@schlessera/brain-ui-react 0.4.0

package/dist/components/chat/tool-views.js

@@ -0,0 +1,628 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from "react";
+import { Terminal, FileEdit, FilePlus, FileSearch, FolderSearch, Search, Eye, Globe, Bot, Wand2, Braces, NotebookPen, MapPin, ChevronRight, } from "lucide-react";
+import { cn } from "../../lib/utils.js";
+import { linkifyPaths, FileLink } from "./brain-markdown.js";
+import { MarkdownContent } from "./markdown-content.js";
+import { isInternalRepoPath } from "../../stores/file-store.js";
+import { GET_LOCATION_TOOL_NAME, normalizeToolName } from "../../lib/tool-names.js";
+// ============================================================
+// Shared helpers
+// ============================================================
+function str(v) {
+    return typeof v === "string" && v.length > 0 ? v : null;
+}
+function num(v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function basename(p) {
+    return p.replace(/^.*\//, "");
+}
+/**
+ * Tool inputs carry absolute paths (`/data/brain/notes/foo.md`); the file
+ * panel wants repo-relative ones. Strip everything up to the brain repo root
+ * and verify the result actually looks like a repo path.
+ */
+export function toRepoRelative(path) {
+    // isInternalRepoPath is a `href is string` guard; feed it a widened local
+    // so the original string parameter is not narrowed to `never`.
+    const candidate = path;
+    if (isInternalRepoPath(candidate))
+        return candidate;
+    const idx = path.indexOf("/brain/");
+    if (idx >= 0) {
+        const rel = path.slice(idx + "/brain/".length);
+        if (isInternalRepoPath(rel))
+            return rel;
+    }
+    return null;
+}
+/** Path as a clickable file link when it resolves inside the brain repo. */
+function fileLabel(path) {
+    const rel = toRepoRelative(path);
+    if (rel)
+        return _jsx(FileLink, { path: rel, children: rel });
+    return _jsx("span", { title: path, children: path });
+}
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const m = Math.floor(ms / 60_000);
+    const s = Math.round((ms % 60_000) / 1000);
+    return `${m}m ${s}s`;
+}
+export function countLines(text) {
+    let n = 1;
+    for (let i = 0; i < text.length; i++)
+        if (text[i] === "\n")
+            n++;
+    return n;
+}
+// ============================================================
+// Header helpers: icon, summary, meta badge
+// ============================================================
+const toolIcons = {
+    Bash: Terminal,
+    Edit: FileEdit,
+    Write: FilePlus,
+    NotebookEdit: NotebookPen,
+    Read: Eye,
+    Grep: FileSearch,
+    Glob: FolderSearch,
+    WebSearch: Search,
+    WebFetch: Globe,
+    Agent: Bot,
+    Skill: Wand2,
+    LSP: Braces,
+    [GET_LOCATION_TOOL_NAME]: MapPin,
+};
+export function getToolIcon(name) {
+    return toolIcons[normalizeToolName(name)] || Terminal;
+}
+/**
+ * Display name for a tool. In-process MCP tools stream as
+ * `mcp__<server>__<tool>`; show just the bare tool name in the timeline.
+ */
+export function getToolLabel(name) {
+    if (name.startsWith("mcp__")) {
+        const parts = name.split("__");
+        return parts[parts.length - 1] || name;
+    }
+    return name;
+}
+/** Extract a short inline summary from tool input for at-a-glance context. */
+export function getToolSummary(tool) {
+    const inp = tool.input;
+    if (!inp)
+        return null;
+    switch (tool.name) {
+        case "Agent":
+            return str(inp.description);
+        case "Bash":
+            // The human-phrased description reads better than a truncated command
+            return str(inp.description) ?? str(inp.command)?.slice(0, 80) ?? null;
+        case "Read": {
+            const path = str(inp.file_path);
+            if (!path)
+                return null;
+            const offset = num(inp.offset);
+            const limit = num(inp.limit);
+            if (offset !== null && limit !== null) {
+                return `${basename(path)} · ${offset}–${offset + limit}`;
+            }
+            return basename(path);
+        }
+        case "Edit":
+        case "Write":
+            return str(inp.file_path) ? basename(inp.file_path) : null;
+        case "NotebookEdit":
+            return str(inp.notebook_path) ? basename(inp.notebook_path) : null;
+        case "Glob":
+        case "Grep":
+            return str(inp.pattern);
+        case "WebSearch":
+            return str(inp.query);
+        case "WebFetch": {
+            const url = str(inp.url);
+            if (!url)
+                return null;
+            try {
+                const u = new URL(url);
+                return `${u.host}${u.pathname === "/" ? "" : u.pathname}`;
+            }
+            catch {
+                return url;
+            }
+        }
+        case "Skill":
+            return [str(inp.skill), str(inp.args)].filter(Boolean).join(" ") || null;
+        case "LSP": {
+            const op = str(inp.operation) ?? str(inp.method) ?? str(inp.action);
+            const path = str(inp.file_path);
+            return [op, path && basename(path)].filter(Boolean).join(" · ") || null;
+        }
+        default:
+            return null;
+    }
+}
+/** Right-side header meta: output size + wall-clock duration. */
+export function getOutputMeta(tool) {
+    const parts = [];
+    if (tool.output && !tool.isError) {
+        const lines = countLines(tool.output.trimEnd());
+        switch (tool.name) {
+            case "Grep":
+                parts.push(/no matches/i.test(tool.output) ? "no matches" : `${lines} matches`);
+                break;
+            case "Glob":
+                parts.push(/no files/i.test(tool.output)
+                    ? "no files"
+                    : `${lines} file${lines === 1 ? "" : "s"}`);
+                break;
+            case "Read":
+                parts.push(`${lines} lines`);
+                break;
+            default:
+                if (lines > 5)
+                    parts.push(`${lines} lines`);
+        }
+    }
+    if (tool.startedAt && tool.endedAt && tool.endedAt > tool.startedAt) {
+        parts.push(formatDuration(tool.endedAt - tool.startedAt));
+    }
+    return parts.length ? parts.join(" · ") : null;
+}
+/** File a tool writes to — used for the "N files touched" group summary. */
+export function getTouchedFile(tool) {
+    if (tool.name === "Edit" || tool.name === "Write") {
+        return str(tool.input?.file_path);
+    }
+    if (tool.name === "NotebookEdit") {
+        return str(tool.input?.notebook_path);
+    }
+    return null;
+}
+// ============================================================
+// Input views
+// ============================================================
+export function ToolInputView({ tool }) {
+    // Input JSON still streaming in — a partial JSON dump is noise
+    if (tool.status === "streaming") {
+        return (_jsxs("div", { className: "flex items-center gap-2 rounded-md bg-background/60 p-2 text-[11px] text-muted-foreground/60", children: [_jsx("span", { className: "inline-block h-1.5 w-1.5 rounded-full bg-primary", style: { animation: "breathe 1.5s ease-in-out infinite" } }), "Preparing input\u2026"] }));
+    }
+    switch (tool.name) {
+        case "Edit":
+            if (str(tool.input?.old_string) !== null && str(tool.input?.new_string) !== null) {
+                return _jsx(EditDiffView, { tool: tool });
+            }
+            break;
+        case "Write":
+            if (str(tool.input?.content) !== null) {
+                return _jsx(WriteFileView, { tool: tool });
+            }
+            break;
+        case "Bash":
+            if (str(tool.input?.command) !== null) {
+                return _jsx(BashCommandView, { tool: tool });
+            }
+            break;
+        case "Read":
+            if (str(tool.input?.file_path) !== null) {
+                return _jsx(ReadInputView, { tool: tool });
+            }
+            break;
+    }
+    return _jsx(KeyValueView, { tool: tool });
+}
+function PathHeader({ path, badge }) {
+    return (_jsxs("div", { className: "flex items-center gap-2 border-b border-border-subtle bg-surface-raised/50 px-2 py-1.5 font-[family-name:var(--font-mono)] text-[11px]", children: [_jsx("span", { className: "min-w-0 truncate text-foreground/80", children: path ? fileLabel(path) : "unknown file" }), badge && (_jsx("span", { className: "ml-auto shrink-0 rounded bg-primary/15 px-1.5 py-0.5 text-[10px] text-primary", children: badge }))] }));
+}
+/**
+ * Hand-rolled LCS diff (standard DP + forward walk) so we avoid pulling in the
+ * `diff` package. Returns ops in source order: `same` where the sequences
+ * agree, `del` for items only in `a`, `ins` for items only in `b`.
+ */
+function diffSeq(a, b, eq = (x, y) => x === y) {
+    const m = a.length;
+    const n = b.length;
+    // dp[i][j] = length of the LCS of a[i:] and b[j:]
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            dp[i][j] = eq(a[i], b[j])
+                ? dp[i + 1][j + 1] + 1
+                : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        if (eq(a[i], b[j])) {
+            ops.push({ kind: "same", value: a[i] });
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            ops.push({ kind: "del", value: a[i] });
+            i++;
+        }
+        else {
+            ops.push({ kind: "ins", value: b[j] });
+            j++;
+        }
+    }
+    while (i < m)
+        ops.push({ kind: "del", value: a[i++] });
+    while (j < n)
+        ops.push({ kind: "ins", value: b[j++] });
+    return ops;
+}
+/**
+ * Token-level LCS for a single deleted/inserted line pair. Splitting on
+ * `/(\s+)/` keeps the whitespace as its own tokens so we can reassemble the
+ * line exactly. Unchanged tokens are shared between both sides.
+ */
+function wordDiff(oldLine, newLine) {
+    const a = oldLine.split(/(\s+)/);
+    const b = newLine.split(/(\s+)/);
+    // Token-level LCS is O(words²); a pathological minified line would be slow.
+    // Above the cap, skip word refinement and flag the whole line as changed.
+    if (a.length * b.length > 10_000) {
+        return {
+            del: [{ text: oldLine, changed: true }],
+            ins: [{ text: newLine, changed: true }],
+        };
+    }
+    const ops = diffSeq(a, b);
+    const del = [];
+    const ins = [];
+    for (const op of ops) {
+        if (op.kind === "same") {
+            del.push({ text: op.value, changed: false });
+            ins.push({ text: op.value, changed: false });
+        }
+        else if (op.kind === "del") {
+            del.push({ text: op.value, changed: true });
+        }
+        else {
+            ins.push({ text: op.value, changed: true });
+        }
+    }
+    return { del, ins };
+}
+/**
+ * Merge `old_string`/`new_string` into a single diff: unchanged lines appear
+ * once as neutral, deletions/insertions keep the red/green treatment. A change
+ * block that is exactly one deleted line against one inserted line gets
+ * word-level highlighting.
+ */
+export function computeDiffRows(oldStr, newStr) {
+    const oldLines = oldStr.split("\n");
+    const newLines = newStr.split("\n");
+    // Line-level LCS is O(m×n) in time and memory; a huge Edit (thousands of
+    // lines) would build a massive DP matrix and hang the UI. Above the cap, fall
+    // back to a naive "all old removed, all new added" diff.
+    if (oldLines.length * newLines.length > 250_000) {
+        return [
+            ...oldLines.map((line) => ({ kind: "del", line, tokens: null })),
+            ...newLines.map((line) => ({ kind: "ins", line, tokens: null })),
+        ];
+    }
+    const ops = diffSeq(oldLines, newLines);
+    const rows = [];
+    let idx = 0;
+    while (idx < ops.length) {
+        if (ops[idx].kind === "same") {
+            rows.push({ kind: "same", line: ops[idx].value, tokens: null });
+            idx++;
+            continue;
+        }
+        // Collect a maximal run of changes, grouping deletes before inserts.
+        const dels = [];
+        const inss = [];
+        while (idx < ops.length && ops[idx].kind !== "same") {
+            if (ops[idx].kind === "del")
+                dels.push(ops[idx].value);
+            else
+                inss.push(ops[idx].value);
+            idx++;
+        }
+        if (dels.length === 1 && inss.length === 1) {
+            const { del, ins } = wordDiff(dels[0], inss[0]);
+            rows.push({ kind: "del", line: dels[0], tokens: del });
+            rows.push({ kind: "ins", line: inss[0], tokens: ins });
+        }
+        else {
+            for (const d of dels)
+                rows.push({ kind: "del", line: d, tokens: null });
+            for (const s of inss)
+                rows.push({ kind: "ins", line: s, tokens: null });
+        }
+    }
+    return rows;
+}
+/** Render a diff line, emphasizing changed word tokens when refined. */
+function DiffLine({ tokens, line, changedClass }) {
+    if (!tokens)
+        return _jsx(_Fragment, { children: line });
+    return (_jsx(_Fragment, { children: tokens.map((t, i) => t.changed ? (_jsx("span", { className: cn("rounded-sm", changedClass), children: t.text }, i)) : (_jsx("span", { children: t.text }, i))) }));
+}
+export function EditDiffView({ tool }) {
+    const rows = computeDiffRows(str(tool.input.old_string) ?? "", str(tool.input.new_string) ?? "");
+    return (_jsxs("div", { className: "overflow-hidden rounded-md border border-border-subtle", children: [_jsx(PathHeader, { path: str(tool.input.file_path), badge: tool.input.replace_all ? "replace all" : null }), _jsx("div", { className: "max-h-64 overflow-y-auto bg-background/60 py-1 font-[family-name:var(--font-mono)] text-[11px] leading-relaxed", children: rows.map((row, i) => {
+                    if (row.kind === "same") {
+                        return (_jsxs("div", { className: "flex", children: [_jsx("span", { className: "w-5 shrink-0 select-none text-center text-muted-foreground/30", children: " " }), _jsx("span", { className: "min-w-0 whitespace-pre-wrap break-all pr-2 text-muted-foreground/70", children: row.line })] }, `s${i}`));
+                    }
+                    if (row.kind === "del") {
+                        return (_jsxs("div", { className: "flex bg-red-500/10", children: [_jsx("span", { className: "w-5 shrink-0 select-none text-center text-red-400/70", children: "-" }), _jsx("span", { className: "min-w-0 whitespace-pre-wrap break-all pr-2 text-red-200/90", children: _jsx(DiffLine, { tokens: row.tokens, line: row.line, changedClass: "bg-red-500/30" }) })] }, `d${i}`));
+                    }
+                    return (_jsxs("div", { className: "flex bg-emerald-500/10", children: [_jsx("span", { className: "w-5 shrink-0 select-none text-center text-emerald-400/70", children: "+" }), _jsx("span", { className: "min-w-0 whitespace-pre-wrap break-all pr-2 text-emerald-200/90", children: _jsx(DiffLine, { tokens: row.tokens, line: row.line, changedClass: "bg-emerald-500/30" }) })] }, `i${i}`));
+                }) })] }));
+}
+/** Longest backtick run + 1 so the fence survives content containing fences. */
+export function fenceFor(content) {
+    const runs = content.match(/`+/g);
+    const longest = runs ? Math.max(...runs.map((r) => r.length)) : 0;
+    return "`".repeat(Math.max(3, longest + 1));
+}
+export function WriteFileView({ tool }) {
+    const content = str(tool.input.content) ?? "";
+    const path = str(tool.input.file_path);
+    const ext = path?.match(/\.([a-z0-9]{1,8})$/i)?.[1] ?? "";
+    const fence = fenceFor(content);
+    return (_jsxs("div", { className: "overflow-hidden rounded-md border border-border-subtle", children: [_jsx(PathHeader, { path: path, badge: `${countLines(content)} lines` }), _jsx("div", { className: "max-h-64 overflow-y-auto [&_pre]:!my-0 [&_pre]:rounded-none [&_pre]:border-0 [&_pre]:bg-background/60 [&_pre]:p-2 [&_pre]:text-[11px]", children: _jsx(MarkdownContent, { content: `${fence}${ext}\n${content}\n${fence}` }) })] }));
+}
+export function BashCommandView({ tool }) {
+    const command = str(tool.input.command) ?? "";
+    const flags = [];
+    if (tool.input.run_in_background)
+        flags.push("background");
+    const timeout = num(tool.input.timeout);
+    if (timeout)
+        flags.push(`timeout ${Math.round(timeout / 1000)}s`);
+    if (tool.input.dangerouslyDisableSandbox)
+        flags.push("sandbox disabled");
+    return (_jsxs("div", { className: "rounded-md bg-background/60 p-2 font-[family-name:var(--font-mono)] text-[11px] leading-relaxed", children: [_jsxs("div", { className: "flex gap-1.5", children: [_jsx("span", { className: "select-none text-primary", children: "$" }), _jsx("span", { className: "min-w-0 whitespace-pre-wrap break-all text-foreground/90", children: command })] }), flags.length > 0 && (_jsx("div", { className: "mt-1.5 flex flex-wrap gap-1", children: flags.map((f) => (_jsx("span", { className: cn("rounded px-1.5 py-0.5 text-[10px]", f === "sandbox disabled"
+                        ? "bg-destructive/15 text-destructive"
+                        : "bg-surface-raised text-muted-foreground"), children: f }, f))) }))] }));
+}
+function ReadInputView({ tool }) {
+    const path = str(tool.input.file_path) ?? "";
+    const offset = num(tool.input.offset);
+    const limit = num(tool.input.limit);
+    const range = offset !== null && limit !== null
+        ? `lines ${offset}–${offset + limit}`
+        : offset !== null
+            ? `from line ${offset}`
+            : "full file";
+    return (_jsxs("div", { className: "flex items-center gap-2 rounded-md bg-background/60 px-2 py-1.5 font-[family-name:var(--font-mono)] text-[11px]", children: [_jsx("span", { className: "min-w-0 truncate text-foreground/80", children: fileLabel(path) }), _jsx("span", { className: "ml-auto shrink-0 text-muted-foreground/60", children: range })] }));
+}
+/** Generic structured input: one row per field beats raw JSON for scanning. */
+export function KeyValueView({ tool }) {
+    const entries = Object.entries(tool.input ?? {});
+    if (entries.length === 0) {
+        return (_jsx("pre", { className: "overflow-x-auto rounded-md bg-background/60 p-2 font-[family-name:var(--font-mono)] text-[11px] leading-relaxed text-muted-foreground", children: tool.inputJson || "{}" }));
+    }
+    return (_jsx("div", { className: "space-y-1 rounded-md bg-background/60 p-2", children: entries.map(([key, value]) => (_jsxs("div", { className: "flex gap-2 font-[family-name:var(--font-mono)] text-[11px] leading-relaxed", children: [_jsxs("span", { className: "shrink-0 text-muted-foreground/50", children: [key, ":"] }), _jsx("span", { className: "max-h-40 min-w-0 overflow-y-auto whitespace-pre-wrap break-words text-muted-foreground", children: typeof value === "string"
+                        ? linkifyPaths(value)
+                        : JSON.stringify(value, null, 1) })] }, key))) }));
+}
+// ============================================================
+// Output views
+// ============================================================
+export function ToolOutputView({ tool }) {
+    const output = tool.output;
+    if (!output)
+        return null;
+    if (tool.isError) {
+        return _jsx(ClampedPre, { text: output, isError: true });
+    }
+    switch (tool.name) {
+        case "Agent":
+        case "WebFetch":
+            // These outputs are prose (subagent reports, page summaries)
+            return (_jsx(ClampedBox, { lineLabel: `${countLines(output)} lines`, children: _jsx("div", { className: "rounded-md bg-background/60 p-3 text-[13px]", children: _jsx(MarkdownContent, { content: output }) }) }));
+        case "Grep":
+            return _jsx(FileRowsView, { output: output, pattern: str(tool.input?.pattern) });
+        case "Glob":
+            return _jsx(FileRowsView, { output: output });
+        case "Read":
+            return _jsx(ReadOutputStub, { output: output });
+        case "WebSearch":
+            return _jsx(WebSearchResultsView, { output: output });
+        default:
+            return _jsx(ClampedPre, { text: output });
+    }
+}
+/** DOM-safety cap; "Show all" raises it but never renders unbounded output. */
+const CLAMP_HARD_CAP = 50_000;
+const CLAMP_SHOW_ALL_CAP = 200_000;
+export function ClampedPre({ text, isError }) {
+    const lines = countLines(text.trimEnd());
+    const clampable = lines > 16 || text.length > 1600;
+    const [showAll, setShowAll] = useState(false);
+    const shown = showAll ? text.slice(0, CLAMP_SHOW_ALL_CAP) : text.slice(0, CLAMP_HARD_CAP);
+    return (_jsxs("div", { children: [_jsxs("div", { className: cn("relative", clampable && !showAll && "max-h-56 overflow-hidden"), children: [_jsxs("pre", { className: cn("overflow-x-auto rounded-md p-2 pr-7 font-[family-name:var(--font-mono)] text-[11px] leading-relaxed", isError
+                            ? "bg-destructive/10 text-destructive"
+                            : "bg-background/60 text-muted-foreground"), children: [linkifyPaths(shown), text.length > shown.length && "\n…"] }), clampable && !showAll && (_jsx("div", { className: "pointer-events-none absolute inset-x-0 bottom-0 h-10 rounded-b-md bg-gradient-to-t from-surface to-transparent" }))] }), clampable && (_jsx("button", { type: "button", onClick: () => setShowAll(!showAll), className: "mt-1 text-[10px] text-muted-foreground/60 transition-colors hover:text-foreground", children: showAll ? "Collapse" : `Show all (${lines} lines)` }))] }));
+}
+/** Same clamp behavior for arbitrary children (markdown outputs). */
+function ClampedBox({ children, lineLabel }) {
+    const [showAll, setShowAll] = useState(false);
+    return (_jsxs("div", { children: [_jsxs("div", { className: cn("relative", !showAll && "max-h-72 overflow-hidden"), children: [children, !showAll && (_jsx("div", { className: "pointer-events-none absolute inset-x-0 bottom-0 h-10 rounded-b-md bg-gradient-to-t from-surface to-transparent" }))] }), _jsx("button", { type: "button", onClick: () => setShowAll(!showAll), className: "mt-1 text-[10px] text-muted-foreground/60 transition-colors hover:text-foreground", children: showAll ? "Collapse" : `Show all (${lineLabel})` })] }));
+}
+/**
+ * Compile a Grep pattern for match highlighting.
+ *
+ * We run this against every visible row during render, so it must be safe
+ * against catastrophic backtracking (ReDoS) — a synchronous `RegExp.exec` can't
+ * be interrupted, so a pattern like `(a+)+$` would freeze the UI thread. A
+ * pattern that contains no unbounded-repetition operator (`*`, `+`, `{`) cannot
+ * backtrack exponentially, so only those compile as real regexes; anything else
+ * (and any pattern that fails to compile, e.g. `c++`, `(`) is matched as an
+ * escaped literal. Both paths are linear-time. Returns null if even the literal
+ * form can't compile, so callers degrade to unhighlighted rows instead of
+ * throwing.
+ */
+export function safeSearchRegex(pattern) {
+    if (!pattern)
+        return null;
+    if (!/[*+{]/.test(pattern)) {
+        try {
+            return new RegExp(pattern, "gi");
+        }
+        catch {
+            // fall through to the escaped-literal form
+        }
+    }
+    try {
+        return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Split `text` into alternating non-match / match segments for a global regex.
+ * Zero-width matches are skipped (advancing lastIndex) so patterns like `a*`
+ * never spin. Purely string-in / segments-out so it's easy to unit test.
+ */
+export function splitMatches(text, re) {
+    const segments = [];
+    re.lastIndex = 0;
+    let last = 0;
+    let m;
+    let guard = 0;
+    while ((m = re.exec(text)) !== null) {
+        if (guard++ > 10_000)
+            break;
+        if (m[0].length === 0) {
+            re.lastIndex++;
+            continue;
+        }
+        if (m.index > last)
+            segments.push({ text: text.slice(last, m.index), match: false });
+        segments.push({ text: m[0], match: true });
+        last = m.index + m[0].length;
+    }
+    if (last < text.length)
+        segments.push({ text: text.slice(last), match: false });
+    return segments;
+}
+/**
+ * Split a ripgrep-style `path:line:content` row into its linkable prefix and
+ * the content portion. Returns null when the row has no such prefix (e.g. Glob
+ * paths or an unusual format), so the caller can treat the whole line as content.
+ */
+export function splitGrepRow(line) {
+    const m = line.match(/^(.+?:\d+:)([\s\S]*)$/);
+    if (!m)
+        return null;
+    return { prefix: m[1], content: m[2] };
+}
+/** Grep/Glob results: one clickable row per line. */
+export function FileRowsView({ output, pattern }) {
+    const lines = output
+        .split("\n")
+        .map((l) => l.trimEnd())
+        .filter((l) => l.trim().length > 0);
+    // Degenerate outputs fall back to the plain view
+    if (lines.length === 0 || lines.length > 400) {
+        return _jsx(ClampedPre, { text: output });
+    }
+    const re = pattern ? safeSearchRegex(pattern) : null;
+    // Highlight the matched term inside the CONTENT only — never the `path:line:`
+    // prefix (a highlight there would imply the match was in the path and would
+    // fragment the path link). The prefix keeps full path linkification.
+    const renderRow = (line) => {
+        if (!re)
+            return linkifyPaths(line);
+        const split = splitGrepRow(line);
+        const prefix = split?.prefix ?? "";
+        const content = split ? split.content : line;
+        return (_jsxs(_Fragment, { children: [prefix && _jsx("span", { children: linkifyPaths(prefix) }), splitMatches(content, re).map((seg, i) => seg.match ? (_jsx("mark", { className: "rounded-sm bg-amber-400/25 px-0.5 text-amber-100", children: seg.text }, i)) : (_jsx("span", { children: linkifyPaths(seg.text) }, i)))] }));
+    };
+    return (_jsx("div", { className: "max-h-56 overflow-y-auto rounded-md bg-background/60 font-[family-name:var(--font-mono)] text-[11px] leading-relaxed", children: lines.map((line, i) => (_jsx("div", { className: "whitespace-pre-wrap break-all border-b border-border/10 px-2 py-1 last:border-0", children: renderRow(line) }, i))) }));
+}
+/**
+ * Tolerant parser for WebSearch output. The raw text is semi-structured, so we
+ * try a few shapes in priority order — JSON `{title,url}` objects, markdown
+ * links, then a line-scan that pairs a bare URL with nearby title text —
+ * de-duplicating by URL. Garbage input yields `[]` and never throws.
+ */
+export function parseWebSearchResults(output) {
+    const results = [];
+    const seen = new Set();
+    const push = (title, url) => {
+        // Trim trailing sentence punctuation, but keep brackets that are balanced
+        // inside the URL itself — e.g. `…/Function_(mathematics)` must keep its `)`.
+        let u = url.trim().replace(/[.,;:'"]+$/, "");
+        while ((u.endsWith(")") && !u.includes("(")) ||
+            (u.endsWith("]") && !u.includes("["))) {
+            u = u.slice(0, -1).replace(/[.,;:'"]+$/, "");
+        }
+        if (!/^https?:\/\//i.test(u) || seen.has(u))
+            return;
+        seen.add(u);
+        const t = title.trim().replace(/^[-*\d.)\s]+/, "").trim();
+        results.push({ title: t || u, url: u });
+    };
+    // 1. JSON objects carrying "title"/"url" keys
+    for (const m of output.matchAll(/\{[^{}]*\}/g)) {
+        const url = m[0].match(/"url"\s*:\s*"([^"]+)"/)?.[1];
+        if (!url)
+            continue;
+        push(m[0].match(/"title"\s*:\s*"([^"]*)"/)?.[1] ?? "", url);
+    }
+    if (results.length)
+        return results;
+    // 2. Markdown links [title](url)
+    for (const m of output.matchAll(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g)) {
+        push(m[1], m[2]);
+    }
+    if (results.length)
+        return results;
+    // 3. Line scan: a URL uses the leading text on its line, else the line above.
+    // Capture greedily to whitespace (so balanced parens like `/Foo_(bar)` survive)
+    // and let `push` trim any unbalanced trailing bracket / sentence punctuation.
+    const urlRe = /(https?:\/\/\S+)/;
+    let lastText = "";
+    for (const raw of output.split("\n")) {
+        const line = raw.trim();
+        const um = line.match(urlRe);
+        if (um) {
+            push(line.slice(0, um.index).trim() || lastText, um[1]);
+            lastText = "";
+        }
+        else if (line) {
+            lastText = line;
+        }
+    }
+    return results;
+}
+/** Structured WebSearch results: title links with a dimmed host beneath. */
+function WebSearchResultsView({ output }) {
+    const results = parseWebSearchResults(output);
+    if (results.length === 0)
+        return _jsx(ClampedPre, { text: output });
+    return (_jsx("div", { className: "space-y-1.5 rounded-md bg-background/60 p-2 text-[11px]", children: results.map((r, i) => {
+            let host = r.url;
+            try {
+                host = new URL(r.url).host;
+            }
+            catch {
+                // keep the raw URL as the host label
+            }
+            return (_jsxs("div", { className: "min-w-0", children: [_jsx("a", { href: r.url, target: "_blank", rel: "noopener noreferrer", className: "block truncate text-primary hover:underline", children: r.title }), _jsx("span", { className: "block truncate text-[10px] text-muted-foreground/60", children: host })] }, i));
+        }) }));
+}
+/** Read output is rarely worth showing — collapse to a stub by default. */
+function ReadOutputStub({ output }) {
+    const [open, setOpen] = useState(false);
+    const lines = countLines(output.trimEnd());
+    return (_jsxs("div", { children: [_jsxs("button", { type: "button", onClick: () => setOpen(!open), className: "flex items-center gap-1 text-[10px] text-muted-foreground/60 transition-colors hover:text-foreground", children: [_jsx(ChevronRight, { className: cn("h-3 w-3 transition-transform", open && "rotate-90") }), lines, " lines read"] }), open && (_jsx("div", { className: "mt-1", children: _jsx(ClampedPre, { text: output }) }))] }));
+}
+//# sourceMappingURL=tool-views.js.map