// SPDX-License-Identifier: Apache-2.0
//
// Draws lean-ctx results the way Claude Code draws its own: ctx_patch evidence
// through the engine's diff renderer, ctx_read code and ctx_search hits
// syntax-highlighted with line numbers. Display only — the model receives
// every result byte-for-byte. Anything this file does not recognise (map and
// signatures views, errors, running calls) falls through to the engine.
//
// The formats read here are lean-ctx's own output contract: the ```diff fence
// of ctx_patch, the `name NL` header with ` N| ` or `N:hash|` rows of
// ctx_read, and `path:line text` hits of ctx_search.
import type { Elements as SurfaceElements, EngineInterface, On, RenderElement } from "claude-code";
const TOOLS = [
"mcp__lean-ctx__ctx_patch",
"mcp__lean-ctx__ctx_read",
"mcp__lean-ctx__ctx_search",
"mcp__lean_ctx__ctx_patch",
"mcp__lean_ctx__ctx_read",
"mcp__lean_ctx__ctx_search",
] as const;
type LeanTool = (typeof TOOLS)[number];
/** One block under the call row. */
type Block =
| { kind: "note"; text: string }
| { kind: "code"; source: string; path?: string; startLine?: number }
| { kind: "diff"; source: string; path?: string }
| { kind: "hit"; location: string; path: string; line: string; symbol?: string };
/** What a result turns into: the call row's one-line summary and the blocks. */
type Drawing = { summary: string; blocks: Block[] };
// The engine caps one Code drawing; past it a result stays plain.
const MAX_CODE_CHARS = 100_000;
const DIFF_FENCE = /^```diff[ \t]*\n([\s\S]*?)\n?^```[ \t]*$/gm;
const NEW_FILE = /^\+\+\+ (?:b\/)?(\S+)/m;
// A ctx_patch receipt's pointer to the diff lean-ctx archived for this mod.
const DIFF_TRAILER = /^\[diff:([0-9a-f]{16})\]$/gm;
const READ_HEADER = /^(\S+) \d+L\b/;
const LINES_ROW = /^ *(\d+)\| ?(.*)$/;
const ANCHOR_ROW = /^(\d+):[0-9a-f]{2,8}\|(.*)$/;
const SEARCH_HIT = /^([^\s:]+):(\d+) (.*)$/;
const SYMBOL_SUFFIX = / ∈(\S+@L\d+)$/;
export function registerResultRendering(on: On): void {
on(
"ui.render",
{
component: "ToolUse",
props: { tool: TOOLS, isRunning: false, isErrored: false, isInterrupted: false },
},
async ($, event, next) => {
const props = event.props;
await loadArtifacts($, props.tool, props.output);
const drawing = drawingFor(props.tool, props.tool_use_id, props.output, props.input);
if (!drawing) return next(event);
// The engine keeps the call row; only its result text shrinks to the summary.
const row = await next({
...event,
props: { ...props, output: [{ type: "text", text: drawing.summary }] },
});
const els = $.ui.resolve(event);
return (
<els.Box flexDirection="column">
{row}
<els.Box flexDirection="column" paddingLeft={5}>
{drawBlocks(els, drawing.blocks)}
</els.Box>
</els.Box>
);
},
);
on(
"ui.render",
{ component: "ToolResult", props: { tool: TOOLS, isErrored: false } },
async ($, event, next) => {
const props = event.props;
// A standalone result has no call input: headerless full reads stay plain.
await loadArtifacts($, props.tool, props.output);
const drawing = drawingFor(props.tool, `result:${props.tool_use_id}`, props.output, undefined);
if (!drawing) return next(event);
const els = $.ui.resolve(event);
return (
<els.Box flexDirection="column">
<els.Text dimColor>{drawing.summary}</els.Text>
{drawBlocks(els, drawing.blocks)}
</els.Box>
);
},
);
}
// ── Parsing (pure, exported for tests) ──────────────────────────────────────
export function resultText(output: unknown): string {
if (typeof output === "string") return output;
if (Array.isArray(output)) {
return output
.map((part) => (part && typeof part === "object" && "text" in part ? String(part.text) : ""))
.filter((text) => text.length > 0)
.join("\n");
}
if (output && typeof output === "object" && "content" in output) {
return resultText((output as { content: unknown }).content);
}
return "";
}
/** The ids of the `[diff:<id>]` trailers a ctx_patch receipt names. */
export function diffArtifactIds(text: string): string[] {
return [...text.matchAll(DIFF_TRAILER)].map((match) => match[1] ?? "").filter((id) => id);
}
/**
* ctx_patch: every ```diff fence becomes a diff block (`evidence=true`, and
* receipts before 3.12.1); a `[diff:<id>]` trailer becomes the archived diff
* from `artifacts`, which the model never reads. The `patched …`/`created …`
* (or legacy `✓`) line is the summary.
*/
export function drawPatch(text: string, artifacts: ReadonlyMap<string, string> = new Map()): Drawing | null {
const blocks: Block[] = [];
let summary = "";
let cursor = 0;
let drawn = false;
const pushNotes = (chunk: string) => {
for (const line of chunk.split("\n")) {
const trailer = /^\[diff:([0-9a-f]{16})\]$/.exec(line);
if (trailer) {
const source = artifacts.get(trailer[1] ?? "");
if (source === undefined || source.length > MAX_CODE_CHARS) continue;
blocks.push({ kind: "diff", source, path: NEW_FILE.exec(source)?.[1] });
drawn = true;
} else if (!summary && /^(?:patched |created |✓)/.test(line)) summary = line;
else if (line.trim()) blocks.push({ kind: "note", text: line });
}
};
for (const match of text.matchAll(DIFF_FENCE)) {
pushNotes(text.slice(cursor, match.index));
const source = match[1] ?? "";
if (source.length > MAX_CODE_CHARS) return null;
blocks.push({ kind: "diff", source, path: NEW_FILE.exec(source)?.[1] });
drawn = true;
cursor = (match.index ?? 0) + match[0].length;
}
pushNotes(text.slice(cursor));
if (!drawn) return null;
return { summary: summary || "✓ patched", blocks: mergeNotes(blocks) };
}
/** ctx_read: numbered views (lines, anchored) of one or several files; full/raw with input. */
export function drawRead(text: string, input: unknown): Drawing | null {
const args = (input ?? {}) as { path?: unknown; paths?: unknown; mode?: unknown; raw?: unknown };
const body = text.replace(/\n+$/, "");
const files = body.split("\n---\n");
if (files.length > 1) {
const last = files[files.length - 1] ?? "";
if (!/^Read \d+ files?\b/.test(last)) return null;
const blocks: Block[] = [];
for (const file of files.slice(0, -1)) {
const numbered = numberedBlocks(file, undefined);
if (!numbered) return null;
blocks.push({ kind: "note", text: numbered.header }, ...numbered.blocks);
}
return { summary: last.split("\n")[0] ?? last, blocks };
}
const path = typeof args.path === "string" ? args.path : undefined;
const numbered = numberedBlocks(body, path);
if (numbered) return { summary: numbered.header, blocks: numbered.blocks };
const verbatim = args.raw === true || args.mode === "full" || args.mode === "raw";
if (!verbatim || !path || body.length > MAX_CODE_CHARS) return null;
const { code, trailer } = splitTrailer(body);
// One line is more likely an error than a file.
if (code.split("\n").filter((line) => line.trim()).length < 2) return null;
const blocks: Block[] = [{ kind: "code", source: code, path, startLine: 1 }];
if (trailer) blocks.push({ kind: "note", text: trailer });
return { summary: `${baseName(path)} ${code.split("\n").length}L`, blocks };
}
/** ctx_search: `path:line text` hits; everything else is a note. */
export function drawSearch(text: string): Drawing | null {
const [summary = "", ...lines] = text.replace(/\n+$/, "").split("\n");
const blocks: Block[] = [];
for (const line of lines) {
const hit = SEARCH_HIT.exec(line);
if (!hit) {
if (line.trim()) blocks.push({ kind: "note", text: line });
continue;
}
const [, path = "", lineNo = "", rest = ""] = hit;
const symbol = SYMBOL_SUFFIX.exec(rest);
blocks.push({
kind: "hit",
location: `${path}:${lineNo}`,
path,
line: (symbol ? rest.slice(0, symbol.index) : rest).replace(/\t/g, " ").trimEnd(),
symbol: symbol?.[1],
});
}
if (!blocks.some((block) => block.kind === "hit")) return null;
return { summary, blocks: mergeNotes(blocks) };
}
function numberedBlocks(
text: string,
path: string | undefined,
): { header: string; blocks: Block[] } | null {
const [header = "", ...rows] = text.split("\n");
const named = READ_HEADER.exec(header);
if (!named) return null;
const rowPattern = ANCHOR_ROW.test(rows[0] ?? "") ? ANCHOR_ROW : LINES_ROW;
const filePath = path ?? named[1];
const blocks: Block[] = [];
let run: string[] = [];
let first = 0;
let previous = 0;
let index = 0;
const flush = () => {
if (run.length) blocks.push({ kind: "code", source: run.join("\n"), path: filePath, startLine: first });
run = [];
};
for (; index < rows.length; index++) {
const row = rowPattern.exec(rows[index] ?? "");
if (!row) break;
const lineNo = Number(row[1]);
// `lines:1-5,20-30` leaves gaps: each contiguous run numbers itself.
if (run.length && lineNo !== previous + 1) flush();
if (!run.length) first = lineNo;
run.push(row[2] ?? "");
previous = lineNo;
}
flush();
if (!blocks.length) return null;
const tail = rows.slice(index).join("\n").trim();
if (tail) blocks.push({ kind: "note", text: tail });
return { header, blocks };
}
/** Trailing `[lean-ctx …]` / `[… truncated …]` service lines are not code. */
function splitTrailer(text: string): { code: string; trailer: string } {
const lines = text.split("\n");
let end = lines.length;
while (end > 0 && /^\[(?:lean-ctx|…)/.test(lines[end - 1] ?? "")) end--;
return { code: lines.slice(0, end).join("\n"), trailer: lines.slice(end).join("\n") };
}
function mergeNotes(blocks: Block[]): Block[] {
const merged: Block[] = [];
for (const block of blocks) {
const last = merged[merged.length - 1];
if (block.kind === "note" && last?.kind === "note") last.text += `\n${block.text}`;
else merged.push({ ...block });
}
return merged;
}
function baseName(path: string): string {
return path.slice(Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1);
}
// ── Drawing ─────────────────────────────────────────────────────────────────
// Tool rows draw on every surface; these three elements exist on all of them.
type Elements = Pick<SurfaceElements[keyof SurfaceElements], "Box" | "Text" | "Code">;
// Finished results never change, but rows redraw on scroll and resize.
const CACHE_LIMIT = 200;
const drawings = new Map<string, { text: string; loaded: number; drawing: Drawing | null }>();
// Archived ctx_patch diffs by id (content-addressed, so never stale), and the
// lean-ctx data directory they live under, as lean-ctx reports it.
const artifacts = new Map<string, string>();
let archiveRoot: Promise<string | undefined> | undefined;
function locateArchive($: EngineInterface): Promise<string | undefined> {
archiveRoot ??= $.process
.run(["lean-ctx", "prompt-segment", "--json"], { timeoutMs: 15_000 })
.then(({ exitCode, stdout }) => {
if (exitCode !== 0) return undefined;
const parsed: unknown = JSON.parse(stdout);
const watch = parsed && typeof parsed === "object" ? (parsed as { watch?: unknown }).watch : undefined;
// `<data>/value/projects` → `<data>/archives`
return typeof watch === "string" ? `${watch.replace(/[\\/]value[\\/]projects[\\/]?$/, "")}/archives` : undefined;
})
.catch(() => undefined);
return archiveRoot;
}
/** Reads each archived diff a ctx_patch receipt names; a missing one is left out. */
async function loadArtifacts($: EngineInterface, tool: LeanTool, output: unknown): Promise<void> {
if (!tool.endsWith("__ctx_patch")) return;
const ids = diffArtifactIds(resultText(output)).filter((id) => !artifacts.has(id));
if (!ids.length) return;
const root = await locateArchive($);
if (!root) return;
for (const id of ids) {
// The archive's own layout: `<archives>/<first 2 hex>/<id>.txt`.
const diff = await $.fs.read(`${root}/${id.slice(0, 2)}/${id}.txt`).catch(() => undefined);
if (typeof diff === "string") artifacts.set(id, diff);
}
}
function drawingFor(tool: LeanTool, key: string, output: unknown, input: unknown): Drawing | null {
const text = resultText(output);
const cached = drawings.get(key);
const loaded = diffArtifactIds(text).filter((id) => artifacts.has(id)).length;
if (cached && cached.text === text && cached.loaded === loaded) return cached.drawing;
const name = tool.slice(tool.lastIndexOf("__") + 2);
const drawing =
name === "ctx_patch"
? drawPatch(text, artifacts)
: name === "ctx_read"
? drawRead(text, input)
: drawSearch(text);
if (drawings.size >= CACHE_LIMIT) {
const oldest = drawings.keys().next();
if (!oldest.done) drawings.delete(oldest.value);
}
drawings.set(key, { text, loaded, drawing });
return drawing;
}
function drawBlocks(els: Elements, blocks: Block[]): RenderElement[] {
return blocks.map((block, index) => {
const key = `b${index}`;
switch (block.kind) {
case "note":
return (
<els.Text key={key} dimColor>
{block.text}
</els.Text>
);
case "diff":
return <els.Code key={key} source={block.source} path={block.path} format="diff" />;
case "code":
return <els.Code key={key} source={block.source} path={block.path} startLine={block.startLine} />;
case "hit":
return (
<els.Box key={key} flexDirection="row">
<els.Box flexShrink={0}>
<els.Text dimColor>{`${block.location} `}</els.Text>
</els.Box>
<els.Box flexShrink={1}>
<els.Code source={block.line} path={block.path} wrap="truncate-end" />
</els.Box>
{block.symbol ? (
<els.Box flexShrink={0}>
<els.Text dimColor>{` ∈ ${block.symbol}`}</els.Text>
</els.Box>
) : null}
</els.Box>
);
}
});
}