@nexrall/code-core 1.4.76 → 1.4.78

package/dist/search/conversationTurns.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_CLIP = exports.MAX_TURNS = exports.RESULT_PREVIEW_LINES = exports.MAX_TURN_LINES = exports.BANG_TRANSCRIPT_PREFIX = void 0;
+exports.flatten = flatten;
+exports.clip = clip;
+exports.blockLines = blockLines;
+exports.startsTurn = startsTurn;
+exports.isSyntheticUserText = isSyntheticUserText;
+exports.turnsFrom = turnsFrom;
+exports.lastPrompt = lastPrompt;
+exports.lastTypedPrompt = lastTypedPrompt;
+// Conversation → turns, the pure half (moved from the CLI's ui/transcriptView.ts,
+// 2026-10-04) so /find searches the SAME turn shape in the VS Code panel; the
+// CLI module re-exports everything.
+const types_1 = require("../types");
+const toolLabel_1 = require("../util/toolLabel");
+/** `!cmd` transcripts are synthesised user messages; this is their prefix (moved
+ *  here from commands/bangShell.ts so the synthetic-user list has one home). */
+exports.BANG_TRANSCRIPT_PREFIX = 'I ran this command myself in the terminal:';
+/** Lines of a turn's body shown by a jump before the rest is summarised. */
+exports.MAX_TURN_LINES = 80;
+/** Tool-result lines kept inline; the rest is a count. */
+exports.RESULT_PREVIEW_LINES = 3;
+/** Newest turns kept — a 400-turn session does not need all of it in memory. */
+exports.MAX_TURNS = 200;
+/** Prompt length in a turn header / search label. */
+exports.PROMPT_CLIP = 100;
+function flatten(s) {
+    return s.replace(/\s+/g, ' ').trim();
+}
+function clip(s, max) {
+    return s.length <= max ? s : s.slice(0, max - 1) + '\u2026';
+}
+/** One display line per content block, or null for blocks that are not conversation. */
+function blockLines(m, b) {
+    switch (b.type) {
+        case 'text': {
+            const text = b.text.trimEnd();
+            if (!text.trim())
+                return null;
+            if (m.role === 'user')
+                return text.split('\n').map((l) => '  ' + l);
+            return text.split('\n');
+        }
+        case 'tool_use':
+            return ['  \u26a1 ' + (0, toolLabel_1.toolLabel)(b.name, b.input)];
+        case 'tool_result': {
+            const body = b.content.replace(/\r/g, '').trimEnd().split('\n');
+            const kept = body.slice(0, exports.RESULT_PREVIEW_LINES).map((l) => '  \u2502 ' + clip(l, 200));
+            if (body.length > exports.RESULT_PREVIEW_LINES)
+                kept.push(`  \u2514 \u2026 +${body.length - exports.RESULT_PREVIEW_LINES} line(s)`);
+            return kept;
+        }
+        case 'image':
+            return ['  [image]'];
+        case 'document':
+            return ['  [document]'];
+        default:
+            return null;
+    }
+}
+/** User turns the CLI synthesised — outputs and notices folded in dressed as
+ *  user messages. None of these is "what the user asked for". */
+const SYNTHETIC_USER_PREFIXES = [
+    '<task-notification>', // core's formatBackgroundNotifications
+    exports.BANG_TRANSCRIPT_PREFIX, // a `!cmd` transcript
+    '[Message from peer session ', // core's renderPeerMessages
+];
+/** Did this user message start a turn, or is it agent bookkeeping? */
+function startsTurn(m) {
+    if (m.role !== 'user')
+        return false;
+    return m.content.some((b) => b.type === 'text' && !(0, types_1.isRuntimeContextBlock)(b));
+}
+function isSyntheticUserText(text) {
+    return SYNTHETIC_USER_PREFIXES.some((p) => text.startsWith(p));
+}
+/**
+ * Group the conversation into turns. Content before the first real prompt (the
+ * opening context block) is not a turn and is skipped.
+ */
+function turnsFrom(messages, opts = {}) {
+    const maxLines = opts.maxLines ?? exports.MAX_TURN_LINES;
+    const turns = [];
+    let current = null;
+    let hasPrompt = false;
+    // The block a turn's prompt came from: it is printed as `> prompt` by the header,
+    // so repeating it as the first body line would show every question twice.
+    let promptBlock = null;
+    for (const m of messages) {
+        if (startsTurn(m)) {
+            if (current)
+                turns.push(finish(current, maxLines));
+            const firstText = m.content.find((b) => b.type === 'text' && !(0, types_1.isRuntimeContextBlock)(b));
+            current = {
+                index: turns.length + 1,
+                prompt: clip(flatten(firstText?.text ?? ''), exports.PROMPT_CLIP),
+                lines: [],
+                toolCalls: 0,
+                dropped: 0,
+            };
+            promptBlock = firstText ?? null;
+            hasPrompt = true;
+        }
+        if (!hasPrompt || !current)
+            continue;
+        for (const b of m.content) {
+            if (b === promptBlock) {
+                promptBlock = null;
+                continue;
+            }
+            if (b.type === 'text' && (0, types_1.isRuntimeContextBlock)(b))
+                continue; // runtime context: not conversation
+            if (b.type === 'tool_use')
+                current.toolCalls++;
+            const lines = blockLines(m, b);
+            if (lines)
+                current.lines.push(...lines);
+        }
+    }
+    if (current)
+        turns.push(finish(current, maxLines));
+    const kept = turns.length > (opts.maxTurns ?? exports.MAX_TURNS) ? turns.slice(-(opts.maxTurns ?? exports.MAX_TURNS)) : turns;
+    kept.forEach((t, i) => {
+        t.index = i + 1;
+    });
+    return kept;
+}
+function finish(t, maxLines) {
+    if (t.lines.length > maxLines) {
+        t.dropped = t.lines.length - maxLines;
+        t.lines = [...t.lines.slice(0, maxLines), `  \u2514 \u2026 ${t.dropped} more line(s) in this turn`];
+    }
+    return t;
+}
+/**
+ * The most recent real prompt in the conversation — the label a `/cost` turn row carries.
+ *
+ * Scans BACKWARDS so a mid-turn follow-up (folded in by the loop while the agent works) is
+ * what the row reads: that is the last thing the user actually asked for. '' when nothing
+ * has been typed yet.
+ */
+function lastPrompt(messages, max = exports.PROMPT_CLIP) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== 'user')
+            continue;
+        const b = m.content.find((x) => x.type === 'text' && !(0, types_1.isRuntimeContextBlock)(x));
+        if (b && b.type === 'text')
+            return clip(flatten(b.text), max);
+    }
+    return '';
+}
+/**
+ * The last prompt the USER actually typed — skips the synthetic user messages (a `!cmd`
+ * transcript, a task notification, a peer message), which are turns but were not typed.
+ * The §81 handoff goal is built from this; `lastPrompt` deliberately does not skip them.
+ */
+function lastTypedPrompt(messages, max = exports.PROMPT_CLIP) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== 'user')
+            continue;
+        const b = m.content.find((x) => x.type === 'text' && !(0, types_1.isRuntimeContextBlock)(x));
+        if (b && b.type === 'text' && !isSyntheticUserText(b.text))
+            return clip(flatten(b.text), max);
+    }
+    return '';
+}
+//# sourceMappingURL=conversationTurns.js.map

package/dist/search/globalSearch.d.ts

@@ -0,0 +1,144 @@
+import type { Turn } from './conversationTurns';
+import type { Incident } from '../verify/failureTimeline';
+/**
+ * Structurally minimal shapes for the two CLI-UI stores (kept local so core
+ * needs no import from the CLI; richer objects pass structurally). The CLI's
+ * ToolOutputEntry / AgentNode satisfy these unchanged.
+ */
+export interface ToolOutputEntry {
+    /** Monotonic id, 1-based — what `/expand <n>` refers to. */
+    id: number;
+    name: string;
+    /** One-line description of the call (the command, the path …). */
+    label: string;
+    output: string;
+    isError: boolean;
+    durationMs: number;
+}
+export interface AgentNode {
+    name: string;
+    label: string;
+    files: string[];
+    error?: string;
+    report?: string;
+}
+export type Scope = 'files' | 'conversation' | 'tools' | 'git' | 'errors' | 'agents';
+/** Display order — §52 lists files first because that is where a code query usually lives. */
+export declare const SCOPES: readonly Scope[];
+export declare const SCOPE_LABEL: Record<Scope, string>;
+/** Hits printed per scope. The counts line stays complete — only the list is capped. */
+export declare const MAX_PER_SCOPE = 5;
+/** A matched line kept for context, so a hit is recognisable without opening anything. */
+export declare const DETAIL_CLIP = 96;
+export declare const LABEL_CLIP = 72;
+export interface Hit {
+    scope: Scope;
+    /** Stable identity inside the scope, for the "N of M" note and for ordering. */
+    key: string;
+    /** What the row shows first: a path, a command, an agent. */
+    label: string;
+    /** The matching line, when the label itself is not the match. */
+    detail?: string;
+    /** 0 = best. */
+    score: number;
+    /** 1-based position in the scope's own listing, so the row can be found again. */
+    index: number;
+}
+export interface Sources {
+    files?: string[];
+    turns?: Turn[];
+    tools?: ToolOutputEntry[];
+    git?: Array<{
+        path: string;
+        status?: string;
+    }>;
+    errors?: Incident[];
+    agents?: AgentNode[];
+}
+export interface Count {
+    scope: Scope;
+    count: number;
+}
+export interface Result {
+    query: string;
+    hits: Hit[];
+    counts: Count[];
+}
+/**
+ * Shorten an ASSEMBLED line to `cols`, keeping its leading indent.
+ *
+ * `clip` flattens whitespace, which is right for a path or a matched line but destroys a row
+ * whose alignment is the point: `clip('  Files  12')` returns `Files  12`, and every column in
+ * the counts block collapses. Measured on the first run of the tests in this module.
+ */
+export declare function fitLine(body: string, cols: number, indent?: string): string;
+/**
+ * Rank one text against the query. `Infinity` = no match.
+ *
+ * Substring only, case-insensitive — this is a search box for code, where a fuzzy match is
+ * noise. The ladder, weakest last:
+ *
+ *   0  the text IS the query                     `auth`      vs `auth`
+ *   1  the text begins with the query             `auth.ts`   vs `auth`
+ *   2  the query begins a word                    `src/auth.ts`, `jwt-refresh.ts`
+ *   3  the query starts mid-word                  `myjwthelper.ts`, `contest/a.ts`
+ *
+ * Rung 1 exists on its own because a tie between `auth.ts` and `x/auth-mid.ts` used to be
+ * settled by whatever order the scope listed them in, which put the worse match first.
+ */
+export declare function scoreText(query: string, text: string): number;
+/** Files: the path itself. */
+export declare function searchFiles(query: string, files: string[]): Hit[];
+/** Conversation: prompts and reply lines, via the transcript the turn navigation already builds. */
+export declare function searchConversation(query: string, turns: Turn[]): Hit[];
+/** Tools: the call label and the output the transcript folded away. */
+export declare function searchTools(query: string, entries: ToolOutputEntry[]): Hit[];
+/** Git: changed paths, with the status letter kept in front so `M`/`??` is visible. */
+export declare function searchGit(query: string, changes: Array<{
+    path: string;
+    status?: string;
+}>): Hit[];
+/** Errors: the failing command, the files it touched, and the re-tests. */
+export declare function searchErrors(query: string, incidents: Incident[]): Hit[];
+/** Agents: type, task label and the files each one touched. */
+export declare function searchAgents(query: string, nodes: AgentNode[]): Hit[];
+export declare function globalSearch(query: string, sources: Sources, perScope?: number): Result;
+export declare function filterScope(hits: Hit[], scope: Scope | null): Hit[];
+/**
+ * The §52 counts block:
+ *
+ *     > JWT
+ *
+ *     Files        12
+ *     Conversation  8
+ *     Git           3
+ *     Agents        2
+ *
+ * Labels pad to the widest, counts right-align to the widest — so the numbers line up even
+ * when "Conversation" sits next to "Files". Every line is clipped to `cols`; at narrow widths
+ * the label is what gets cut, never the count.
+ */
+export declare function formatCounts(result: Result, cols: number, opts?: {
+    table?: boolean;
+}): string[];
+/**
+ * One printed row per hit: `  3. Git  M src/app.js`, with the matched line under it when the
+ * label alone would not say why it matched.
+ *
+ * `tag` prepends the 3-letter scope — on when the rows are mixed, off inside a per-scope
+ * section where the heading already said it.
+ */
+export declare function formatHits(hits: Hit[], cols: number, indent?: string, tag?: boolean): string[];
+/** `Scopes: /find <q> --files --git` — only the flags that would actually narrow this result. */
+export declare function scopeHint(counts: Count[]): string;
+export interface SearchArgs {
+    query: string;
+    /** null = search everything. */
+    scopes: Scope[] | null;
+    /** Flags that are not scopes — reported instead of silently becoming part of the query. */
+    bad: string[];
+}
+/** `/find JWT --git --tools` → query "JWT", scopes [git, tools]. `--all` clears the narrowing. */
+export declare function parseSearchArgs(arg: string): SearchArgs;
+export declare function searchUsage(): string;
+//# sourceMappingURL=globalSearch.d.ts.map

package/dist/search/globalSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalSearch.d.ts","sourceRoot":"","sources":["../../src/search/globalSearch.ts"],"names":[],"mappings":"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"}

package/dist/search/globalSearch.js

@@ -0,0 +1,350 @@
+"use strict";
+// Lives in core (moved from the CLI's ui/globalSearch.ts, 2026-10-04) so
+// /find searches with the same engine in the VS Code panel; the CLI module is
+// a re-export shim.
+// §52 Global search — one query across files, conversation, tools, git, errors and agents.
+//
+// WHY: every scope already had its own command (/diff, /expand, /failures, /agents, /find), so
+// answering "where does JWT show up at all?" meant running five of them and remembering which
+// one held the answer. This module is the missing index over the sources the session already
+// holds — pure functions, so a count is exactly what the scope contains and nothing is invented.
+// It finds and ranks; the per-scope commands still do the jumping.
+//
+// Pure (no Ink, no console, no fs) so ranking, clipping and the counts block are unit-testable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LABEL_CLIP = exports.DETAIL_CLIP = exports.MAX_PER_SCOPE = exports.SCOPE_LABEL = exports.SCOPES = void 0;
+exports.fitLine = fitLine;
+exports.scoreText = scoreText;
+exports.searchFiles = searchFiles;
+exports.searchConversation = searchConversation;
+exports.searchTools = searchTools;
+exports.searchGit = searchGit;
+exports.searchErrors = searchErrors;
+exports.searchAgents = searchAgents;
+exports.globalSearch = globalSearch;
+exports.filterScope = filterScope;
+exports.formatCounts = formatCounts;
+exports.formatHits = formatHits;
+exports.scopeHint = scopeHint;
+exports.parseSearchArgs = parseSearchArgs;
+exports.searchUsage = searchUsage;
+const cellWidth_1 = require("../util/cellWidth");
+/** Display order — §52 lists files first because that is where a code query usually lives. */
+exports.SCOPES = ['files', 'conversation', 'tools', 'git', 'errors', 'agents'];
+exports.SCOPE_LABEL = {
+    files: 'Files',
+    conversation: 'Conversation',
+    tools: 'Tools',
+    git: 'Git',
+    errors: 'Errors',
+    agents: 'Agents',
+};
+/** Flags accepted after the query, including the short forms a user is likely to try first. */
+const SCOPE_FLAG = {
+    '--files': 'files',
+    '--file': 'files',
+    '--chat': 'conversation',
+    '--conversation': 'conversation',
+    '--conv': 'conversation',
+    '--tools': 'tools',
+    '--tool': 'tools',
+    '--git': 'git',
+    '--errors': 'errors',
+    '--error': 'errors',
+    '--agents': 'agents',
+    '--agent': 'agents',
+};
+/** Hits printed per scope. The counts line stays complete — only the list is capped. */
+exports.MAX_PER_SCOPE = 5;
+/** A matched line kept for context, so a hit is recognisable without opening anything. */
+exports.DETAIL_CLIP = 96;
+exports.LABEL_CLIP = 72;
+function clip(s, max) {
+    const flat = s.replace(/\s+/g, ' ').trim();
+    return (0, cellWidth_1.truncateCells)(flat, max);
+}
+/**
+ * Shorten an ASSEMBLED line to `cols`, keeping its leading indent.
+ *
+ * `clip` flattens whitespace, which is right for a path or a matched line but destroys a row
+ * whose alignment is the point: `clip('  Files  12')` returns `Files  12`, and every column in
+ * the counts block collapses. Measured on the first run of the tests in this module.
+ */
+function fitLine(body, cols, indent = '') {
+    const room = Math.max(1, cols - (0, cellWidth_1.visibleLen)(indent));
+    if ((0, cellWidth_1.visibleLen)(body) <= room)
+        return indent + body;
+    const cut = (0, cellWidth_1.truncateCells)(body, room);
+    // A cut lands mid-style (the closing code of the run it interrupted is never reached), and an
+    // SGR left open bleeds into every row printed after it. Only styled rows get the reset, so
+    // NO_COLOR output stays byte-identical to what it always was.
+    return indent + (cut.includes('\u001b') ? cut + '\u001b[0m' : cut);
+}
+/**
+ * Rank one text against the query. `Infinity` = no match.
+ *
+ * Substring only, case-insensitive — this is a search box for code, where a fuzzy match is
+ * noise. The ladder, weakest last:
+ *
+ *   0  the text IS the query                     `auth`      vs `auth`
+ *   1  the text begins with the query             `auth.ts`   vs `auth`
+ *   2  the query begins a word                    `src/auth.ts`, `jwt-refresh.ts`
+ *   3  the query starts mid-word                  `myjwthelper.ts`, `contest/a.ts`
+ *
+ * Rung 1 exists on its own because a tie between `auth.ts` and `x/auth-mid.ts` used to be
+ * settled by whatever order the scope listed them in, which put the worse match first.
+ */
+function scoreText(query, text) {
+    const q = query.toLowerCase();
+    if (!q)
+        return Infinity;
+    const t = text.toLowerCase();
+    const at = t.indexOf(q);
+    if (at < 0)
+        return Infinity;
+    if (t === q)
+        return 0;
+    if (at === 0)
+        return 1;
+    if (!/[a-z0-9]/.test(t[at - 1]))
+        return 2;
+    return 3;
+}
+/** Best first: score, then the order the source listed them in. */
+function top(hits, limit) {
+    const sorted = hits.sort((a, b) => a.score - b.score || a.index - b.index);
+    return limit === Infinity ? sorted : sorted.slice(0, limit);
+}
+function push(hits, scope, index, label, detail, score) {
+    hits.push({
+        scope,
+        key: `${scope}:${index}`,
+        label: clip(label, exports.LABEL_CLIP),
+        detail: detail && clip(detail, exports.DETAIL_CLIP),
+        score,
+        index,
+    });
+}
+// ─── Per-scope matchers ───────────────────────────────────────────────────────
+/** Files: the path itself. */
+function searchFiles(query, files) {
+    const hits = [];
+    files.forEach((f, i) => {
+        const score = scoreText(query, f);
+        if (score !== Infinity)
+            push(hits, 'files', i + 1, f, undefined, score);
+    });
+    return top(hits, Infinity);
+}
+/** Conversation: prompts and reply lines, via the transcript the turn navigation already builds. */
+function searchConversation(query, turns) {
+    const hits = [];
+    turns.forEach((t) => {
+        const score = scoreText(query, t.prompt);
+        if (score !== Infinity)
+            push(hits, 'conversation', t.index, `turn ${t.index}  you  ${t.prompt}`, undefined, score);
+        t.lines.forEach((line) => {
+            const s = scoreText(query, line);
+            if (s !== Infinity)
+                push(hits, 'conversation', t.index, `turn ${t.index}`, line, s + 1);
+        });
+    });
+    return top(hits, Infinity);
+}
+/** Tools: the call label and the output the transcript folded away. */
+function searchTools(query, entries) {
+    const hits = [];
+    entries.forEach((e) => {
+        const label = `${e.name}: ${e.label}`;
+        let best = scoreText(query, label);
+        let detail;
+        for (const line of e.output.split('\n')) {
+            const s = scoreText(query, line);
+            if (s !== Infinity) {
+                if (s + 1 < best)
+                    best = s + 1;
+                detail = line; // one output line is enough to recognise the call; /expand <id> shows the rest
+                break;
+            }
+        }
+        // ONE row per tool call: the count then answers "how many calls mention this", and the
+        // command that is itself the query does not show up as a second, identical-looking hit.
+        if (best !== Infinity)
+            push(hits, 'tools', e.id, `#${e.id} ${label}`, detail, best);
+    });
+    return top(hits, Infinity);
+}
+/** Git: changed paths, with the status letter kept in front so `M`/`??` is visible. */
+function searchGit(query, changes) {
+    const hits = [];
+    changes.forEach((c, i) => {
+        const score = scoreText(query, c.path);
+        if (score !== Infinity)
+            push(hits, 'git', i + 1, `${c.status ? c.status + ' ' : ''}${c.path}`, undefined, score);
+    });
+    return top(hits, Infinity);
+}
+/** Errors: the failing command, the files it touched, and the re-tests. */
+function searchErrors(query, incidents) {
+    const hits = [];
+    incidents.forEach((inc) => {
+        const head = `#${inc.id} ${inc.command}`;
+        const inHead = scoreText(query, head);
+        if (inHead !== Infinity)
+            push(hits, 'errors', inc.id, head, undefined, inHead);
+        for (const f of inc.files) {
+            const s = scoreText(query, f);
+            if (s !== Infinity)
+                push(hits, 'errors', inc.id, head, f, s + 1);
+        }
+        for (const r of inc.retests) {
+            const s = scoreText(query, r.command);
+            if (s !== Infinity)
+                push(hits, 'errors', inc.id, head, `[${r.ok ? 'ok' : 'fail'}] ${r.command}`, s + 1);
+        }
+    });
+    return top(hits, Infinity);
+}
+/** Agents: type, task label and the files each one touched. */
+function searchAgents(query, nodes) {
+    const hits = [];
+    nodes.forEach((n, i) => {
+        const head = `${n.name}  ${n.label}`;
+        const inHead = scoreText(query, head);
+        if (inHead !== Infinity)
+            push(hits, 'agents', i + 1, head, n.error, inHead);
+        for (const f of n.files) {
+            const s = scoreText(query, f);
+            if (s !== Infinity)
+                push(hits, 'agents', i + 1, head, f, s + 1);
+        }
+        if (n.report) {
+            const s = scoreText(query, n.report);
+            if (s !== Infinity)
+                push(hits, 'agents', i + 1, head, 'report', s + 2);
+        }
+    });
+    return top(hits, Infinity);
+}
+// ─── The search itself ───────────────────────────────────────────────────────
+function globalSearch(query, sources, perScope = exports.MAX_PER_SCOPE) {
+    const q = query.trim();
+    if (!q)
+        return { query: '', hits: [], counts: [] };
+    const all = [];
+    if (sources.files)
+        all.push(...searchFiles(q, sources.files));
+    if (sources.turns)
+        all.push(...searchConversation(q, sources.turns));
+    if (sources.tools)
+        all.push(...searchTools(q, sources.tools));
+    if (sources.git)
+        all.push(...searchGit(q, sources.git));
+    if (sources.errors)
+        all.push(...searchErrors(q, sources.errors));
+    if (sources.agents)
+        all.push(...searchAgents(q, sources.agents));
+    const counts = exports.SCOPES.map((scope) => ({ scope, count: all.filter((h) => h.scope === scope).length })).filter((c) => c.count > 0);
+    const hits = [];
+    for (const scope of exports.SCOPES) {
+        hits.push(...top(all.filter((h) => h.scope === scope), perScope));
+    }
+    return { query: q, hits, counts };
+}
+function filterScope(hits, scope) {
+    return scope ? hits.filter((h) => h.scope === scope) : hits;
+}
+// ─── Rendering ────────────────────────────────────────────────────────────────
+/**
+ * The §52 counts block:
+ *
+ *     > JWT
+ *
+ *     Files        12
+ *     Conversation  8
+ *     Git           3
+ *     Agents        2
+ *
+ * Labels pad to the widest, counts right-align to the widest — so the numbers line up even
+ * when "Conversation" sits next to "Files". Every line is clipped to `cols`; at narrow widths
+ * the label is what gets cut, never the count.
+ */
+function formatCounts(result, cols, opts = {}) {
+    const out = [];
+    if (!result.query)
+        return out;
+    out.push(fitLine(`> ${result.query}`, cols));
+    if (!result.counts.length) {
+        out.push('');
+        out.push(fitLine('No match in files, conversation, tools, git, errors or agents.', cols, '  '));
+        return out;
+    }
+    // With one scope selected the section heading below already carries its count (`Git  1`),
+    // so the table would only repeat it — but the `> query` header still belongs to the result.
+    if (opts.table === false)
+        return out;
+    const labelW = Math.max(...result.counts.map((c) => exports.SCOPE_LABEL[c.scope].length)) + 1;
+    const numW = Math.max(...result.counts.map((c) => String(c.count).length));
+    out.push('');
+    for (const c of result.counts) {
+        const label = exports.SCOPE_LABEL[c.scope].padEnd(labelW);
+        const num = String(c.count).padStart(numW);
+        out.push(fitLine(`${label}${num}`, cols, '  '));
+    }
+    return out;
+}
+/**
+ * One printed row per hit: `  3. Git  M src/app.js`, with the matched line under it when the
+ * label alone would not say why it matched.
+ *
+ * `tag` prepends the 3-letter scope — on when the rows are mixed, off inside a per-scope
+ * section where the heading already said it.
+ */
+function formatHits(hits, cols, indent = '  ', tag = true) {
+    const out = [];
+    hits.forEach((h, i) => {
+        const n = String(i + 1).padStart(3);
+        const mark = tag ? `${exports.SCOPE_LABEL[h.scope].slice(0, 3)}  ` : '';
+        out.push(fitLine(`${n}. ${mark}${h.label}`, cols, indent));
+        if (h.detail && h.detail !== h.label)
+            out.push(fitLine(h.detail, cols, indent + '     '));
+    });
+    return out;
+}
+/** `Scopes: /find <q> --files --git` — only the flags that would actually narrow this result. */
+function scopeHint(counts) {
+    if (!counts.length)
+        return '';
+    const flags = counts.map((c) => '--' + c.scope);
+    return `Scopes: /find <query> ${flags.join(' ')}`;
+}
+/** `/find JWT --git --tools` → query "JWT", scopes [git, tools]. `--all` clears the narrowing. */
+function parseSearchArgs(arg) {
+    const words = arg.trim().split(/\s+/).filter(Boolean);
+    const scopes = [];
+    const bad = [];
+    const rest = [];
+    let all = false;
+    for (const w of words) {
+        const scope = SCOPE_FLAG[w.toLowerCase()];
+        if (scope) {
+            scopes.push(scope);
+            continue;
+        }
+        if (w.toLowerCase() === '--all') {
+            all = true;
+            continue;
+        }
+        if (w.startsWith('--')) {
+            bad.push(w);
+            continue;
+        }
+        rest.push(w);
+    }
+    return { query: rest.join(' '), scopes: all || !scopes.length ? null : [...new Set(scopes)], bad };
+}
+function searchUsage() {
+    const flags = exports.SCOPES.map((s) => (s === 'conversation' ? '--conversation|--chat' : `--${s}`));
+    return `Usage: /find <text> ${flags.map((f) => `[${f}]`).join(' ')}`;
+}
+//# sourceMappingURL=globalSearch.js.map