@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/rg-wrapper/core.js

@@ -1,6 +1,714 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.classifyRgArgs=l,exports.runBrgRaw=A,exports.runBrgRawInherited=L,exports.runBrgOptimizedModel=F,exports.runBrgFormatted=T,exports.buildRgJsonArgs=_,exports.parseRgJsonModel=v,exports.formatBrgSearchModel=y;const f=require("node:child_process"),c=require("../tool-runtime/runtime-tools"),w=new Set(["--json","--vimgrep","--files","--count","--count-matches","--files-with-matches","--files-without-match","--passthru","--stats","--only-matching","--pretty"]),S=new Set(["-o","-c","-l"]),d=new Set(["--replace","-r"]),R=new Set(["--no-config","--line-number","--column","--ignore-case","--case-sensitive","--smart-case","--word-regexp","--fixed-strings","--hidden","--no-hidden","--no-ignore","--no-ignore-vcs","--no-ignore-parent","--no-ignore-global","--no-ignore-dot","--follow","--unrestricted"]),b=new Set(["--glob","--iglob","--type","--type-not","--after-context","--before-context","--context","--max-count","--regexp"]),N=new Set(["-n","-i","-s","-S","-w","-F","-u"]),h=new Set(["-g","-t","-T","-A","-B","-C","-e","-m"]);function l(e,n={}){const s=$(e),r=n.hasStdin===!0,t=s.filter(a=>!a.positional).map(a=>a.name),o=s.filter(a=>a.positional).map(a=>a.value??""),i=s.filter(a=>!a.positional&&!G(a)).map(a=>a.name),u={hasStdin:r,hasPattern:H(s)||o.length>0,optionTerminated:e.includes("--"),flags:t,positionals:o,unsupportedFlags:i};return s.some(a=>a.name==="--json")?{mode:"raw",reason:"explicit-json",features:u}:s.some(a=>w.has(a.name)||S.has(a.name))?{mode:"raw",reason:"alternate-output",features:u}:s.some(a=>d.has(a.name))?{mode:"raw",reason:"output-transform",features:u}:s.some(a=>a.name==="--color"&&a.value==="always")?{mode:"raw",reason:"ansi-output",features:u}:r?{mode:"raw",reason:"stdin",features:u}:i.length>0?{mode:"raw",reason:"unknown-flag",features:u}:u.hasPattern?{mode:"optimizable",reason:"text-search-v1",features:u}:{mode:"raw",reason:"missing-pattern",features:u}}function A(e){const n=l(e.args,{hasStdin:e.stdinText!==void 0}),s=g(e.env),r=p(s),t=(0,f.spawnSync)(r,e.args,{cwd:e.cwd,input:e.stdinText,encoding:"utf8",windowsHide:!0,shell:(0,c.shouldUseShellForTool)(r),env:s,maxBuffer:64*1024*1024}),o=typeof t.status=="number"?t.status:t.error?2:1;return{ok:o===0,command:"rg",exitCode:o,stdout:t.stdout??"",stderr:t.stderr??(t.error?`${t.error.message}
-`:""),signal:t.signal??null,spawnError:t.error?t.error.message:null,classification:n}}function L(e){const n=l(e.args,{hasStdin:e.hasStdin===!0}),s=g(e.env),r=p(s),t=(0,f.spawnSync)(r,e.args,{cwd:e.cwd,stdio:"inherit",windowsHide:!0,shell:(0,c.shouldUseShellForTool)(r),env:s}),o=typeof t.status=="number"?t.status:t.error?2:1;return{ok:o===0,command:"rg",exitCode:o,stdout:"",stderr:t.error?`${t.error.message}
-`:"",signal:t.signal??null,spawnError:t.error?t.error.message:null,classification:n}}function F(e){const n=l(e.args,{hasStdin:e.stdinText!==void 0});if(n.mode!=="optimizable")throw new Error(`Cannot build optimized rg model for ${n.reason}.`);const s=g(e.env),r=p(s),t=(0,f.spawnSync)(r,_(e.args),{cwd:e.cwd,input:e.stdinText,encoding:"utf8",windowsHide:!0,shell:(0,c.shouldUseShellForTool)(r),env:s,maxBuffer:64*1024*1024}),o=typeof t.status=="number"?t.status:t.error?2:1;return{ok:o===0,command:"rg",exitCode:o,files:v(t.stdout??""),stderr:t.stderr??(t.error?`${t.error.message}
-`:""),signal:t.signal??null,spawnError:t.error?t.error.message:null,classification:n}}function g(e){return{...process.env,...e}}function p(e){return(0,c.resolveToolRuntime)({tool:"rg",envVar:(0,c.toolRuntimeEnvVar)("rg"),env:e}).executable}function T(e,n={}){const s=l(e.args,{hasStdin:e.stdinText!==void 0});if(n.enabled===!1||s.mode!=="optimizable")return A(e);const r=F(e);return{ok:r.ok,command:"rg",exitCode:r.exitCode,stdout:r.files.length===0?"":y(r,{...n,omitSingleFileHeader:n.omitSingleFileHeader===!0,showColumn:n.showColumn===!0,trimLineStart:n.trimLineStart===!0})+`
-`,stderr:r.stderr,signal:r.signal,spawnError:r.spawnError,classification:s}}function _(e){return e.includes("--json")?[...e]:["--json",...e]}function v(e){const n=new Map;for(const s of e.split(/\r?\n/)){if(!s.trim())continue;const r=JSON.parse(s);if(r.type!=="match"&&r.type!=="context")continue;const t=x(r.data?.path?.text);if(!t)continue;const o=j(n,t),i={lineNumber:m(r.data?.line_number),text:x(r.data?.lines?.text),absoluteOffset:m(r.data?.absolute_offset),submatches:U(r.data?.submatches)};r.type==="match"?o.matches.push(i):o.contexts.push(i)}return[...n.values()]}function y(e,n={}){if(e.files.length===0)return`(exit ${e.exitCode}, no matches)`;const s=[],r=n.omitSingleFileHeader===!0&&e.files.length===1;for(const t of e.files){r||s.push(`${(n.formatPath??(o=>o))(t.path)}:`);for(const o of M(t)){const i=n.trimLineStart===!0?o.text.trimStart():o.text;s.push(`${O(o,n)}${i.trimEnd()}`)}}return s.join(`
-`)}function M(e){return[...e.matches.map(s=>({...s,kind:"match"})),...e.contexts.map(s=>({...s,kind:"context"}))].sort((s,r)=>{const t=s.lineNumber??Number.MAX_SAFE_INTEGER,o=r.lineNumber??Number.MAX_SAFE_INTEGER;return t!==o?t-o:s.kind==="context"&&r.kind==="match"?-1:1})}function O(e,n){const s=e.kind==="match"?":":"-",r=e.lineNumber===null?"?":String(e.lineNumber);if(n.showColumn===!0&&e.kind==="match"){const t=e.submatches[0];if(t)return`${r}${s}${t.start+1}:`}return`${r}${s}`}function $(e){const n=[];let s=!1;for(let r=0;r<e.length;r+=1){const t=e[r]??"";if(s){n.push({name:"positional",value:t,positional:!0});continue}if(t==="--"){s=!0;continue}if(!t.startsWith("-")||t==="-"){n.push({name:"positional",value:t,positional:!0});continue}if(t.startsWith("--")){const[i,u]=C(t);if(u!==void 0){n.push({name:i,value:u});continue}if(E(i)){n.push({name:i,value:e[r+1]??""}),r+=1;continue}n.push({name:i});continue}const o=B(t,e[r+1]);n.push(...o.tokens),r+=o.consumedNext?1:0}return n}function B(e,n){const s=`-${e[1]??""}`;if(h.has(s)||d.has(s)){const t=e.slice(2);return{tokens:[{name:s,value:t||n||""}],consumedNext:t.length===0}}const r=[];for(const t of e.slice(1))r.push({name:`-${t}`});return{tokens:r,consumedNext:!1}}function C(e){const n=e.indexOf("=");return n<0?[e,void 0]:[e.slice(0,n),e.slice(n+1)]}function E(e){return b.has(e)||h.has(e)||d.has(e)||e==="--color"}function G(e){return e.positional?!0:E(e.name)&&e.value===""?!1:e.name==="--color"?e.value==="always"||e.value==="auto"||e.value==="never":w.has(e.name)||S.has(e.name)||d.has(e.name)||R.has(e.name)||b.has(e.name)||N.has(e.name)||h.has(e.name)}function H(e){return e.some(n=>n.name==="-e"||n.name==="--regexp")}function j(e,n){const s=e.get(n);if(s)return s;const r={path:n,matches:[],contexts:[]};return e.set(n,r),r}function x(e){return typeof e=="string"?e:""}function m(e){return typeof e=="number"&&Number.isFinite(e)?e:null}function U(e){return Array.isArray(e)?e.flatMap(n=>{if(!n||typeof n!="object"||Array.isArray(n))return[];const s=n,r=x(s.match?.text),t=m(s.start),o=m(s.end);return t===null||o===null?[]:[{text:r,start:t,end:o}]}):[]}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyRgArgs = classifyRgArgs;
+exports.runBrgRaw = runBrgRaw;
+exports.runBrgRawAsync = runBrgRawAsync;
+exports.runBrgRawInherited = runBrgRawInherited;
+exports.runBrgOptimizedModel = runBrgOptimizedModel;
+exports.runBrgOptimizedModelAsync = runBrgOptimizedModelAsync;
+exports.runBrgFormatted = runBrgFormatted;
+exports.runBrgFormattedAsync = runBrgFormattedAsync;
+exports.buildRgJsonArgs = buildRgJsonArgs;
+exports.parseRgJsonModel = parseRgJsonModel;
+exports.formatBrgSearchModel = formatBrgSearchModel;
+const node_child_process_1 = require("node:child_process");
+const buffered_process_1 = require("../runtime/buffered-process");
+const runtime_tools_1 = require("../tool-runtime/runtime-tools");
+const RAW_LONG_FLAGS = new Set([
+    "--json",
+    "--vimgrep",
+    "--files",
+    "--count",
+    "--count-matches",
+    "--files-with-matches",
+    "--files-without-match",
+    "--passthru",
+    "--stats",
+    "--only-matching",
+    "--pretty"
+]);
+const RAW_SHORT_FLAGS = new Set(["-o", "-c", "-l"]);
+const OUTPUT_TRANSFORM_VALUE_FLAGS = new Set(["--replace", "-r"]);
+const SAFE_LONG_FLAGS = new Set([
+    "--no-config",
+    "--line-number",
+    "--column",
+    "--ignore-case",
+    "--case-sensitive",
+    "--smart-case",
+    "--word-regexp",
+    "--fixed-strings",
+    "--hidden",
+    "--no-hidden",
+    "--no-ignore",
+    "--no-ignore-vcs",
+    "--no-ignore-parent",
+    "--no-ignore-global",
+    "--no-ignore-dot",
+    "--follow",
+    "--unrestricted"
+]);
+const SAFE_LONG_VALUE_FLAGS = new Set([
+    "--glob",
+    "--iglob",
+    "--type",
+    "--type-not",
+    "--after-context",
+    "--before-context",
+    "--context",
+    "--max-count",
+    "--regexp"
+]);
+const SAFE_SHORT_FLAGS = new Set(["-n", "-i", "-s", "-S", "-w", "-F", "-u"]);
+const SAFE_SHORT_VALUE_FLAGS = new Set(["-g", "-t", "-T", "-A", "-B", "-C", "-e", "-m"]);
+function classifyRgArgs(args, options = {}) {
+    const tokens = scanRgArgs(args);
+    const hasStdin = options.hasStdin === true;
+    const flags = tokens.filter((token) => !token.positional).map((token) => token.name);
+    const positionals = tokens.filter((token) => token.positional).map((token) => token.value ?? "");
+    const unsupportedFlags = tokens
+        .filter((token) => !token.positional && !isSupportedFlag(token))
+        .map((token) => token.name);
+    const features = {
+        hasStdin,
+        hasPattern: hasExplicitPattern(tokens) || positionals.length > 0,
+        optionTerminated: args.includes("--"),
+        flags,
+        positionals,
+        unsupportedFlags
+    };
+    if (tokens.some((token) => token.name === "--json")) {
+        return { mode: "raw", reason: "explicit-json", features };
+    }
+    if (tokens.some((token) => RAW_LONG_FLAGS.has(token.name) || RAW_SHORT_FLAGS.has(token.name))) {
+        return { mode: "raw", reason: "alternate-output", features };
+    }
+    if (tokens.some((token) => OUTPUT_TRANSFORM_VALUE_FLAGS.has(token.name))) {
+        return { mode: "raw", reason: "output-transform", features };
+    }
+    if (tokens.some((token) => token.name === "--color" && token.value === "always")) {
+        return { mode: "raw", reason: "ansi-output", features };
+    }
+    if (hasStdin) {
+        return { mode: "raw", reason: "stdin", features };
+    }
+    if (unsupportedFlags.length > 0) {
+        return { mode: "raw", reason: "unknown-flag", features };
+    }
+    if (!features.hasPattern) {
+        return { mode: "raw", reason: "missing-pattern", features };
+    }
+    return { mode: "optimizable", reason: "text-search-v1", features };
+}
+function runBrgRaw(input) {
+    const classification = classifyRgArgs(input.args, { hasStdin: input.stdinText !== undefined });
+    const env = buildBrgEnv(input.env);
+    const executable = resolveRgExecutable(env);
+    const result = (0, node_child_process_1.spawnSync)(executable, input.args, {
+        cwd: input.cwd,
+        input: input.stdinText,
+        encoding: "utf8",
+        windowsHide: true,
+        shell: (0, runtime_tools_1.shouldUseShellForTool)(executable),
+        env,
+        maxBuffer: 64 * 1024 * 1024
+    });
+    const exitCode = typeof result.status === "number" ? result.status : result.error ? 2 : 1;
+    return {
+        ok: exitCode === 0,
+        command: "rg",
+        exitCode,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? (result.error ? `${result.error.message}\n` : ""),
+        signal: result.signal ?? null,
+        spawnError: result.error ? result.error.message : null,
+        classification
+    };
+}
+async function runBrgRawAsync(input, signal) {
+    const classification = classifyRgArgs(input.args, { hasStdin: input.stdinText !== undefined });
+    const env = buildBrgEnv(input.env);
+    const executable = resolveRgExecutable(env);
+    const result = await (0, buffered_process_1.runBufferedProcess)({
+        command: executable,
+        args: input.args,
+        cwd: input.cwd,
+        env,
+        shell: (0, runtime_tools_1.shouldUseShellForTool)(executable),
+        ...(input.stdinText !== undefined ? { input: input.stdinText } : {}),
+        ...(signal ? { signal } : {})
+    });
+    const exitCode = typeof result.status === "number" ? result.status : result.error ? 2 : 1;
+    return {
+        ok: exitCode === 0,
+        command: "rg",
+        exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr || (result.error ? `${result.error.message}\n` : ""),
+        signal: result.signal,
+        spawnError: result.error?.message ?? null,
+        classification
+    };
+}
+function runBrgRawInherited(input) {
+    const classification = classifyRgArgs(input.args, { hasStdin: input.hasStdin === true });
+    const env = buildBrgEnv(input.env);
+    const executable = resolveRgExecutable(env);
+    const result = (0, node_child_process_1.spawnSync)(executable, input.args, {
+        cwd: input.cwd,
+        stdio: "inherit",
+        windowsHide: true,
+        shell: (0, runtime_tools_1.shouldUseShellForTool)(executable),
+        env
+    });
+    const exitCode = typeof result.status === "number" ? result.status : result.error ? 2 : 1;
+    return {
+        ok: exitCode === 0,
+        command: "rg",
+        exitCode,
+        stdout: "",
+        stderr: result.error ? `${result.error.message}\n` : "",
+        signal: result.signal ?? null,
+        spawnError: result.error ? result.error.message : null,
+        classification
+    };
+}
+function runBrgOptimizedModel(input) {
+    const classification = classifyRgArgs(input.args, { hasStdin: input.stdinText !== undefined });
+    if (classification.mode !== "optimizable") {
+        throw new Error(`Cannot build optimized rg model for ${classification.reason}.`);
+    }
+    const env = buildBrgEnv(input.env);
+    const executable = resolveRgExecutable(env);
+    const result = (0, node_child_process_1.spawnSync)(executable, buildRgJsonArgs(input.args), {
+        cwd: input.cwd,
+        input: input.stdinText,
+        encoding: "utf8",
+        windowsHide: true,
+        shell: (0, runtime_tools_1.shouldUseShellForTool)(executable),
+        env,
+        maxBuffer: 64 * 1024 * 1024
+    });
+    const exitCode = typeof result.status === "number" ? result.status : result.error ? 2 : 1;
+    return {
+        ok: exitCode === 0,
+        command: "rg",
+        exitCode,
+        files: parseRgJsonModel(result.stdout ?? ""),
+        stderr: result.stderr ?? (result.error ? `${result.error.message}\n` : ""),
+        signal: result.signal ?? null,
+        spawnError: result.error ? result.error.message : null,
+        classification
+    };
+}
+async function runBrgOptimizedModelAsync(input, signal) {
+    const classification = classifyRgArgs(input.args, { hasStdin: input.stdinText !== undefined });
+    if (classification.mode !== "optimizable")
+        throw new Error(`Cannot build optimized rg model for ${classification.reason}.`);
+    const env = buildBrgEnv(input.env);
+    const executable = resolveRgExecutable(env);
+    const result = await (0, buffered_process_1.runBufferedProcess)({
+        command: executable,
+        args: buildRgJsonArgs(input.args),
+        cwd: input.cwd,
+        env,
+        shell: (0, runtime_tools_1.shouldUseShellForTool)(executable),
+        ...(input.stdinText !== undefined ? { input: input.stdinText } : {}),
+        ...(signal ? { signal } : {})
+    });
+    const exitCode = typeof result.status === "number" ? result.status : result.error ? 2 : 1;
+    return {
+        ok: exitCode === 0,
+        command: "rg",
+        exitCode,
+        files: parseRgJsonModel(result.stdout),
+        stderr: result.stderr || (result.error ? `${result.error.message}\n` : ""),
+        signal: result.signal,
+        spawnError: result.error?.message ?? null,
+        classification
+    };
+}
+function buildBrgEnv(env) {
+    return {
+        ...process.env,
+        ...env
+    };
+}
+function resolveRgExecutable(env) {
+    return (0, runtime_tools_1.resolveToolRuntime)({
+        tool: "rg",
+        envVar: (0, runtime_tools_1.toolRuntimeEnvVar)("rg"),
+        env
+    }).executable;
+}
+function runBrgFormatted(input, options = {}) {
+    const classification = classifyRgArgs(input.args, { hasStdin: input.stdinText !== undefined });
+    if (options.enabled === false || classification.mode !== "optimizable") {
+        return applyBrgOutputCap(input, runBrgRaw(input), options);
+    }
+    const model = runBrgOptimizedModel(input);
+    return applyBrgOutputCap(input, {
+        ok: model.ok,
+        command: "rg",
+        exitCode: model.exitCode,
+        stdout: model.files.length === 0 ? "" : formatBrgSearchModel(model, {
+            ...options,
+            omitSingleFileHeader: options.omitSingleFileHeader === true,
+            showColumn: options.showColumn === true,
+            trimLineStart: options.trimLineStart === true
+        }) + "\n",
+        stderr: model.stderr,
+        signal: model.signal,
+        spawnError: model.spawnError,
+        classification
+    }, options, model);
+}
+async function runBrgFormattedAsync(input, options = {}, signal) {
+    const classification = classifyRgArgs(input.args, { hasStdin: input.stdinText !== undefined });
+    if (options.enabled === false || classification.mode !== "optimizable") {
+        return applyBrgOutputCap(input, await runBrgRawAsync(input, signal), options);
+    }
+    const model = await runBrgOptimizedModelAsync(input, signal);
+    return applyBrgOutputCap(input, {
+        ok: model.ok,
+        command: "rg",
+        exitCode: model.exitCode,
+        stdout: model.files.length === 0 ? "" : formatBrgSearchModel(model, {
+            ...options,
+            omitSingleFileHeader: options.omitSingleFileHeader === true,
+            showColumn: options.showColumn === true,
+            trimLineStart: options.trimLineStart === true
+        }) + "\n",
+        stderr: model.stderr,
+        signal: model.signal,
+        spawnError: model.spawnError,
+        classification
+    }, options, model);
+}
+function buildRgJsonArgs(args) {
+    return args.includes("--json") ? [...args] : ["--json", ...args];
+}
+function parseRgJsonModel(stdout) {
+    const files = new Map();
+    for (const line of stdout.split(/\r?\n/)) {
+        if (!line.trim()) {
+            continue;
+        }
+        const event = JSON.parse(line);
+        if (event.type !== "match" && event.type !== "context") {
+            continue;
+        }
+        const filePath = readText(event.data?.path?.text);
+        if (!filePath) {
+            continue;
+        }
+        const file = getOrCreateModelFile(files, filePath);
+        const lineModel = {
+            lineNumber: readNumber(event.data?.line_number),
+            text: readText(event.data?.lines?.text),
+            absoluteOffset: readNumber(event.data?.absolute_offset),
+            submatches: readSubmatches(event.data?.submatches)
+        };
+        if (event.type === "match") {
+            file.matches.push(lineModel);
+        }
+        else {
+            file.contexts.push(lineModel);
+        }
+    }
+    return [...files.values()];
+}
+function formatBrgSearchModel(model, options = {}) {
+    if (model.files.length === 0) {
+        return `(exit ${model.exitCode}, no matches)`;
+    }
+    const lines = [];
+    const omitFileHeader = options.omitSingleFileHeader === true && model.files.length === 1;
+    for (const file of model.files) {
+        if (!omitFileHeader) {
+            lines.push(`${(options.formatPath ?? ((value) => value))(file.path)}:`);
+        }
+        for (const row of mergedModelRows(file)) {
+            const text = options.trimLineStart === true ? row.text.trimStart() : row.text;
+            lines.push(`${formatModelLocation(row, options)}${text.trimEnd()}`);
+        }
+    }
+    return lines.join("\n");
+}
+function mergedModelRows(file) {
+    const rows = [
+        ...file.matches.map((line) => ({ ...line, kind: "match" })),
+        ...file.contexts.map((line) => ({ ...line, kind: "context" }))
+    ];
+    return rows.sort((left, right) => {
+        const leftLine = left.lineNumber ?? Number.MAX_SAFE_INTEGER;
+        const rightLine = right.lineNumber ?? Number.MAX_SAFE_INTEGER;
+        if (leftLine !== rightLine) {
+            return leftLine - rightLine;
+        }
+        return left.kind === "context" && right.kind === "match" ? -1 : 1;
+    });
+}
+function formatModelLocation(row, options) {
+    const marker = row.kind === "match" ? ":" : "-";
+    const lineNumber = row.lineNumber === null ? "?" : String(row.lineNumber);
+    if (options.showColumn === true && row.kind === "match") {
+        const first = row.submatches[0];
+        if (first) {
+            return `${lineNumber}${marker}${first.start + 1}:`;
+        }
+    }
+    return `${lineNumber}${marker}`;
+}
+function applyBrgOutputCap(input, result, options = {}, model) {
+    const capBytes = options.outputCapBytes;
+    if (typeof capBytes !== "number" || !Number.isFinite(capBytes) || capBytes <= 0) {
+        return result;
+    }
+    const outputBytes = Buffer.byteLength(result.stdout, "utf8");
+    if (outputBytes <= capBytes) {
+        return result;
+    }
+    return {
+        ...result,
+        ok: false,
+        exitCode: 2,
+        stdout: formatBrgOutputCapDiagnostic(input.args, outputBytes, capBytes, options, model),
+        stderr: capDiagnosticStderr(result.stderr)
+    };
+}
+function formatBrgOutputCapDiagnostic(args, outputBytes, capBytes, options, model) {
+    return [
+        `AIB_RG_OUTPUT_CAP_EXCEEDED: ${formatByteSize(outputBytes)} > ${formatByteSize(capBytes)}`,
+        `command: ${formatDiagnosticCommand(args)}`,
+        ...formatBrgCapModelHints(args, options, model),
+        "next: narrow path/glob/pattern, or set AIB_OUTPUT_CAP=off for diagnostics."
+    ].join("\n") + "\n";
+}
+function formatBrgCapModelHints(args, options, model) {
+    if (!model || model.files.length === 0) {
+        return [];
+    }
+    const matchLineCount = model.files.reduce((sum, file) => sum + file.matches.length, 0);
+    const contextLineCount = model.files.reduce((sum, file) => sum + file.contexts.length, 0);
+    const lines = [formatMatchSummary(model, matchLineCount, options)];
+    const termSummary = summarizePatternTerms(args, model);
+    if (termSummary) {
+        lines.push(termSummary);
+    }
+    const fileSummary = summarizeLargestFiles(model, options);
+    if (fileSummary) {
+        lines.push(fileSummary);
+    }
+    if (contextLineCount > 0) {
+        lines.push(summarizeContextLines(contextLineCount, model.classification));
+    }
+    const scopeSummary = summarizeSearchScope(model.classification);
+    if (scopeSummary) {
+        lines.push(scopeSummary);
+    }
+    return lines;
+}
+function formatMatchSummary(model, matchLineCount, options) {
+    const base = `matches: ${matchLineCount} ${plural(matchLineCount, "line", "lines")} in ${model.files.length} ${plural(model.files.length, "file", "files")}`;
+    if (model.files.length !== 1) {
+        return base;
+    }
+    return `${base}: ${formatDisplayPath(model.files[0]?.path ?? "", options)}`;
+}
+function summarizeLargestFiles(model, options) {
+    if (model.files.length <= 1) {
+        return null;
+    }
+    const ranked = model.files
+        .map((file) => [formatDisplayPath(file.path, options), file.matches.length])
+        .filter(([, count]) => count > 0)
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .slice(0, 3);
+    return ranked.length > 0 ? `largest files: ${formatCountList(ranked)}` : null;
+}
+function summarizePatternTerms(args, model) {
+    const patterns = extractRgPatterns(args);
+    if (patterns.length > 1) {
+        const terms = patterns.every((pattern) => isLiteralPattern(pattern)) ? patterns : [];
+        return terms.length > 0 ? summarizeLiteralTerms(terms, model) : summarizeMatchedTexts(model);
+    }
+    const pattern = patterns[0];
+    if (pattern === undefined) {
+        return null;
+    }
+    const terms = splitLiteralAlternation(pattern);
+    if (terms.length < 2) {
+        return summarizeMatchedTexts(model);
+    }
+    return summarizeLiteralTerms(terms, model);
+}
+function summarizeLiteralTerms(terms, model) {
+    const termSet = new Set(terms);
+    const counts = new Map();
+    for (const file of model.files) {
+        for (const match of file.matches) {
+            const seenInLine = new Set();
+            for (const submatch of match.submatches) {
+                if (termSet.has(submatch.text)) {
+                    seenInLine.add(submatch.text);
+                }
+            }
+            for (const text of seenInLine) {
+                counts.set(text, (counts.get(text) ?? 0) + 1);
+            }
+        }
+    }
+    const ranked = rankCounts(counts);
+    return ranked.length > 0 ? `largest terms: ${formatCountList(ranked)}` : null;
+}
+function summarizeMatchedTexts(model) {
+    const matchedTexts = topMatchedTexts(model);
+    return matchedTexts.length > 0 ? `largest matched texts: ${formatCountList(matchedTexts)}` : null;
+}
+function extractRgPatterns(args) {
+    const tokens = scanRgArgs(args);
+    const explicitPatterns = tokens
+        .filter((token) => token.name === "-e" || token.name === "--regexp")
+        .map((token) => token.value ?? "")
+        .filter((value) => value.length > 0);
+    if (explicitPatterns.length > 0) {
+        return explicitPatterns;
+    }
+    const firstPositional = tokens.find((token) => token.positional)?.value;
+    return firstPositional ? [firstPositional] : [];
+}
+function splitLiteralAlternation(pattern) {
+    if (!pattern.includes("|") || /[()[\]{}+*?^$]/.test(pattern)) {
+        return [];
+    }
+    const terms = pattern.split("|")
+        .map((term) => term.trim())
+        .filter((term) => term.length > 0);
+    if (terms.length < 2 || terms.some((term) => term.includes("\\"))) {
+        return [];
+    }
+    return terms;
+}
+function isLiteralPattern(pattern) {
+    return pattern.length > 0 && !/[|()[\]{}+*?^$\\]/.test(pattern);
+}
+function topMatchedTexts(model) {
+    const counts = new Map();
+    for (const file of model.files) {
+        for (const match of file.matches) {
+            const seenInLine = new Set();
+            for (const submatch of match.submatches) {
+                const text = submatch.text.trim();
+                if (text.length > 0 && text.length <= 80) {
+                    seenInLine.add(text);
+                }
+            }
+            for (const text of seenInLine) {
+                counts.set(text, (counts.get(text) ?? 0) + 1);
+            }
+        }
+    }
+    return rankCounts(counts);
+}
+function rankCounts(counts) {
+    return [...counts.entries()]
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .slice(0, 3);
+}
+function formatCountList(items) {
+    return items.map(([name, count]) => `${formatTerm(name)} ${count}`).join(", ");
+}
+function formatTerm(value) {
+    return /^[A-Za-z0-9_./:=@-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function formatDisplayPath(filePath, options) {
+    const displayPath = (options.formatPath ?? ((value) => value))(filePath);
+    return middleTruncate(displayPath.replace(/\\/g, "/"), 72);
+}
+function summarizeSearchScope(classification) {
+    const positionals = classification.features.positionals;
+    const paths = hasExplicitPatternToken(classification)
+        ? positionals
+        : positionals.slice(1);
+    if (paths.length === 0) {
+        return "scope: default working tree";
+    }
+    if (paths.length === 1 && (paths[0] === "." || paths[0] === "./")) {
+        return "scope: broad path .";
+    }
+    return `scope: ${paths.length} ${paths.length === 1 ? "path" : "paths"}`;
+}
+function summarizeContextLines(contextLineCount, classification) {
+    const contextFlags = ["-C", "--context", "-A", "--after-context", "-B", "--before-context"]
+        .filter((flag) => classification.features.flags.includes(flag));
+    const source = contextFlags.length > 0 ? ` from ${contextFlags.join("/")}` : "";
+    return `context: ${contextLineCount} extra ${plural(contextLineCount, "line", "lines")}${source}`;
+}
+function plural(count, one, many) {
+    return count === 1 ? one : many;
+}
+function hasExplicitPatternToken(classification) {
+    return classification.features.flags.includes("-e") || classification.features.flags.includes("--regexp");
+}
+function capDiagnosticStderr(stderr) {
+    const maxBytes = 4096;
+    if (Buffer.byteLength(stderr, "utf8") <= maxBytes) {
+        return stderr;
+    }
+    return `${stderr.slice(-maxBytes)}\n(aib rg stderr truncated after output cap)\n`;
+}
+function formatByteSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    const kib = bytes / 1024;
+    if (kib < 1024) {
+        return `${kib.toFixed(kib < 10 ? 1 : 0)} KiB`;
+    }
+    const mib = kib / 1024;
+    return `${mib.toFixed(mib < 10 ? 1 : 0)} MiB`;
+}
+function formatDiagnosticCommand(args) {
+    const command = `aib rg -- ${formatCommandArgs(args)}`.trimEnd();
+    return middleTruncateWithRemainder(command, 180);
+}
+function formatCommandArgs(args) {
+    return args.map((arg) => /^[A-Za-z0-9_./:=@-]+$/.test(arg) ? arg : JSON.stringify(arg)).join(" ");
+}
+function middleTruncate(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    const marker = "...";
+    const keep = Math.max(0, maxChars - marker.length);
+    const left = Math.ceil(keep * 0.6);
+    const right = keep - left;
+    return `${value.slice(0, left)}${marker}${value.slice(value.length - right)}`;
+}
+function middleTruncateWithRemainder(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    return `${middleTruncate(value, maxChars)} (+${value.length - maxChars} chars)`;
+}
+function scanRgArgs(args) {
+    const tokens = [];
+    let optionsEnded = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        if (optionsEnded) {
+            tokens.push({ name: "positional", value: arg, positional: true });
+            continue;
+        }
+        if (arg === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (!arg.startsWith("-") || arg === "-") {
+            tokens.push({ name: "positional", value: arg, positional: true });
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            const [name, inlineValue] = splitLongFlag(arg);
+            if (inlineValue !== undefined) {
+                tokens.push({ name, value: inlineValue });
+                continue;
+            }
+            if (flagNeedsValue(name)) {
+                tokens.push({ name, value: args[index + 1] ?? "" });
+                index += 1;
+                continue;
+            }
+            tokens.push({ name });
+            continue;
+        }
+        const scanned = scanShortFlag(arg, args[index + 1]);
+        tokens.push(...scanned.tokens);
+        index += scanned.consumedNext ? 1 : 0;
+    }
+    return tokens;
+}
+function scanShortFlag(arg, next) {
+    const first = `-${arg[1] ?? ""}`;
+    if (SAFE_SHORT_VALUE_FLAGS.has(first) || OUTPUT_TRANSFORM_VALUE_FLAGS.has(first)) {
+        const inlineValue = arg.slice(2);
+        return {
+            tokens: [{ name: first, value: inlineValue || next || "" }],
+            consumedNext: inlineValue.length === 0
+        };
+    }
+    const tokens = [];
+    for (const char of arg.slice(1)) {
+        tokens.push({ name: `-${char}` });
+    }
+    return { tokens, consumedNext: false };
+}
+function splitLongFlag(arg) {
+    const equalsIndex = arg.indexOf("=");
+    if (equalsIndex < 0) {
+        return [arg, undefined];
+    }
+    return [arg.slice(0, equalsIndex), arg.slice(equalsIndex + 1)];
+}
+function flagNeedsValue(name) {
+    return SAFE_LONG_VALUE_FLAGS.has(name) ||
+        SAFE_SHORT_VALUE_FLAGS.has(name) ||
+        OUTPUT_TRANSFORM_VALUE_FLAGS.has(name) ||
+        name === "--color";
+}
+function isSupportedFlag(token) {
+    if (token.positional) {
+        return true;
+    }
+    if (flagNeedsValue(token.name) && token.value === "") {
+        return false;
+    }
+    if (token.name === "--color") {
+        return token.value === "always" || token.value === "auto" || token.value === "never";
+    }
+    return RAW_LONG_FLAGS.has(token.name) ||
+        RAW_SHORT_FLAGS.has(token.name) ||
+        OUTPUT_TRANSFORM_VALUE_FLAGS.has(token.name) ||
+        SAFE_LONG_FLAGS.has(token.name) ||
+        SAFE_LONG_VALUE_FLAGS.has(token.name) ||
+        SAFE_SHORT_FLAGS.has(token.name) ||
+        SAFE_SHORT_VALUE_FLAGS.has(token.name);
+}
+function hasExplicitPattern(tokens) {
+    return tokens.some((token) => token.name === "-e" || token.name === "--regexp");
+}
+function getOrCreateModelFile(files, filePath) {
+    const existing = files.get(filePath);
+    if (existing) {
+        return existing;
+    }
+    const next = {
+        path: filePath,
+        matches: [],
+        contexts: []
+    };
+    files.set(filePath, next);
+    return next;
+}
+function readText(value) {
+    return typeof value === "string" ? value : "";
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readSubmatches(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            return [];
+        }
+        const candidate = item;
+        const text = readText(candidate.match?.text);
+        const start = readNumber(candidate.start);
+        const end = readNumber(candidate.end);
+        return start === null || end === null ? [] : [{ text, start, end }];
+    });
+}