grep names each file once with its lines under it, the changes header keeps its position whole, and the bash teardown tests stop flaking on macOS

- grep groups its lines under each file, the layout of rg --heading, rather than repeating the
  path on every line: 9–28% fewer bytes than rg -n on the searches measured. scopes: true labels
  each run of matches with the function or type around it.
- The changes pane's header shortens the path rather than cut its position, and keeps a gap
  before the FILE / DIFF switch.
- The bash teardown tests count a loop still running as a survivor, not one write already under
  way when the kill landed.
This commit is contained in:
Evan Whittaker
2026-10-18 09:18:05 -05:00
parent 7b460ab9c7
commit 933c1195b4
23 changed files with 673 additions and 163 deletions

View File

@@ -16,9 +16,14 @@ changes add to that section until it ships; `scripts/version-check.py` holds the
- Editing a file with the edit or write tool, or format-on-save rewriting it, keeps the file's - Editing a file with the edit or write tool, or format-on-save rewriting it, keeps the file's
permissions, so an edited script stays executable. A kept mode is now exact rather than trimmed permissions, so an edited script stays executable. A kept mode is now exact rather than trimmed
by the umask. by the umask.
- The changes pane's header keeps its position (`8 of 14`) whole, shortening the path instead, and
keeps a gap between the line counts and the FILE / DIFF switch.
### Changed ### Changed
- `grep` names each file once with its matching lines under it, rather than repeating the path on
every line: 9–28% fewer bytes than `rg -n` on the searches measured. `scopes: true` also labels
each run of matches with the function or type around it.
- The install guide leads with `curl -fsSL https://luxe.dev/install.sh | sh` and - The install guide leads with `curl -fsSL https://luxe.dev/install.sh | sh` and
`powershell -c "irm https://luxe.dev/install.ps1 | iex"`. `powershell -c "irm https://luxe.dev/install.ps1 | iex"`.

View File

@@ -164,8 +164,9 @@ async fn main() -> anyhow::Result<()> {
/// The tools a session registers, minus the ones that wait on a person or a debugger. /// The tools a session registers, minus the ones that wait on a person or a debugger.
fn registry(cwd: &std::path::Path) -> luxe_core::ToolRegistry { fn registry(cwd: &std::path::Path) -> luxe_core::ToolRegistry {
let mut registry = luxe_core::ToolRegistry::new(); let mut registry = luxe_core::ToolRegistry::new();
let tracker = let web = luxe_tools::web::WebConfig::from_env();
luxe_tools::register_builtins(&mut registry, None, luxe_tools::web::WebConfig::from_env()); let outline = Arc::new(luxe_lsp::syntax::SyntaxOutline);
let tracker = luxe_tools::register_builtins(&mut registry, None, web, Some(outline));
let lsp = Arc::new(luxe_lsp::WorkspaceLspClient::with_servers(Default::default())); let lsp = Arc::new(luxe_lsp::WorkspaceLspClient::with_servers(Default::default()));
let graph = Arc::new(luxe_lsp::graph::GraphService::new(cwd)); let graph = Arc::new(luxe_lsp::graph::GraphService::new(cwd));
registry.register(Arc::new( registry.register(Arc::new(

View File

@@ -252,7 +252,10 @@ pub(super) fn build_tool_registry(
clone_repositories: luxe_core::config::Config::load(state_root).tools.clone_repositories(), clone_repositories: luxe_core::config::Config::load(state_root).tools.clone_repositories(),
..luxe_tools::web::WebConfig::from_env() ..luxe_tools::web::WebConfig::from_env()
}; };
let read_tracker = luxe_tools::register_builtins(&mut registry, Some(todo_root), web); // tree-sitter, so `grep` can say which function or type each match sits in
let outline = Arc::new(luxe_lsp::syntax::SyntaxOutline);
let read_tracker =
luxe_tools::register_builtins(&mut registry, Some(todo_root), web, Some(outline));
if loop_driven { if loop_driven {
registry.register(Arc::new(luxe_tools::loop_control::LoopControlTool::new())); registry.register(Arc::new(luxe_tools::loop_control::LoopControlTool::new()));
} }

View File

@@ -4552,7 +4552,7 @@ group: "Using Luxe"
| `write`, `edit` | Write or change a file. A file must be read before it is edited, and the card shows the diff, after [formatting](#format-on-save). | | `write`, `edit` | Write or change a file. A file must be read before it is edited, and the card shows the diff, after [formatting](#format-on-save). |
| `bash` | Run a shell command. Long output is trimmed, and the untouched output saved under `.luxe/artifacts/`: each stream whole up to 8 MB, or its first and last 4 MB past that. | | `bash` | Run a shell command. Long output is trimmed, and the untouched output saved under `.luxe/artifacts/`: each stream whole up to 8 MB, or its first and last 4 MB past that. |
| `test` | Run the project's tests and report each failure with its `file:line`, and which tests your change broke. Output is saved as `bash`'s is. | | `test` | Run the project's tests and report each failure with its `file:line`, and which tests your change broke. Output is saved as `bash`'s is. |
| `grep`, `glob` | Search file contents and names, with capped output | | `grep`, `glob` | Search file contents and names, with capped output. `grep` names each file once with its matching lines under it, and can say which function or type each match sits in. |
| `ast_grep` | Search and replace by code structure. Needs [ast-grep](https://ast-grep.github.io). | | `ast_grep` | Search and replace by code structure. Needs [ast-grep](https://ast-grep.github.io). |
| `git` | Status, diffs, history, commits, branches, and GitHub pull requests, issues and CI checks through `gh` | | `git` | Status, diffs, history, commits, branches, and GitHub pull requests, issues and CI checks through `gh` |
| `todo` | The agent's checklist, shown in the dock's **PLAN** | | `todo` | The agent's checklist, shown in the dock's **PLAN** |

View File

@@ -15,7 +15,7 @@
mod standards; mod standards;
pub use standards::{FunctionSize, OutlineSource}; pub use standards::{FunctionSize, OutlineSource, Scope};
use crate::formatter::FormatterRegistry; use crate::formatter::FormatterRegistry;
use crate::hook::{Hook, HookCtx, HookEvent, HookOutcome, HookPoint}; use crate::hook::{Hook, HookCtx, HookEvent, HookOutcome, HookPoint};

View File

@@ -20,6 +20,24 @@ const MAX_NAMED: usize = 5;
pub trait OutlineSource: Send + Sync { pub trait OutlineSource: Send + Sync {
/// The functions and methods in `source`, or `None` for a language it cannot parse. /// The functions and methods in `source`, or `None` for a language it cannot parse.
fn functions(&self, path: &Path, source: &str) -> Option<Vec<FunctionSize>>; fn functions(&self, path: &Path, source: &str) -> Option<Vec<FunctionSize>>;
/// The named scopes in `source` that can hold code: functions, methods, types and modules,
/// not fields or constants. `None` for a language it cannot parse, which is also the default.
/// A search labels what it found with the scopes around it.
fn scopes(&self, _path: &Path, _source: &str) -> Option<Vec<Scope>> {
None
}
}
/// One named scope and the lines it spans, 0-based and inclusive.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Scope {
/// The bare name, `delete` or `QuerySet`
pub name: String,
/// Its first line, where its declaration starts
pub start_line: usize,
/// Its last line
pub end_line: usize,
} }
/// One function's name, qualified by its container where it has one, and its length. /// One function's name, qualified by its container where it has one, and its length.

View File

@@ -247,6 +247,17 @@ fn symbol_kind(def_kind: &str, container_kind: Option<&str>) -> u32 {
} }
} }
/// The kinds that can hold code, and so name where a line sits: not fields, variants or constants.
const SCOPE_KINDS: [u32; 7] = [
kinds::FUNCTION,
kinds::METHOD,
kinds::CLASS,
kinds::STRUCT,
kinds::ENUM,
kinds::INTERFACE,
kinds::MODULE,
];
/// Function lengths for the size standards the edit hook holds, from the same outline /// Function lengths for the size standards the edit hook holds, from the same outline
/// `module_report` draws. /// `module_report` draws.
pub struct SyntaxOutline; pub struct SyntaxOutline;
@@ -272,6 +283,25 @@ impl luxe_core::hooks::file_changed::OutlineSource for SyntaxOutline {
.collect(), .collect(),
) )
} }
fn scopes(
&self,
path: &Path,
source: &str,
) -> Option<Vec<luxe_core::hooks::file_changed::Scope>> {
let symbols = outline(path, source)?;
Some(
symbols
.into_iter()
.filter(|symbol| SCOPE_KINDS.contains(&symbol.kind))
.map(|symbol| luxe_core::hooks::file_changed::Scope {
name: symbol.name,
start_line: symbol.start_line as usize,
end_line: symbol.end_line as usize,
})
.collect(),
)
}
} }
#[cfg(test)] #[cfg(test)]
@@ -337,6 +367,19 @@ mod tests {
assert_eq!(method.kind, kinds::METHOD); assert_eq!(method.kind, kinds::METHOD);
} }
/// The scopes a search labels with are the ones that hold code, with the lines they span: a
/// class and its method, not the attribute beside them.
#[test]
fn scopes_are_the_code_holding_symbols_and_their_spans() {
use luxe_core::hooks::file_changed::{OutlineSource, Scope};
let src = "class QuerySet:\n model = None\n\n def delete(self):\n return 1\n";
let scopes = SyntaxOutline.scopes(Path::new("query.py"), src).expect("python parses");
let scope =
|name: &str, start_line, end_line| Scope { name: name.into(), start_line, end_line };
assert_eq!(scopes, vec![scope("QuerySet", 0, 4), scope("delete", 3, 4)]);
assert_eq!(SyntaxOutline.scopes(Path::new("notes.md"), "# hi"), None);
}
#[test] #[test]
fn unsupported_language_returns_none() { fn unsupported_language_returns_none() {
assert!(outline(Path::new("notes.md"), "# hi").is_none()); assert!(outline(Path::new("notes.md"), "# hi").is_none());

View File

@@ -442,10 +442,18 @@ mod tree_teardown {
format!("(for _ in $(seq 1 40); do touch {}; sleep 0.25; done) & wait", marker.display()) format!("(for _ in $(seq 1 40); do touch {}; sleep 0.25; done) & wait", marker.display())
} }
/// Whether anything is still touching `marker` after it is removed. /// Whether anything is still touching `marker`, the loop, once a touch that was already under
/// way has had its moment.
///
/// The kill reaches the whole group at once, but a `touch` forked as it lands can finish one
/// write after it, and on macOS's slower teardown that write can follow the first clear. One
/// straggling write is not a survivor; a loop still running touches again within a quarter
/// second of the second clear.
async fn survivor_still_running(marker: &std::path::Path) -> bool { async fn survivor_still_running(marker: &std::path::Path) -> bool {
let _ = std::fs::remove_file(marker); let _ = std::fs::remove_file(marker);
tokio::time::sleep(Duration::from_millis(1_200)).await; tokio::time::sleep(Duration::from_millis(300)).await;
let _ = std::fs::remove_file(marker);
tokio::time::sleep(Duration::from_millis(1_000)).await;
marker.exists() marker.exists()
} }

View File

@@ -4,16 +4,21 @@
//! it is opened, and the approved files are scanned in parallel with `regex`. An external `rg` //! it is opened, and the approved files are scanned in parallel with `regex`. An external `rg`
//! could not do the middle step, which is the one that keeps denied content out of the answer. //! could not do the middle step, which is the one that keeps denied content out of the answer.
//! //!
//! The result is bounded `file:line:text`, with optional context lines and a glob filter — or, //! The rows are bounded `file:line:text`, with optional context lines and a glob filter — or,
//! where the question is coarser than the lines, the files that match or a count per file. //! where the question is coarser than the lines, the files that match or a count per file. Lines
//! reach the model grouped under their file: the path once rather than on every line. Asked to
//! (`scopes`), each run of matches is labeled with the function or type around it, where an
//! outline can say, so where a match sits needs no read to find out.
use async_trait::async_trait; use async_trait::async_trait;
use luxe_core::hooks::file_changed::{OutlineSource, Scope};
use luxe_core::{ContentBlock, Tool, ToolContext, ToolResultData, ToolSchema}; use luxe_core::{ContentBlock, Tool, ToolContext, ToolResultData, ToolSchema};
use serde_json::json; use serde_json::json;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use tracing::warn; use tracing::warn;
mod guarded; mod guarded;
mod present;
#[cfg(test)] #[cfg(test)]
mod read_policy_tests; mod read_policy_tests;
@@ -21,7 +26,9 @@ mod read_policy_tests;
fn grep_schema() -> ToolSchema { fn grep_schema() -> ToolSchema {
ToolSchema { ToolSchema {
name: "grep".to_string(), name: "grep".to_string(),
description: "Search file *contents* by regex. Returns `file:line:text`, bounded \ description: "Search file *contents* by regex. Returns each matching file's path once \
with its `line:text` rows under it; `scopes: true` also names the function \
or type around each match, as `[QuerySet › delete]`. Bounded \
— a broad pattern says it was capped instead of flooding your context. Case \ — a broad pattern says it was capped instead of flooding your context. Case \
is sensitive unless the pattern says otherwise: prefix `(?i)`. Skips ignored \ is sensitive unless the pattern says otherwise: prefix `(?i)`. Skips ignored \
paths (`.gitignore`, `.git/`, build output); set `all: true` to include \ paths (`.gitignore`, `.git/`, build output); set `all: true` to include \
@@ -50,7 +57,7 @@ fn grep_schema() -> ToolSchema {
"outputMode": { "outputMode": {
"type": "string", "type": "string",
"enum": ["content", "files", "count"], "enum": ["content", "files", "count"],
"description": "What to return: 'content' (file:line:text, the default), \ "description": "What to return: 'content' (matching lines under each file, the default), \
'files' (one path per matching file), or 'count' (file:count \ 'files' (one path per matching file), or 'count' (file:count \
of matching lines). Prefer 'files' when you only need to know \ of matching lines). Prefer 'files' when you only need to know \
where to look." where to look."
@@ -76,6 +83,13 @@ fn grep_schema() -> ToolSchema {
"type": "boolean", "type": "boolean",
"description": "Return the lines that do NOT match the pattern. Default false." "description": "Return the lines that do NOT match the pattern. Default false."
}, },
"scopes": {
"type": "boolean",
"description": "Name the function or type each match sits in, for code a \
parser reads. Costs a row per change of scope; worth it \
when *where* a match is matters, as for call sites. \
Default false."
},
"all": { "all": {
"type": "boolean", "type": "boolean",
"description": "Include ignored files (build output, vendored deps). Default false." "description": "Include ignored files (build output, vendored deps). Default false."
@@ -148,6 +162,44 @@ impl OutputMode {
} }
} }
/// One row a search found, kept whole until the answer is laid out.
#[derive(Debug, Clone)]
struct Hit {
/// The file, relative to where the search ran
file: std::sync::Arc<str>,
kind: HitKind,
/// 1-based line, for a match or a context row
line: usize,
/// The line itself, or the number of matching lines for [`HitKind::Count`]
text: String,
/// The scopes around a match, outermost first, `QuerySet › delete`, where an outline can say
scope: Option<String>,
}
/// What a [`Hit`] is.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum HitKind {
Match,
Context,
/// A file with a match, in the files mode
File,
/// A file's number of matching lines, in the count mode
Count,
}
impl Hit {
/// The row as ripgrep prints it, which the caps measure: `file:line:text`, `file-line-text`
/// for context, a bare path, or `file:count`.
fn flat(&self) -> String {
match self.kind {
HitKind::Match => format!("{}:{}:{}", self.file, self.line, self.text),
HitKind::Context => format!("{}-{}-{}", self.file, self.line, self.text),
HitKind::File => self.file.to_string(),
HitKind::Count => format!("{}:{}", self.file, self.text),
}
}
}
/// One parsed search. /// One parsed search.
/// ///
/// `limit` is deliberately *not* consulted while searching. Stopping early would make the total the /// `limit` is deliberately *not* consulted while searching. Stopping early would make the total the
@@ -162,17 +214,22 @@ struct Search<'a> {
after: usize, after: usize,
all: bool, all: bool,
invert: bool, invert: bool,
/// Label each match with the scopes around it, where an outline can read the file
scopes: bool,
mode: OutputMode, mode: OutputMode,
limit: usize, limit: usize,
} }
/// What `search` finds under `cwd`, unguarded, as the tests ask it. /// What `search` finds under `cwd`, unguarded and as ripgrep would print it, as the tests ask it.
#[cfg(test)] #[cfg(test)]
fn native_search(cwd: &Path, search: &Search<'_>) -> Result<Vec<String>, String> { fn native_search(cwd: &Path, search: &Search<'_>) -> Result<Vec<String>, String> {
native_search_files(cwd, search, crate::walk::files(cwd, search.path, search.all), || false) let paths = crate::walk::files(cwd, search.path, search.all);
let hits = native_search_files(cwd, search, paths, None, || false)?;
Ok(hits.iter().map(Hit::flat).collect())
} }
/// Scans `paths` (relative to `cwd`) for `search`, in parallel, rows in path order. /// Scans `paths` (relative to `cwd`) for `search`, in parallel, rows in path order, each match
/// labeled with its scopes where `outline` can parse the file.
/// ///
/// Each worker takes a contiguous run of the sorted paths and the runs are joined in order, so the /// Each worker takes a contiguous run of the sorted paths and the runs are joined in order, so the
/// answer reads the same however many threads produced it. `stopped` is checked between files. /// answer reads the same however many threads produced it. `stopped` is checked between files.
@@ -180,8 +237,9 @@ fn native_search_files(
cwd: &Path, cwd: &Path,
search: &Search<'_>, search: &Search<'_>,
paths: Vec<PathBuf>, paths: Vec<PathBuf>,
outline: Option<&dyn OutlineSource>,
stopped: impl Fn() -> bool + Sync, stopped: impl Fn() -> bool + Sync,
) -> Result<Vec<String>, String> { ) -> Result<Vec<Hit>, String> {
let regex = regex::Regex::new(search.pattern) let regex = regex::Regex::new(search.pattern)
.map_err(|error| format!("'{}' is not a valid regex: {error}", search.pattern))?; .map_err(|error| format!("'{}' is not a valid regex: {error}", search.pattern))?;
let prefilter = prefilter(search); let prefilter = prefilter(search);
@@ -199,7 +257,7 @@ fn native_search_files(
let workers = std::thread::available_parallelism().map_or(1, usize::from).min(16); let workers = std::thread::available_parallelism().map_or(1, usize::from).min(16);
let run = paths.len().div_ceil(workers).max(1); let run = paths.len().div_ceil(workers).max(1);
// a worker is `Err` when it panicked, `Ok(None)` when it was stopped // a worker is `Err` when it panicked, `Ok(None)` when it was stopped
let scanned: Vec<std::thread::Result<Option<Vec<String>>>> = std::thread::scope(|scope| { let scanned: Vec<std::thread::Result<Option<Vec<Hit>>>> = std::thread::scope(|scope| {
let handles: Vec<_> = paths let handles: Vec<_> = paths
.chunks(run) .chunks(run)
.map(|chunk| { .map(|chunk| {
@@ -210,7 +268,8 @@ fn native_search_files(
if stopped() { if stopped() {
return None; return None;
} }
rows.extend(search_file(cwd, relative, (regex, prefilter), search)); let matcher = (regex, prefilter);
rows.extend(search_file(cwd, relative, matcher, search, outline));
} }
Some(rows) Some(rows)
}) })
@@ -223,9 +282,9 @@ fn native_search_files(
/// The workers' rows joined in order; a crashed worker is a failure, a stopped one a cancel. /// The workers' rows joined in order; a crashed worker is a failure, a stopped one a cancel.
fn combine( fn combine(
scanned: Vec<std::thread::Result<Option<Vec<String>>>>, scanned: Vec<std::thread::Result<Option<Vec<Hit>>>>,
stopped: bool, stopped: bool,
) -> Result<Vec<String>, String> { ) -> Result<Vec<Hit>, String> {
if scanned.iter().any(Result::is_err) { if scanned.iter().any(Result::is_err) {
return Err("a search worker failed; nothing it scanned is reported".into()); return Err("a search worker failed; nothing it scanned is reported".into());
} }
@@ -269,14 +328,15 @@ fn has_lone_carriage_return(text: &str) -> bool {
bytes.iter().enumerate().any(|(at, byte)| *byte == b'\r' && bytes.get(at + 1) != Some(&b'\n')) bytes.iter().enumerate().any(|(at, byte)| *byte == b'\r' && bytes.get(at + 1) != Some(&b'\n'))
} }
/// The rows one file contributes, in the shape ripgrep prints them: `file:line:text` for a match, /// The rows one file contributes: its matching and context lines, or its name or count for the
/// `file-line-text` for context, or the file's name or count for the coarser modes. /// coarser modes. A match is labeled with the scopes around it where `outline` parses the file.
fn search_file( fn search_file(
cwd: &Path, cwd: &Path,
relative: &Path, relative: &Path,
(regex, prefilter): (&regex::Regex, Option<&regex::Regex>), (regex, prefilter): (&regex::Regex, Option<&regex::Regex>),
search: &Search<'_>, search: &Search<'_>,
) -> Vec<String> { outline: Option<&dyn OutlineSource>,
) -> Vec<Hit> {
let Ok(bytes) = std::fs::read(cwd.join(relative)) else { return Vec::new() }; let Ok(bytes) = std::fs::read(cwd.join(relative)) else { return Vec::new() };
if bytes.iter().take(BINARY_SNIFF_BYTES).any(|byte| *byte == 0) { if bytes.iter().take(BINARY_SNIFF_BYTES).any(|byte| *byte == 0) {
return Vec::new(); return Vec::new();
@@ -287,7 +347,7 @@ fn search_file(
if filtered.is_some_and(|prefilter| !prefilter.is_match(&text)) { if filtered.is_some_and(|prefilter| !prefilter.is_match(&text)) {
return Vec::new(); return Vec::new();
} }
let name = luxe_core::paths::display(relative); let file: std::sync::Arc<str> = luxe_core::paths::display(relative).into();
let lines: Vec<&str> = text.lines().collect(); let lines: Vec<&str> = text.lines().collect();
let matched: Vec<usize> = lines let matched: Vec<usize> = lines
.iter() .iter()
@@ -298,45 +358,78 @@ fn search_file(
if matched.is_empty() { if matched.is_empty() {
return Vec::new(); return Vec::new();
} }
let row = |kind, line, text: String| Hit { file: file.clone(), kind, line, text, scope: None };
match search.mode { match search.mode {
OutputMode::Files => vec![name], OutputMode::Files => vec![row(HitKind::File, 0, String::new())],
OutputMode::Count => vec![format!("{name}:{}", matched.len())], OutputMode::Count => vec![row(HitKind::Count, 0, matched.len().to_string())],
OutputMode::Content => { OutputMode::Content => {
// Decide *which* lines to print and *what each one is* separately, then print each let outline = outline.filter(|_| search.scopes);
// once. Doing it per match instead conflates the two: a match inside an earlier let scopes = outline.and_then(|outline| outline.scopes(relative, &text));
// match's trailing context gets emitted as context and never as the answer. line_hits(&lines, &matched, search)
let mut shown = vec![false; lines.len()]; .map(|(index, is_match)| {
for index in &matched { let kind = if is_match { HitKind::Match } else { HitKind::Context };
let first = index.saturating_sub(search.before); let mut hit = row(kind, index + 1, lines[index].to_string());
let last = (index + search.after + 1).min(lines.len()); hit.scope =
shown[first..last].iter_mut().for_each(|slot| *slot = true); scopes.as_deref().filter(|_| is_match).and_then(|s| scope_label(s, index));
} hit
let is_match = |index: usize| matched.binary_search(&index).is_ok();
lines
.iter()
.enumerate()
.filter(|(index, _)| shown[*index])
.map(|(index, line)| {
// `-` marks a context line; the caller's parsers and the model both read the
// `:` rows as the answer
let separator = if is_match(index) { ':' } else { '-' };
format!("{name}{separator}{}{separator}{line}", index + 1)
}) })
.collect() .collect()
} }
} }
} }
/// The lines to show and whether each is a match, in order.
///
/// Decides *which* lines to print and *what each one is* separately, then yields each once. Doing
/// it per match instead conflates the two: a match inside an earlier match's trailing context gets
/// emitted as context and never as the answer.
fn line_hits<'a>(
lines: &'a [&str],
matched: &'a [usize],
search: &Search<'_>,
) -> impl Iterator<Item = (usize, bool)> + 'a {
let mut shown = vec![false; lines.len()];
for index in matched {
let first = index.saturating_sub(search.before);
let last = (index + search.after + 1).min(lines.len());
shown[first..last].iter_mut().for_each(|slot| *slot = true);
}
(0..lines.len())
.filter(move |index| shown[*index])
.map(move |index| (index, matched.binary_search(&index).is_ok()))
}
/// The scopes around 0-based line `line`, outermost first, as `QuerySet › delete`.
///
/// A scope whose declaration starts on the line is left out: the line itself names it, so
/// `def delete(self):` is labeled `QuerySet`, not `QuerySet › delete`.
fn scope_label(scopes: &[Scope], line: usize) -> Option<String> {
let mut around: Vec<&Scope> =
scopes.iter().filter(|scope| scope.start_line < line && line <= scope.end_line).collect();
around.sort_by_key(|scope| (scope.start_line, std::cmp::Reverse(scope.end_line)));
let names: Vec<&str> = around.iter().map(|scope| scope.name.as_str()).collect();
(!names.is_empty()).then(|| names.join(" › "))
}
/// The `grep` tool implementation. /// The `grep` tool implementation.
pub struct GrepTool { pub struct GrepTool {
/// Shared read tracker; a file whose lines a search printed is recorded as read /// Shared read tracker; a file whose lines a search printed is recorded as read
tracker: Option<std::sync::Arc<luxe_core::read_tracker::ReadTracker>>, tracker: Option<std::sync::Arc<luxe_core::read_tracker::ReadTracker>>,
/// What names the scopes a match sits in; without it lines come unlabeled
outline: Option<std::sync::Arc<dyn OutlineSource>>,
} }
impl GrepTool { impl GrepTool {
/// Create a new grep tool instance. /// Create a new grep tool instance.
pub fn new() -> Self { pub fn new() -> Self {
Self { tracker: None } Self { tracker: None, outline: None }
}
/// Attach the outline that labels each match with the function or type around it, a parser
/// that lives outside this crate.
pub fn with_outline(mut self, outline: std::sync::Arc<dyn OutlineSource>) -> Self {
self.outline = Some(outline);
self
} }
/// Attach the shared read tracker, so the lines a search showed satisfy the edit guards the /// Attach the shared read tracker, so the lines a search showed satisfy the edit guards the
@@ -380,6 +473,8 @@ impl Tool for GrepTool {
} }
} }
#[cfg(test)]
mod scope_tests;
#[cfg(test)] #[cfg(test)]
mod search_tests; mod search_tests;
#[cfg(test)] #[cfg(test)]

View File

@@ -48,6 +48,7 @@ pub(super) fn parse_search(args: &serde_json::Value) -> Result<Search<'_>, Strin
after: side("after"), after: side("after"),
all: args.get("all").and_then(|value| value.as_bool()).unwrap_or(false), all: args.get("all").and_then(|value| value.as_bool()).unwrap_or(false),
invert: args.get("invert").and_then(|value| value.as_bool()).unwrap_or(false), invert: args.get("invert").and_then(|value| value.as_bool()).unwrap_or(false),
scopes: args.get("scopes").and_then(|value| value.as_bool()).unwrap_or(false),
// camelCase is advertised; snake_case is what models reach for, and a silently ignored // camelCase is advertised; snake_case is what models reach for, and a silently ignored
// mode returns the expensive answer // mode returns the expensive answer
mode: OutputMode::parse( mode: OutputMode::parse(
@@ -106,16 +107,15 @@ async fn scan(
args: serde_json::Value, args: serde_json::Value,
cx: &ToolContext, cx: &ToolContext,
paths: Vec<PathBuf>, paths: Vec<PathBuf>,
stopped: Arc<AtomicBool>, (outline, stopped): (Option<Arc<dyn OutlineSource>>, Arc<AtomicBool>),
) -> Result<String, String> { ) -> Result<Vec<Hit>, String> {
let cwd = cx.cwd.clone(); let cwd = cx.cwd.clone();
let cancelled = cx.cancelled.clone(); let cancelled = cx.cancelled.clone();
tokio::task::spawn_blocking(move || { tokio::task::spawn_blocking(move || {
let search = parse_search(&args)?; let search = parse_search(&args)?;
super::native_search_files(&cwd, &search, paths, || { super::native_search_files(&cwd, &search, paths, outline.as_deref(), || {
stopped.load(Ordering::Relaxed) || *cancelled.borrow() stopped.load(Ordering::Relaxed) || *cancelled.borrow()
}) })
.map(|rows| rows.join("\n"))
}) })
.await .await
.map_err(|error| format!("grep scan worker failed: {error}"))? .map_err(|error| format!("grep scan worker failed: {error}"))?
@@ -141,7 +141,7 @@ pub(super) async fn run(
Ok(plan) => plan, Ok(plan) => plan,
Err(error) => return ToolResultData::error(error), Err(error) => return ToolResultData::error(error),
}; };
let found = scan(args.clone(), cx, plan.allowed, stopped).await; let found = scan(args.clone(), cx, plan.allowed, (tool.outline.clone(), stopped)).await;
let mut result = finish(tool, cx, &search, found); let mut result = finish(tool, cx, &search, found);
if plan.denied + plan.asks > 0 { if plan.denied + plan.asks > 0 {
result.content.push(ContentBlock::Text(format!( result.content.push(ContentBlock::Text(format!(
@@ -159,20 +159,24 @@ pub(super) fn finish(
tool: &GrepTool, tool: &GrepTool,
cx: &ToolContext, cx: &ToolContext,
search: &Search<'_>, search: &Search<'_>,
found: Result<String, String>, found: Result<Vec<Hit>, String>,
) -> ToolResultData { ) -> ToolResultData {
match found { match found {
Ok(matches) if matches.trim().is_empty() => ToolResultData::text("No matches found"), Ok(hits) if hits.is_empty() => ToolResultData::text("No matches found"),
Ok(matches) => { Ok(hits) if search.mode == OutputMode::Content => {
let bounded = crate::output_limit::cap_lines_within( let (text, shown) = super::present::content(&hits, search);
&matches, record_matches(tool, cx, search, &hits[..shown]);
ToolResultData::text(text)
}
Ok(hits) => {
let rows: Vec<String> = hits.iter().map(Hit::flat).collect();
ToolResultData::text(crate::output_limit::cap_lines_within(
&rows.join("\n"),
search.limit, search.limit,
GREP_MAX_CHARS, GREP_MAX_CHARS,
search.mode.unit(), search.mode.unit(),
search.mode.hint(), search.mode.hint(),
); ))
record_matches(tool, cx, search, &bounded);
ToolResultData::text(bounded)
} }
Err(problem) => { Err(problem) => {
warn!(pattern = search.pattern, error = %problem, "grep failed"); warn!(pattern = search.pattern, error = %problem, "grep failed");
@@ -181,15 +185,18 @@ pub(super) fn finish(
} }
} }
fn record_matches(tool: &GrepTool, cx: &ToolContext, search: &Search<'_>, bounded: &str) { /// Records as read every file a line of which the answer showed, the way a `read` of it would be.
let (Some(tracker), OutputMode::Content) = (&tool.tracker, search.mode) else { return }; fn record_matches(tool: &GrepTool, cx: &ToolContext, search: &Search<'_>, shown: &[Hit]) {
let Some(tracker) = &tool.tracker else { return };
let searched = cx.cwd.join(search.path); let searched = cx.cwd.join(search.path);
let shown = if searched.is_file() { let files: Vec<PathBuf> = match searched.is_file() {
vec![searched] true => vec![searched],
} else { false => shown.iter().map(|hit| cx.cwd.join(&*hit.file)).collect(),
crate::bash::seen::files_in_rows(bounded, &cx.cwd)
}; };
for path in shown { let mut recorded = std::collections::HashSet::new();
for path in files {
if recorded.insert(path.clone()) {
tracker.record(&cx.session_id, &path); tracker.record(&cx.session_id, &path);
} }
}
} }

View File

@@ -0,0 +1,106 @@
//! Present — a content search laid out for reading: each file named once, its lines under it, and
//! the scope around a run of matches where an outline can say.
//!
//! The rows are counted and capped as ripgrep would print them, `file:line:text`, so the bounds and
//! the totals are the ones the other modes keep. Only the layout changes. A path repeated on every
//! line is a large share of a broad search, and the function a match sits in is what the next
//! `read` would have gone to find out.
use super::{Hit, HitKind, Search, GREP_MAX_CHARS};
/// The capped, grouped answer, and how many of `hits` it shows.
pub(super) fn content(hits: &[Hit], search: &Search<'_>) -> (String, usize) {
let lengths = hits.iter().map(|hit| hit.flat().chars().count());
let kept = crate::output_limit::lines_within(lengths, search.limit, GREP_MAX_CHARS);
let shown = grouped(&hits[..kept], search.before + search.after > 0);
let text = match kept < hits.len() {
true => crate::output_limit::with_note(
&shown,
hits.len() - kept,
hits.len(),
search.mode.unit(),
search.mode.hint(),
),
false => crate::output_limit::clamp(&shown),
};
(text, kept)
}
/// `hits` under their files: the path, then `line:text` for a match and `line-text` for context,
/// ` [Scope › name]` before a match whose scope differs from the last one's, and `--` where
/// context leaves a gap.
fn grouped(hits: &[Hit], context: bool) -> String {
let mut out: Vec<String> = Vec::new();
let mut previous: Option<&Hit> = None;
let mut scope: Option<&str> = None;
for hit in hits {
match previous {
Some(last) if last.file == hit.file => {
if context && hit.line > last.line + 1 {
out.push("--".into());
}
}
_ => {
out.push(hit.file.to_string());
scope = None;
}
}
if hit.kind == HitKind::Match && hit.scope.as_deref() != scope {
out.push(scope_row(hit.scope.as_deref()));
scope = hit.scope.as_deref();
}
let separator = if hit.kind == HitKind::Match { ':' } else { '-' };
out.push(format!("{}{separator}{}", hit.line, hit.text));
previous = Some(hit);
}
out.join("\n")
}
/// ` [QuerySet › delete]`, or ` [top level]` for a match that has left the scopes before it.
fn scope_row(scope: Option<&str>) -> String {
format!(" [{}]", scope.unwrap_or("top level"))
}
#[cfg(test)]
mod tests {
use super::*;
fn hit(file: &str, kind: HitKind, line: usize, text: &str, scope: Option<&str>) -> Hit {
let (file, text, scope) = (file.into(), text.to_string(), scope.map(String::from));
Hit { file, kind, line, text, scope }
}
/// Each file is named once, its lines under it, and a scope row comes only where it changes.
#[test]
fn matches_group_under_their_file_with_a_row_per_change_of_scope() {
let hits = [
hit("a.py", HitKind::Match, 3, " def delete(self):", Some("QuerySet")),
hit("a.py", HitKind::Match, 9, " def delete_all(self):", Some("QuerySet")),
hit("a.py", HitKind::Match, 20, "def delete(): pass", None),
hit("b.py", HitKind::Match, 5, " delete()", Some("Model › save")),
];
let expected = "a.py\n [QuerySet]\n3: def delete(self):\n9: def delete_all(self):\n \
[top level]\n20:def delete(): pass\nb.py\n [Model › save]\n5: delete()";
assert_eq!(grouped(&hits, false), expected);
}
/// A file no outline can read gets no scope rows at all, rather than a `[top level]` that
/// would claim to know.
#[test]
fn an_unlabeled_file_gets_no_scope_rows() {
let hits = [hit("notes.md", HitKind::Match, 1, "delete it", None)];
assert_eq!(grouped(&hits, false), "notes.md\n1:delete it");
}
/// Context lines take `-`, and a gap between runs of context is marked `--`.
#[test]
fn context_rows_take_a_dash_and_a_gap_is_marked() {
let hits = [
hit("a.rs", HitKind::Match, 2, "needle", None),
hit("a.rs", HitKind::Context, 3, "after", None),
hit("a.rs", HitKind::Match, 9, "needle", None),
];
assert_eq!(grouped(&hits, true), "a.rs\n2:needle\n3-after\n--\n9:needle");
assert_eq!(grouped(&hits, false), "a.rs\n2:needle\n3-after\n9:needle", "no context asked");
}
}

View File

@@ -0,0 +1,77 @@
use super::*;
use luxe_core::hooks::file_changed::FunctionSize;
use std::sync::Arc;
use tokio::sync::{mpsc, watch};
/// A stand-in for the tree-sitter outline: in a `.py` file, a class over lines 1–9 (0-based 0–8)
/// with a method over lines 3–6, and nothing it can read in any other file.
struct OneClass;
impl OutlineSource for OneClass {
fn functions(&self, _: &Path, _: &str) -> Option<Vec<FunctionSize>> {
None
}
fn scopes(&self, path: &Path, _: &str) -> Option<Vec<Scope>> {
let scope =
|name: &str, start_line, end_line| Scope { name: name.into(), start_line, end_line };
(path.extension()? == "py").then(|| vec![scope("QuerySet", 0, 8), scope("delete", 2, 5)])
}
}
fn context(cwd: &Path) -> ToolContext {
let (event_tx, _event_rx) = mpsc::channel(64);
let (_cancel_tx, cancel_rx) = watch::channel(false);
ToolContext {
cwd: cwd.to_path_buf(),
session_id: "test-session".to_string(),
cancelled: Arc::new(cancel_rx),
event_tx,
hook_ctx: None,
question_broker: None,
}
}
/// Each match is labeled with the scopes around it, outermost first, and only where the label
/// changes. The definition line takes its parent's label, since it names itself; a file no outline
/// can read gets no label at all; and the path comes once, above its lines.
#[tokio::test]
async fn a_match_is_labeled_with_the_scopes_around_it() {
let dir = tempfile::tempdir().unwrap();
let python =
"class QuerySet:\n \n def delete(self):\n self.delete_batch()\n \
return self\n \n \nOTHER = 1\n \ndef delete():\n pass\n";
std::fs::write(dir.path().join("a.py"), python).unwrap();
std::fs::write(dir.path().join("notes.md"), "delete it\n").unwrap();
let tool = GrepTool::new().with_outline(Arc::new(OneClass));
let args = json!({"pattern": "delete", "scopes": true});
let result = tool.run(args, &context(dir.path())).await;
let ContentBlock::Text(text) = &result.content[0] else { panic!("expected text") };
let expected = "a.py\n [QuerySet]\n3: def delete(self):\n [QuerySet › delete]\n4: \
self.delete_batch()\n [top level]\n10:def delete():\nnotes.md\n1:delete it";
assert_eq!(text, expected);
}
/// Labels cost a row each, so a search without `scopes` gets the grouped lines alone, outline or
/// not.
#[tokio::test]
async fn a_search_is_unlabeled_unless_it_asks() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("a.py"), "class A:\n \n def delete(self):\n").unwrap();
let tool = GrepTool::new().with_outline(Arc::new(OneClass));
let result = tool.run(json!({"pattern": "delete"}), &context(dir.path())).await;
let ContentBlock::Text(text) = &result.content[0] else { panic!("expected text") };
assert_eq!(text, "a.py\n3: def delete(self):");
}
/// The coarse modes have no lines to label, so they ask nothing of the outline.
#[tokio::test]
async fn the_files_mode_carries_no_scopes() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("a.py"), "class A:\n def delete(self): pass\n").unwrap();
let tool = GrepTool::new().with_outline(Arc::new(OneClass));
let args = json!({"pattern": "delete", "outputMode": "files"});
let result = tool.run(args, &context(dir.path())).await;
let ContentBlock::Text(text) = &result.content[0] else { panic!("expected text") };
assert_eq!(text.trim(), "a.py");
}

View File

@@ -17,6 +17,7 @@ fn base(pattern: &str) -> Search<'_> {
after: 0, after: 0,
all: false, all: false,
invert: false, invert: false,
scopes: false,
mode: OutputMode::Content, mode: OutputMode::Content,
limit: 500, limit: 500,
} }
@@ -147,10 +148,20 @@ fn the_prefilter_never_hides_a_matching_line() {
/// A worker that crashed is a failure the caller hears about; one that was stopped is a cancel. /// A worker that crashed is a failure the caller hears about; one that was stopped is a cancel.
#[test] #[test]
fn a_crashed_worker_is_a_failure_not_a_cancel() { fn a_crashed_worker_is_a_failure_not_a_cancel() {
let rows = |row: &str| Ok(Some(vec![row.to_string()])); let rows = |file: &str| {
let crashed: std::thread::Result<Option<Vec<String>>> = Err(Box::new("boom")); let hit = Hit {
file: file.into(),
kind: HitKind::File,
line: 0,
text: String::new(),
scope: None,
};
Ok(Some(vec![hit]))
};
let crashed: std::thread::Result<Option<Vec<Hit>>> = Err(Box::new("boom"));
let failed = combine(vec![rows("a"), crashed], false).unwrap_err(); let failed = combine(vec![rows("a"), crashed], false).unwrap_err();
assert!(failed.contains("worker failed"), "{failed}"); assert!(failed.contains("worker failed"), "{failed}");
assert_eq!(combine(vec![rows("a"), Ok(None)], false).unwrap_err(), "grep cancelled"); assert_eq!(combine(vec![rows("a"), Ok(None)], false).unwrap_err(), "grep cancelled");
assert_eq!(combine(vec![rows("a"), rows("b")], false).unwrap(), ["a", "b"]); let joined = combine(vec![rows("a"), rows("b")], false).unwrap();
assert_eq!(joined.iter().map(Hit::flat).collect::<Vec<_>>(), ["a", "b"]);
} }

View File

@@ -17,6 +17,13 @@ fn test_context(tmp_dir: &std::path::Path) -> ToolContext {
} }
} }
/// The matching-line rows of a content answer, `12:text`, not the paths or scope rows around them.
fn match_rows(text: &str) -> usize {
text.lines()
.filter(|line| line.split_once(':').is_some_and(|(n, _)| n.parse::<usize>().is_ok()))
.count()
}
/// A plain content search of `.`, for a test to vary one field of. /// A plain content search of `.`, for a test to vary one field of.
fn search<'a>(pattern: &'a str) -> Search<'a> { fn search<'a>(pattern: &'a str) -> Search<'a> {
Search { Search {
@@ -27,6 +34,7 @@ fn search<'a>(pattern: &'a str) -> Search<'a> {
after: 0, after: 0,
all: false, all: false,
invert: false, invert: false,
scopes: false,
mode: OutputMode::Content, mode: OutputMode::Content,
limit: GREP_MAX_LINES, limit: GREP_MAX_LINES,
} }
@@ -246,7 +254,7 @@ async fn a_zero_limit_is_an_absent_limit() {
.run(json!({"pattern": "needle", "limit": 0}), &test_context(dir.path())) .run(json!({"pattern": "needle", "limit": 0}), &test_context(dir.path()))
.await; .await;
let ContentBlock::Text(text) = &result.content[0] else { panic!("expected text") }; let ContentBlock::Text(text) = &result.content[0] else { panic!("expected text") };
assert_eq!(text.lines().count(), 20, "every match, not none: {text}"); assert_eq!(match_rows(text), 20, "every match, not none: {text}");
assert!(!text.contains("not shown"), "and nothing was cut: {text}"); assert!(!text.contains("not shown"), "and nothing was cut: {text}");
} }
@@ -282,16 +290,12 @@ async fn a_limit_can_only_tighten_the_cap() {
let sampled = GrepTool::new().run(json!({"pattern": "needle", "limit": 5}), &cx).await; let sampled = GrepTool::new().run(json!({"pattern": "needle", "limit": 5}), &cx).await;
let ContentBlock::Text(text) = &sampled.content[0] else { panic!("expected text") }; let ContentBlock::Text(text) = &sampled.content[0] else { panic!("expected text") };
assert_eq!(text.lines().filter(|line| line.contains("many.txt")).count(), 5, "{text}"); assert_eq!(match_rows(text), 5, "{text}");
assert!(text.contains("295 more matching lines not shown (300 total)"), "{text}"); assert!(text.contains("295 more matching lines not shown (300 total)"), "{text}");
let greedy = GrepTool::new().run(json!({"pattern": "needle", "limit": 5000}), &cx).await; let greedy = GrepTool::new().run(json!({"pattern": "needle", "limit": 5000}), &cx).await;
let ContentBlock::Text(text) = &greedy.content[0] else { panic!("expected text") }; let ContentBlock::Text(text) = &greedy.content[0] else { panic!("expected text") };
assert_eq!( assert_eq!(match_rows(text), GREP_MAX_LINES, "a limit past the ceiling is the ceiling: {text}");
text.lines().filter(|line| line.contains("many.txt")).count(),
GREP_MAX_LINES,
"a limit past the ceiling is the ceiling: {text}"
);
} }
/// The count a capped result reports is the count that exists, not the count that was kept. /// The count a capped result reports is the count that exists, not the count that was kept.

View File

@@ -49,6 +49,9 @@ pub mod write;
/// The `todo` tool requires a store root (e.g. `.luxe/todos`). Pass `None` to skip registering it. /// The `todo` tool requires a store root (e.g. `.luxe/todos`). Pass `None` to skip registering it.
/// `web` configures `web_search` and `web_fetch`; [`web::WebConfig::from_env`] is the usual start. /// `web` configures `web_search` and `web_fetch`; [`web::WebConfig::from_env`] is the usual start.
/// ///
/// `outline` labels each `grep` match with the function or type around it; it is a parser this
/// crate cannot depend on (tree-sitter lives in `luxe-lsp`), and `None` leaves matches unlabeled.
///
/// Returns the shared [`luxe_core::read_tracker::ReadTracker`] backing the read-before-edit / /// Returns the shared [`luxe_core::read_tracker::ReadTracker`] backing the read-before-edit /
/// staleness / blind-write guards, so the caller can also wire it into the LSP funnel reads /// staleness / blind-write guards, so the caller can also wire it into the LSP funnel reads
/// (`read_symbol`, `module_report`) that see file content but live in a crate that can't depend /// (`read_symbol`, `module_report`) that see file content but live in a crate that can't depend
@@ -57,6 +60,7 @@ pub fn register_builtins(
registry: &mut luxe_core::ToolRegistry, registry: &mut luxe_core::ToolRegistry,
todo_store_root: Option<std::path::PathBuf>, todo_store_root: Option<std::path::PathBuf>,
web: web::WebConfig, web: web::WebConfig,
outline: Option<std::sync::Arc<dyn luxe_core::hooks::file_changed::OutlineSource>>,
) -> std::sync::Arc<luxe_core::read_tracker::ReadTracker> { ) -> std::sync::Arc<luxe_core::read_tracker::ReadTracker> {
use std::sync::Arc; use std::sync::Arc;
// One shared read tracker backs the read-before-edit + staleness + blind-write guards across // One shared read tracker backs the read-before-edit + staleness + blind-write guards across
@@ -76,7 +80,11 @@ pub fn register_builtins(
registry.register(Arc::new(write::WriteTool::new().with_tracker(read_tracker.clone()))); registry.register(Arc::new(write::WriteTool::new().with_tracker(read_tracker.clone())));
registry.register(Arc::new(edit::EditTool::new().with_tracker(read_tracker.clone()))); registry.register(Arc::new(edit::EditTool::new().with_tracker(read_tracker.clone())));
registry.register(Arc::new(bash::BashTool::new().with_tracker(read_tracker.clone()))); registry.register(Arc::new(bash::BashTool::new().with_tracker(read_tracker.clone())));
registry.register(Arc::new(grep::GrepTool::new().with_tracker(read_tracker.clone()))); let grep = grep::GrepTool::new().with_tracker(read_tracker.clone());
registry.register(Arc::new(match outline {
Some(outline) => grep.with_outline(outline),
None => grep,
}));
registry.register(Arc::new(glob::GlobTool::new())); registry.register(Arc::new(glob::GlobTool::new()));
registry.register(Arc::new(question::QuestionTool::new(question::QuestionConfig::default()))); registry.register(Arc::new(question::QuestionTool::new(question::QuestionConfig::default())));
registry.register(Arc::new(skill::SkillTool::new(skill::SkillConfig))); registry.register(Arc::new(skill::SkillTool::new(skill::SkillConfig)));

View File

@@ -37,24 +37,54 @@ pub(crate) fn cap_lines_within(
hint: &str, hint: &str,
) -> String { ) -> String {
let total = text.lines().count(); let total = text.lines().count();
let mut kept_lines = 0usize; let kept_lines =
let mut spent = 0usize; lines_within(text.lines().map(|line| line.chars().count()), max_lines, max_chars);
for line in text.lines().take(max_lines) {
let cost = line.chars().count().saturating_add(1);
if kept_lines > 0 && spent.saturating_add(cost) > max_chars {
break;
}
spent = spent.saturating_add(cost);
kept_lines += 1;
}
if kept_lines >= total { if kept_lines >= total {
return clamp_bytes(text); return clamp_bytes(text);
} }
let kept = text.lines().take(kept_lines).collect::<Vec<_>>().join("\n"); let kept = text.lines().take(kept_lines).collect::<Vec<_>>().join("\n");
let remaining = total - kept_lines; with_note(&kept, total - kept_lines, total, unit, hint)
}
/// How many lines, given each one's length in characters, fit under both `max_lines` and
/// `max_chars`; at least one when there is any, however long it is.
///
/// The cut [`cap_lines_within`] makes, for a tool that lays its lines out after choosing them.
pub(crate) fn lines_within(
lengths: impl IntoIterator<Item = usize>,
max_lines: usize,
max_chars: usize,
) -> usize {
let mut kept = 0usize;
let mut spent = 0usize;
for length in lengths.into_iter().take(max_lines) {
let cost = length.saturating_add(1);
if kept > 0 && spent.saturating_add(cost) > max_chars {
break;
}
spent = spent.saturating_add(cost);
kept += 1;
}
kept
}
/// `kept`, then the note that `remaining` more of `total` were cut and how to see them, clamped to
/// the byte backstop.
pub(crate) fn with_note(
kept: &str,
remaining: usize,
total: usize,
unit: &str,
hint: &str,
) -> String {
clamp_bytes(&format!("{kept}\n\n… {remaining} more {unit} not shown ({total} total). {hint}")) clamp_bytes(&format!("{kept}\n\n… {remaining} more {unit} not shown ({total} total). {hint}"))
} }
/// [`clamp_bytes`] for a tool that caps its own lines first.
pub(crate) fn clamp(text: &str) -> String {
clamp_bytes(text)
}
/// Head+tail byte clamp for the rare single-huge-line case the line cap can't shrink. /// Head+tail byte clamp for the rare single-huge-line case the line cap can't shrink.
fn clamp_bytes(text: &str) -> String { fn clamp_bytes(text: &str) -> String {
if text.len() <= MAX_OUTPUT_BYTES { if text.len() <= MAX_OUTPUT_BYTES {

View File

@@ -19,25 +19,75 @@ use unicode_width::UnicodeWidthStr;
/// there are others and that stepping is a thing you can do, which is what the footer's bracket /// there are others and that stepping is a thing you can do, which is what the footer's bracket
/// keys then explain. /// keys then explain.
pub(super) fn render_header(frame: &mut Frame, area: Rect, app: &App, view: &ChangesView) { pub(super) fn render_header(frame: &mut Frame, area: Rect, app: &App, view: &ChangesView) {
let styles = &app.theme_styles; let line = header_line(app, view, area);
let entry = view.current(); frame.render_widget(Paragraph::new(line), Rect { height: 1, ..area });
let width = usize::from(area.width); if area.height > 1 {
frame.render_widget(
Block::default().borders(Borders::TOP).border_style(app.theme_styles.border_muted),
Rect { y: area.y + 1, height: 1, ..area },
);
}
}
let position = match (view.position(), view.files.len()) { /// Cells kept between the file's details and the FILE / DIFF switch, so its slab never touches them.
const SWITCH_GAP: usize = 2;
/// The least of a path worth showing: below this the position goes before the path does.
const PATH_FLOOR: usize = 8;
/// The header's one line, laid out so it fits: every fixed part is measured first and the path gets
/// what they leave. When even a stub of path will not fit, the position goes whole, never `8 of`.
fn header_line(app: &App, view: &ChangesView, area: Rect) -> Line<'static> {
let width = usize::from(area.width);
let entry = view.current();
let lead = lead_span(app, view, entry);
let details = detail_spans(app, view, entry);
let tabs = match view.changed() {
true => view_tabs(view.view, app),
false => ViewTabs::default(),
};
let mut position = position_label(view);
let fixed = |position: &str| {
let tail = tabs.width() + position_cells(position);
cells(std::slice::from_ref(&lead)) + cells(&details) + tail + SWITCH_GAP
};
if fixed(&position) + PATH_FLOOR > width {
position.clear();
}
// Cut from the left: the tail of a path is the file, which is the thing being named. A file
// outside the project arrives absolute and is said the way a person would say it
let budget = width.saturating_sub(fixed(&position)).max(PATH_FLOOR);
let path = truncate_path_left(&home_relative(&view.path), budget);
let mut spans =
vec![lead, Span::styled(path, app.theme_styles.text.add_modifier(Modifier::BOLD))];
spans.extend(details);
push_tail(&mut spans, (app, area), tabs, position);
Line::from(spans)
}
/// `8 of 14`, or nothing for a single file.
fn position_label(view: &ChangesView) -> String {
match (view.position(), view.files.len()) {
(Some(index), total) if total > 1 => format!("{} of {total}", index + 1), (Some(index), total) if total > 1 => format!("{} of {total}", index + 1),
_ => String::new(), _ => String::new(),
}; }
let counts = entry.and_then(count_label).unwrap_or_default(); }
// Give the path whatever the fixed parts leave, and cut it from the left: the tail of a path
// is the file, which is the thing being named. A file outside the project arrives absolute and
// is said the way a person would say it, which is also what tells the reader at a glance that
// they are not looking at project code.
let reserved = position.chars().count() + counts.chars().count() + 6;
let titled = home_relative(&view.path);
let path = truncate_path_left(&titled, width.saturating_sub(reserved).max(8));
// A changed file leads with its git letter; any other file with the mark of its language /// The position's cells with the two that part it from the switch, or none when it is absent.
let lead = match entry { fn position_cells(position: &str) -> usize {
match position.is_empty() {
true => 0,
false => position.width() + 2,
}
}
fn cells(spans: &[Span<'_>]) -> usize {
spans.iter().map(|span| UnicodeWidthStr::width(span.content.as_ref())).sum()
}
/// A changed file leads with its git letter; any other file with the mark of its language.
fn lead_span(app: &App, view: &ChangesView, entry: Option<&ChangedFile>) -> Span<'static> {
let styles = &app.theme_styles;
match entry {
Some(file) => { Some(file) => {
Span::styled(format!("{} ", marker_of(file.status)), status_style(file.status, app)) Span::styled(format!("{} ", marker_of(file.status)), status_style(file.status, app))
} }
@@ -49,10 +99,13 @@ pub(super) fn render_header(frame: &mut Frame, area: Rect, app: &App, view: &Cha
crate::widgets::language_hue(icon, styles), crate::widgets::language_hue(icon, styles),
) )
} }
}; }
let mut spans = vec![lead]; }
spans.push(Span::styled(path, styles.text.add_modifier(Modifier::BOLD)));
// What the File view is showing: how long it is, and that it was cut short when it was /// What follows the path: the File view's length (and that it was cut short), and `+6 −8`.
fn detail_spans(app: &App, view: &ChangesView, entry: Option<&ChangedFile>) -> Vec<Span<'static>> {
let styles = &app.theme_styles;
let mut spans = Vec::new();
if let (PeekView::File, crate::changes::TextLoad::Ready(file)) = (view.view, &view.text) { if let (PeekView::File, crate::changes::TextLoad::Ready(file)) = (view.view, &view.text) {
let lines = file.text.lines().count(); let lines = file.text.lines().count();
let mut meta = format!(" {lines} line{}", if lines == 1 { "" } else { "s" }); let mut meta = format!(" {lines} line{}", if lines == 1 { "" } else { "s" });
@@ -66,39 +119,39 @@ pub(super) fn render_header(frame: &mut Frame, area: Rect, app: &App, view: &Cha
spans.push(Span::styled(format!(" +{additions}"), styles.success)); spans.push(Span::styled(format!(" +{additions}"), styles.success));
spans.push(Span::styled(format!(" −{deletions}"), styles.error)); spans.push(Span::styled(format!(" −{deletions}"), styles.error));
} }
// A changed file has two faces, and the one not showing is a click away spans
let tabs = match view.changed() { }
true => view_tabs(view.view, app),
false => ViewTabs::default(), /// The switch and the position, pushed to the right edge with at least [`SWITCH_GAP`] before them,
}; /// and the hidden face of the switch published as the click that flips the view.
let tabs_width: usize = tabs.spans.iter().map(|span| span.content.width()).sum(); fn push_tail(
let used: usize = spans.iter().map(|span| UnicodeWidthStr::width(span.content.as_ref())).sum(); spans: &mut Vec<Span<'static>>,
let tail = tabs_width + position.chars().count() + usize::from(!position.is_empty()) * 2; (app, area): (&App, Rect),
if tail > 0 { tabs: ViewTabs,
let pad = width.saturating_sub(used + tail); position: String,
) {
let tail = tabs.width() + position_cells(&position);
if tail == 0 {
return;
}
let used = cells(spans);
let pad = usize::from(area.width).saturating_sub(used + tail).max(SWITCH_GAP);
spans.push(Span::raw(" ".repeat(pad))); spans.push(Span::raw(" ".repeat(pad)));
let tabs_at = used + pad; publish_switch(app, area, used + pad, tabs.other);
if let Some((start, cells)) = tabs.other {
if let (Ok(x), Ok(cells)) = (u16::try_from(tabs_at + start), u16::try_from(cells)) {
app.hit.borrow_mut().push(
Rect::new(area.x + x, area.y, cells, 1),
MouseTarget::ChangesFooter(ChangesFooterAction::ToggleView),
);
}
}
spans.extend(tabs.spans); spans.extend(tabs.spans);
if !position.is_empty() { if !position.is_empty() {
spans.push(Span::raw(" ")); spans.push(Span::raw(" "));
spans.push(Span::styled(position, styles.muted)); spans.push(Span::styled(position, app.theme_styles.muted));
}
} }
}
frame.render_widget(Paragraph::new(Line::from(spans)), Rect { height: 1, ..area }); /// Publishes the switch's hidden face, `other` cells into a switch drawn at column `at`, as the
if area.height > 1 { /// click that flips the view.
frame.render_widget( fn publish_switch(app: &App, area: Rect, at: usize, other: Option<(usize, usize)>) {
Block::default().borders(Borders::TOP).border_style(styles.border_muted), let Some((start, width)) = other else { return };
Rect { y: area.y + 1, height: 1, ..area }, if let (Ok(x), Ok(width)) = (u16::try_from(at + start), u16::try_from(width)) {
); let target = MouseTarget::ChangesFooter(ChangesFooterAction::ToggleView);
app.hit.borrow_mut().push(Rect::new(area.x + x, area.y, width, 1), target);
} }
} }
@@ -110,6 +163,12 @@ struct ViewTabs {
other: Option<(usize, usize)>, other: Option<(usize, usize)>,
} }
impl ViewTabs {
fn width(&self) -> usize {
cells(&self.spans)
}
}
/// `FILE DIFF`, both cut into badges: the showing face lit, the other on the idle surface. /// `FILE DIFF`, both cut into badges: the showing face lit, the other on the idle surface.
/// ///
/// Both in capitals and both slabs, so the pair reads as a switch with two positions rather than a /// Both in capitals and both slabs, so the pair reads as a switch with two positions rather than a
@@ -160,12 +219,6 @@ pub(super) fn sentence(message: &str) -> String {
}) })
} }
/// `+6 −8`, or nothing at all when git could not count (a binary blob).
fn count_label(file: &ChangedFile) -> Option<String> {
let (additions, deletions) = file.additions.zip(file.deletions)?;
Some(format!(" +{additions} −{deletions}"))
}
fn marker_of(status: luxe_core::FileChangeStatus) -> &'static str { fn marker_of(status: luxe_core::FileChangeStatus) -> &'static str {
use luxe_core::FileChangeStatus as Status; use luxe_core::FileChangeStatus as Status;
match status { match status {

View File

@@ -171,13 +171,13 @@ ChangesWide@100x30: frame=7f799b893667c928 hits=5ebcfa50c83c624f
ChangesWide@64x20: frame=3531cf4c1d3f2402 hits=a39e334a4bdaa029 ChangesWide@64x20: frame=3531cf4c1d3f2402 hits=a39e334a4bdaa029
ChangesNarrow@140x44: frame=4d45021ad9fb0fa7 hits=de2158bdae6d8dfb ChangesNarrow@140x44: frame=4d45021ad9fb0fa7 hits=de2158bdae6d8dfb
ChangesNarrow@100x30: frame=2ee7cc81d7896506 hits=6dca1cfbcba4056a ChangesNarrow@100x30: frame=2ee7cc81d7896506 hits=6dca1cfbcba4056a
ChangesNarrow@64x20: frame=903e59bd8b8a62f8 hits=98deec46c37135b8 ChangesNarrow@64x20: frame=b82352043f680144 hits=65afb8e6ea7f4981
ChangesFailed@140x44: frame=b8c525886e754d21 hits=88e878b841c4ee77 ChangesFailed@140x44: frame=b8c525886e754d21 hits=88e878b841c4ee77
ChangesFailed@100x30: frame=aba8595c8158cca4 hits=d3e7f3e0ab644214 ChangesFailed@100x30: frame=aba8595c8158cca4 hits=d3e7f3e0ab644214
ChangesFailed@64x20: frame=69cdcefbe785c866 hits=27476cdcd9937bea ChangesFailed@64x20: frame=8d0caaba450a4f3a hits=e16f1ab1fbfea007
ChangesExternal@140x44: frame=fc75aaae10ddb262 hits=d5c3115642e748ad ChangesExternal@140x44: frame=fc75aaae10ddb262 hits=d5c3115642e748ad
ChangesExternal@100x30: frame=522c8250b0f50ac4 hits=3dd17e6200cfb4b5 ChangesExternal@100x30: frame=522c8250b0f50ac4 hits=3dd17e6200cfb4b5
ChangesExternal@64x20: frame=a6d2706231364207 hits=6f0e8da295aaa965 ChangesExternal@64x20: frame=d257ba5dbedfc85f hits=a8e0be5b4625e2bc
ChatTools+palette: frame=85cc5ae977de2fa6 hits=ca2a2a735278a5bd ChatTools+palette: frame=85cc5ae977de2fa6 hits=ca2a2a735278a5bd
ChatTools+slash: frame=a3ce4c3a7d03f8d0 hits=8adf06de80ecdcb2 ChatTools+slash: frame=a3ce4c3a7d03f8d0 hits=8adf06de80ecdcb2
ChatTools+mention: frame=33c4a73f189a3dcc hits=c1b8d78b51a767b7 ChatTools+mention: frame=33c4a73f189a3dcc hits=c1b8d78b51a767b7
@@ -219,7 +219,7 @@ ChatWideProse searching: frame=1878156c08a54641 hits=00e988aa75182c51
ChatWideProse selecting: frame=8c1edde42c1f3700 hits=bddfef30519a2a3a ChatWideProse selecting: frame=8c1edde42c1f3700 hits=bddfef30519a2a3a
ChatWideProse copied: frame=7757bb42f647c93e hits=bddfef30519a2a3a ChatWideProse copied: frame=7757bb42f647c93e hits=bddfef30519a2a3a
ChangesWide@180x44: frame=2f39ea02da654a31 hits=e9b01340cccc666e ChangesWide@180x44: frame=2f39ea02da654a31 hits=e9b01340cccc666e
ChangesNarrow unwrapped: frame=d83dfbbe3d21abf8 hits=29eecb5dbf51e195 ChangesNarrow unwrapped: frame=13da9745cf50215c hits=c84985bf30e3251e
ChangesWide file: frame=4292536a789062da hits=da530d7bf2c94fdf ChangesWide file: frame=4292536a789062da hits=da530d7bf2c94fdf
ChangesWide file cursor: frame=aacfd7dfe8f072f0 hits=6293b97445fe71a6 ChangesWide file cursor: frame=aacfd7dfe8f072f0 hits=6293b97445fe71a6
ChangesWide file unwrapped: frame=cbf79ee6830376c5 hits=316acbdf05625e0b ChangesWide file unwrapped: frame=cbf79ee6830376c5 hits=316acbdf05625e0b

View File

@@ -517,3 +517,43 @@ fn the_pane_wraps_long_lines_without_being_asked() {
assert!(!clipped.contains(tail), "clipped now: {clipped}"); assert!(!clipped.contains(tail), "clipped now: {clipped}");
assert!(clipped.contains('…'), "and marked as clipped: {clipped}"); assert!(clipped.contains('…'), "and marked as clipped: {clipped}");
} }
/// The header's position is whole or absent, never `8 of`: the path is what gives way, and a gap
/// always parts the line counts from the FILE / DIFF switch. The path used to be measured against
/// everything but the switch, so the line ran long and lost its last part, the position.
#[test]
fn the_changes_header_keeps_its_position_whole_and_its_switch_apart() {
use luxe_tui::fixture::FixtureScenario::{ChangesNarrow, ChangesWide};
// Below about 128 columns the dock lies over the pane, so narrower widths drop the dock
let wide = [(ChangesWide, 172u16), (ChangesWide, 140)];
for (scenario, width) in wide.into_iter().chain((44..=110).map(|width| (ChangesNarrow, width)))
{
let (buffer, row, text) = changes_header(scenario, width);
let end = text.trim_end();
let cut = [" 8", " 8 o", " 8 of", " 8 of 1"].iter().any(|cut| end.ends_with(cut));
assert!(!cut, "{width}: the position was cut: {text}");
// Plain background in the two cells after the counts, before the FILE slab begins
let counts = column_of(&text, "−9");
let plain = buffer[(counts - 1, row)].bg;
for x in counts + 2..counts + 4 {
assert_eq!(buffer[(x, row)].bg, plain, "{width}: no gap before the switch: {text}");
}
}
// As wide as the guide's shot, the position shows
let wide = changes_header(ChangesWide, 172).2;
assert!(wide.contains("8 of 14"), "{wide}");
}
/// A guide diff scene at `width` columns: the frame, its header row, and that row's text.
fn changes_header(
scenario: luxe_tui::fixture::FixtureScenario,
width: u16,
) -> (ratatui::buffer::Buffer, u16, String) {
let backend = test_backend(width, 50);
let mut app = luxe_tui::fixture::seeded_app("luxe", scenario).expect("the fixture");
app.update(Msg::TerminalResized { width, height: 50 });
let buffer = render_app(&mut app, &backend);
let row = row_containing(&buffer, "DIFF", width, 50);
let text = row_text(&buffer, row, width);
(buffer, row, text)
}

View File

@@ -13,7 +13,7 @@ group: "Using Luxe"
| `write`, `edit` | Write or change a file. A file must be read before it is edited, and the card shows the diff, after [formatting](#format-on-save). | | `write`, `edit` | Write or change a file. A file must be read before it is edited, and the card shows the diff, after [formatting](#format-on-save). |
| `bash` | Run a shell command. Long output is trimmed, and the untouched output saved under `.luxe/artifacts/`: each stream whole up to 8 MB, or its first and last 4 MB past that. | | `bash` | Run a shell command. Long output is trimmed, and the untouched output saved under `.luxe/artifacts/`: each stream whole up to 8 MB, or its first and last 4 MB past that. |
| `test` | Run the project's tests and report each failure with its `file:line`, and which tests your change broke. Output is saved as `bash`'s is. | | `test` | Run the project's tests and report each failure with its `file:line`, and which tests your change broke. Output is saved as `bash`'s is. |
| `grep`, `glob` | Search file contents and names, with capped output | | `grep`, `glob` | Search file contents and names, with capped output. `grep` names each file once with its matching lines under it, and can say which function or type each match sits in. |
| `ast_grep` | Search and replace by code structure. Needs [ast-grep](https://ast-grep.github.io). | | `ast_grep` | Search and replace by code structure. Needs [ast-grep](https://ast-grep.github.io). |
| `git` | Status, diffs, history, commits, branches, and GitHub pull requests, issues and CI checks through `gh` | | `git` | Status, diffs, history, commits, branches, and GitHub pull requests, issues and CI checks through `gh` |
| `todo` | The agent's checklist, shown in the dock's **PLAN** | | `todo` | The agent's checklist, shown in the dock's **PLAN** |

View File

@@ -5,14 +5,14 @@
<rect x="100" y="0" width="10" height="22" fill="#aa9467"/> <rect x="100" y="0" width="10" height="22" fill="#aa9467"/>
<rect x="110" y="0" width="10" height="22" fill="#786849"/> <rect x="110" y="0" width="10" height="22" fill="#786849"/>
<rect x="120" y="0" width="10" height="22" fill="#453c2c"/> <rect x="120" y="0" width="10" height="22" fill="#453c2c"/>
<rect x="860" y="0" width="70" height="22" fill="#2f2d2a"/> <rect x="840" y="0" width="70" height="22" fill="#2f2d2a"/>
<rect x="930" y="0" width="10" height="22" fill="#282623"/> <rect x="910" y="0" width="10" height="22" fill="#282623"/>
<rect x="940" y="0" width="10" height="22" fill="#211f1c"/> <rect x="920" y="0" width="10" height="22" fill="#211f1c"/>
<rect x="950" y="0" width="10" height="22" fill="#191715"/> <rect x="930" y="0" width="10" height="22" fill="#191715"/>
<rect x="970" y="0" width="70" height="22" fill="#8c7a55"/> <rect x="950" y="0" width="70" height="22" fill="#8c7a55"/>
<rect x="1040" y="0" width="10" height="22" fill="#6e6043"/> <rect x="1020" y="0" width="10" height="22" fill="#6e6043"/>
<rect x="1050" y="0" width="10" height="22" fill="#4f4532"/> <rect x="1030" y="0" width="10" height="22" fill="#4f4532"/>
<rect x="1060" y="0" width="10" height="22" fill="#312b20"/> <rect x="1040" y="0" width="10" height="22" fill="#312b20"/>
<rect x="0" y="88" width="70" height="22" fill="#8c7a55"/> <rect x="0" y="88" width="70" height="22" fill="#8c7a55"/>
<rect x="70" y="88" width="10" height="22" fill="#6e6043"/> <rect x="70" y="88" width="10" height="22" fill="#6e6043"/>
<rect x="80" y="88" width="10" height="22" fill="#4f4532"/> <rect x="80" y="88" width="10" height="22" fill="#4f4532"/>
@@ -552,7 +552,7 @@
<path fill="none" stroke="#ddc084" stroke-width="1.25" d="M1705.00 1089.00L1710.00 1089.00M1705.00 1089.00L1700.00 1089.00"/> <path fill="none" stroke="#ddc084" stroke-width="1.25" d="M1705.00 1089.00L1710.00 1089.00M1705.00 1089.00L1700.00 1089.00"/>
<path fill="none" stroke="#ddc084" stroke-width="1.25" d="M1715.00 1078.00Q1715.00 1089.00 1710.00 1089.00"/> <path fill="none" stroke="#ddc084" stroke-width="1.25" d="M1715.00 1078.00Q1715.00 1089.00 1710.00 1089.00"/>
</g> </g>
<text x="0" y="17.0" textLength="1720" lengthAdjust="spacingAndGlyphs" xml:space="preserve"><tspan> </tspan><tspan fill="#12100e" font-weight="700">PROJECT</tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan fill="#faaa51">M </tspan><tspan fill="#e4dfd6" font-weight="700">crates/luxe-tui/src/view/dock.rs</tspan><tspan fill="#81caa0"> +48</tspan><tspan fill="#e68485"> −9</tspan><tspan> </tspan><tspan fill="#97938c">FILE</tspan><tspan> </tspan><tspan fill="#e4dfd6" font-weight="700">DIFF</tspan><tspan> </tspan><tspan fill="#97938c">8 of </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan></text> <text x="0" y="17.0" textLength="1720" lengthAdjust="spacingAndGlyphs" xml:space="preserve"><tspan> </tspan><tspan fill="#12100e" font-weight="700">PROJECT</tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan fill="#faaa51">M </tspan><tspan fill="#e4dfd6" font-weight="700">…s/luxe-tui/src/view/dock.rs</tspan><tspan fill="#81caa0"> +48</tspan><tspan fill="#e68485"> −9</tspan><tspan> </tspan><tspan fill="#97938c">FILE</tspan><tspan> </tspan><tspan fill="#e4dfd6" font-weight="700">DIFF</tspan><tspan> </tspan><tspan fill="#97938c">8 of 14</tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan></text>
<text x="0" y="39.0" textLength="1720" lengthAdjust="spacingAndGlyphs" xml:space="preserve"><tspan fill="#e4dfd6">󰉋 luxe </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan></text> <text x="0" y="39.0" textLength="1720" lengthAdjust="spacingAndGlyphs" xml:space="preserve"><tspan fill="#e4dfd6">󰉋 luxe </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan></text>
<text x="0" y="61.0" textLength="1720" lengthAdjust="spacingAndGlyphs" xml:space="preserve"><tspan fill="#97938c">󰘬 feature/context-dock *</tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan fill="#ddc084">@@ -140,6 +140,8 @@ fn change_lines</tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan></text> <text x="0" y="61.0" textLength="1720" lengthAdjust="spacingAndGlyphs" xml:space="preserve"><tspan fill="#97938c">󰘬 feature/context-dock *</tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan fill="#ddc084">@@ -140,6 +140,8 @@ fn change_lines</tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan></text>
<text x="0" y="83.0" textLength="1720" lengthAdjust="spacingAndGlyphs" xml:space="preserve"><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan fill="#97938c">140 140 </tspan><tspan> </tspan><tspan fill="#d2a5cd">let</tspan><tspan fill="#e4dfd6"> seen </tspan><tspan fill="#97938c">=</tspan><tspan fill="#e4dfd6"> app.review.seen.</tspan><tspan fill="#ddc084">as_ref</tspan><tspan fill="#97938c">();</tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan></text> <text x="0" y="83.0" textLength="1720" lengthAdjust="spacingAndGlyphs" xml:space="preserve"><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan><tspan fill="#97938c">140 140 </tspan><tspan> </tspan><tspan fill="#d2a5cd">let</tspan><tspan fill="#e4dfd6"> seen </tspan><tspan fill="#97938c">=</tspan><tspan fill="#e4dfd6"> app.review.seen.</tspan><tspan fill="#ddc084">as_ref</tspan><tspan fill="#97938c">();</tspan><tspan> </tspan><tspan> </tspan><tspan> </tspan></text>

Before

Width:  |  Height:  |  Size: 89 KiB

After

Width:  |  Height:  |  Size: 89 KiB

View File

@@ -31,8 +31,8 @@
}, },
"shellBytes": 4384, "shellBytes": 4384,
"shellLines": 56, "shellLines": 56,
"toolBytes": 4383, "toolBytes": 3989,
"toolLines": 56, "toolLines": 100,
"forwarded": { "forwarded": {
"pi": 4383, "pi": 4383,
"opencode": 4383, "opencode": 4383,

View File

@@ -65,7 +65,7 @@ const groups: Group[] = [
name: "grep", name: "grep",
instead: "`grep -rn`, `rg`", instead: "`grep -rn`, `rg`",
bench: "grep", bench: "grep",
text: "Capped per file and overall, with long lines trimmed. It can return just the files that match or just the counts, and says so when there's more.", text: "Names each file once with its lines under it, where `rg` repeats the path on every line. Asked to, it says which function or type each match sits in. Skips what read policy denies, caps per file and overall, and says when there's more.",
}, },
{ {
name: "ast_grep", name: "ast_grep",
@@ -249,7 +249,8 @@ const terminal = ["git", "module_report", "glob"].flatMap((id) => rows.get(id) ?
const times = (shell: number, tool: number) => { const times = (shell: number, tool: number) => {
const ratio = shell / tool; const ratio = shell / tool;
if (ratio < 1.1) return "the same"; // Under a tenth less, a multiple reads as "1.0×", so a real saving is given as a share
if (ratio < 1.1) return tool <= shell * 0.95 ? `${Math.round((1 - tool / shell) * 100)}% less` : "the same";
return ratio < 10 ? `${ratio.toFixed(1)}× less` : `${Math.round(ratio).toLocaleString("en-US")}× less`; return ratio < 10 ? `${ratio.toFixed(1)}× less` : `${Math.round(ratio).toLocaleString("en-US")}× less`;
}; };
/** Luxe against the tightest cut another agent makes, said both ways round. */ /** Luxe against the tightest cut another agent makes, said both ways round. */