pi-ast-sgrep 2.0.2 → 2.1.1

package/dist/ui/card.js

@@ -0,0 +1,316 @@
+/** Pi TUI result card — supernova-style: the call slot is empty; one card
+ * owns the whole lifecycle (running → ops ledger → result → error). Rows are
+ * fixed-column and theme-painted; nothing here writes to the model channel. */
+import { hitLabel, hitLocation, paint, truncateToWidth, visibleWidth, } from "./present.js";
+/** Header text that rides the top border: "asgrep search · 4 hits · 12ms · napi". */
+function frameLabel(model) {
+    const bits = ["asgrep", model.command, ...model.title.filter((b) => Boolean(b))];
+    const tail = model.error ? "failed" : model.running ? "running" : "";
+    if (tail)
+        bits.push(tail);
+    const counts = [];
+    if (model.ops?.length)
+        counts.push(model.ops.length + (model.ops.length === 1 ? " call" : " calls"));
+    if (model.hits)
+        counts.push(model.hits.length + (model.hits.length === 1 ? " hit" : " hits"));
+    return [...bits.slice(0, 2), ...counts, ...bits.slice(2)].join(" \u00b7 ");
+}
+/** renderCall component that paints nothing — the result card owns display. */
+export const EMPTY_CALL = {
+    render: () => [],
+    invalidate() { },
+};
+const TOOL_COL = 12;
+const DUR_COL = 7;
+const MAX_CARD_WIDTH = 100;
+/** Rounded frame glyphs — pi themes may provide theme.boxRound; default ASCII-art set. */
+const BOX = { tl: "\u256d", tr: "\u256e", bl: "\u2570", br: "\u256f", h: "\u2500", v: "\u2502" };
+function boxOf(theme) {
+    const b = theme?.boxRound;
+    if (b && typeof b.topLeft === "string" && typeof b.horizontal === "string" && typeof b.vertical === "string") {
+        return { tl: b.topLeft, tr: b.topRight ?? BOX.tr, bl: b.bottomLeft ?? BOX.bl, br: b.bottomRight ?? BOX.br, h: b.horizontal, v: b.vertical };
+    }
+    return BOX;
+}
+function borderKey(model) {
+    if (model.error)
+        return "error";
+    if (model.running)
+        return "accent";
+    return "dim";
+}
+/** Top/bottom bar with an optional label embedded in the rule. Geometry is in
+ * display cells (frameW): \u256d + 3 rules on the left, corner on the right. */
+function frameBar(theme, box, border, left, right, label, width) {
+    const leftRaw = left + box.h.repeat(3);
+    const shown = label ? clamp(" " + label + " ", Math.max(0, width - frameW(leftRaw) - 1)) : "";
+    const fill = Math.max(0, width - frameW(leftRaw) - frameW(shown) - 1);
+    return border(leftRaw) + shown + border(box.h.repeat(fill)) + border(right);
+}
+/** ANSI-aware cut to `width` display columns on the same scale as frameW
+ * (stripped code-point count). Unlike truncateToWidth this never leaves an
+ * unclosed SGR color behind: a cut inside a painted span appends \x1b[0m
+ * before the ellipsis so the row cannot bleed color into the right border. */
+function clamp(text, width) {
+    const limit = Math.max(1, width);
+    if (frameW(text) <= limit)
+        return text;
+    const budget = Math.max(1, limit - 1); // room for the ellipsis
+    const ansi = /\u001b\[[0-9;]*m/gu;
+    const stops = [];
+    for (let match = ansi.exec(text); match !== null; match = ansi.exec(text)) {
+        stops.push([match.index, match.index + match[0].length]);
+    }
+    let kept = "";
+    let visible = 0;
+    let index = 0;
+    let stopIndex = 0;
+    while (index < text.length && visible < budget) {
+        if (stopIndex < stops.length && index === stops[stopIndex][0]) {
+            const [, end] = stops[stopIndex];
+            kept += text.slice(index, end);
+            index = end;
+            stopIndex += 1;
+            continue;
+        }
+        kept += text[index];
+        visible += 1;
+        index += 1;
+    }
+    return kept + (stops.length > 0 ? "\u001b[0m" : "") + "\u2026";
+}
+function fitPath(text, budget) {
+    if (visibleWidth(text) <= budget)
+        return text;
+    if (budget <= 1)
+        return "\u2026";
+    return "\u2026" + text.slice(Math.max(0, text.length - budget + 1));
+}
+/** Display columns for frame geometry: ANSI-stripped code-point count.
+ * Box glyphs/·/✓ render width-1 in real terminals; the conservative
+ * visibleWidth() over-counts them (width 2) which would ragged the box. */
+function frameW(text) {
+    return text.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function fmtMs(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return "";
+    return ms < 1000 ? Math.round(ms) + "ms" : (ms / 1000).toFixed(1) + "s";
+}
+/** "✓ search      12ms  \"query\"" — one aligned op row. */
+function opRow(theme, op, width) {
+    const marker = op.ok ? paint(theme, "success", "\u2713") : paint(theme, "error", "\u00d7");
+    const tool = paint(theme, "syntaxFunction", op.tool.slice(0, TOOL_COL).padEnd(TOOL_COL));
+    const dur = paint(theme, "dim", fmtMs(op.ms).padStart(DUR_COL));
+    const target = op.target ? "  " + paint(theme, "muted", fitPath(op.target, Math.max(1, width - TOOL_COL - DUR_COL - 9))) : "";
+    return " " + marker + " " + tool + " " + dur + target;
+}
+/** " 1. path:line   symbol · kind" — one numbered hit row. */
+function hitRow(theme, n, hit, width) {
+    const num = paint(theme, "dim", String(n).padStart(2) + ".");
+    const loc = hitLocation(hit);
+    const locBudget = Math.max(8, Math.floor(width * 0.62));
+    const locText = paint(theme, "accent", fitPath(loc, locBudget));
+    const label = hitLabel(hit);
+    const row = " " + num + " " + locText + (label ? "  " + paint(theme, "muted", label) : "");
+    return clamp(row, width);
+}
+export class AsgrepCard {
+    theme;
+    model;
+    cache;
+    set(theme, model) {
+        this.theme = theme;
+        this.model = model;
+        this.cache = undefined;
+    }
+    invalidate() {
+        this.cache = undefined;
+    }
+    render(width = 80) {
+        const theme = this.theme;
+        const model = this.model;
+        if (!model || width <= 0)
+            return [];
+        if (this.cache?.width === width)
+            return this.cache.lines;
+        // Pi hands us the full terminal width — a hollow frame at 200+ cols is a
+        // wall of empty border. Cap at a readable card width; pi pads the rest.
+        const lines = framedLines(theme, model, Math.min(Math.max(8, width), MAX_CARD_WIDTH));
+        this.cache = { width, lines };
+        return lines;
+    }
+}
+/** Rounded card: header embedded in the top rule, body rows in \u2502 gutters. */
+function framedLines(theme, model, width) {
+    const box = boxOf(theme);
+    const key = borderKey(model);
+    const border = (text) => paint(theme, key, text);
+    const inner = Math.max(1, width - 4); // "\u2502 " + content + " \u2502"
+    const label = frameLabel(model);
+    const rows = bodyLines(theme, model, inner);
+    const out = [frameBar(theme, box, border, box.tl, box.tr, label, width)];
+    for (const row of rows) {
+        const body = clamp(row, inner);
+        const pad = Math.max(0, inner - frameW(body));
+        out.push(border(box.v) + " " + body + " ".repeat(pad) + " " + border(box.v));
+    }
+    out.push(frameBar(theme, box, border, box.bl, box.br, null, width));
+    return out;
+}
+function bodyLines(theme, model, width) {
+    const lines = [];
+    const maxOps = model.expanded ? 24 : 8;
+    const maxHits = model.expanded ? 24 : 12;
+    const ops = (model.ops ?? []).slice(0, maxOps);
+    for (const op of ops)
+        lines.push(clamp(opRow(theme, op, width), width));
+    if ((model.ops?.length ?? 0) > ops.length) {
+        lines.push(paint(theme, "dim", "   \u2026 " + ((model.ops?.length ?? 0) - ops.length) + " more calls"));
+    }
+    const hits = (model.hits ?? []).slice(0, maxHits);
+    hits.forEach((hit, i) => lines.push(hitRow(theme, i + 1, hit, width)));
+    if ((model.hits?.length ?? 0) > hits.length) {
+        lines.push(paint(theme, "dim", "   \u2026 " + ((model.hits?.length ?? 0) - hits.length) + " more"));
+    }
+    for (const edit of (model.edits ?? []).slice(0, model.expanded ? 12 : 4)) {
+        const head = " " + paint(theme, "accent", edit.path ?? "?") + (edit.line ? paint(theme, "dim", ":" + edit.line) : "");
+        lines.push(clamp(head, width));
+        for (const line of (edit.removed ?? []).slice(0, model.expanded ? 24 : 8)) {
+            lines.push("   " + paint(theme, "error", "- " + clamp(line, width - 4)));
+        }
+        for (const line of (edit.added ?? []).slice(0, model.expanded ? 24 : 8)) {
+            lines.push("   " + paint(theme, "success", "+ " + clamp(line, width - 4)));
+        }
+        if (edit.truncated)
+            lines.push(paint(theme, "dim", "   \u2026"));
+    }
+    if (model.error) {
+        for (const line of model.error.split("\n").slice(0, model.expanded ? 12 : 4)) {
+            lines.push(" " + paint(theme, "error", clamp(line, width - 1)));
+        }
+    }
+    else if (model.resultLines && model.resultLines.length > 0) {
+        const shown = model.expanded ? model.resultLines : model.resultLines.slice(0, 8);
+        for (const line of shown)
+            lines.push(" " + paint(theme, "muted", clamp(line, width - 1)));
+        if (!model.expanded && model.resultLines.length > shown.length) {
+            lines.push(paint(theme, "dim", "   \u2026 " + (model.resultLines.length - shown.length) + " more result lines"));
+        }
+    }
+    return lines;
+}
+function editsOf(value) {
+    if (value && typeof value === "object" && Array.isArray(value.edits)) {
+        return value.edits.filter((e) => !!e && typeof e === "object" && (Array.isArray(e.removed) || Array.isArray(e.added)));
+    }
+    return undefined;
+}
+function hitsOf(value) {
+    if (value && typeof value === "object" && Array.isArray(value.hits)) {
+        return value.hits;
+    }
+    return undefined;
+}
+function resultPreviewLines(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string")
+        return value.split("\n").filter((l) => l.length > 0).slice(0, 16);
+    if (Array.isArray(value))
+        return [value.length + " value" + (value.length === 1 ? "" : "s")];
+    if (typeof value === "object") {
+        return Object.entries(value).slice(0, 12).map(([k, v]) => {
+            const text = typeof v === "string" ? v : JSON.stringify(v);
+            return k + ": " + (text.length > 80 ? text.slice(0, 79) + "\u2026" : text);
+        });
+    }
+    return [String(value)];
+}
+/** Build the card model from the tool result's details payload. */
+export function cardModel(result, options) {
+    const details = (result.details && typeof result.details === "object" ? result.details : {});
+    const command = typeof details.command === "string" ? details.command : "asgrep";
+    const expanded = options.expanded === true;
+    // In-flight partial updates carry only {command, phase}.
+    if (options.isPartial && !("ok" in details)) {
+        return { command, title: [typeof details.phase === "string" ? details.phase : undefined], running: true, expanded };
+    }
+    const title = [];
+    if (typeof details.query === "string" && details.query)
+        title.push(JSON.stringify(details.query));
+    if (typeof details.mode === "string")
+        title.push(details.mode);
+    const error = details.error;
+    if (result.isError || details.ok === false || error) {
+        return {
+            command,
+            title,
+            error: typeof error?.message === "string" ? error.message : "tool failed",
+            expanded,
+        };
+    }
+    const response = details.response;
+    if (command === "status" || command === "index" || command === "reindex") {
+        const state = typeof response?.status === "string" ? response.status
+            : typeof response?.index_status === "string" ? response.index_status
+                : response?.ok === true ? "ok" : undefined;
+        if (state)
+            title.push(state);
+        const counts = response?.counts;
+        if (counts && typeof counts === "object") {
+            title.push(Object.entries(counts).slice(0, 4).map(([k, v]) => k + "=" + String(v)).join(" "));
+        }
+        else if (response) {
+            // Flat status envelope: file_count/symbol_count/caller_count + embed info.
+            const flat = [];
+            for (const k of ["file_count", "symbol_count", "caller_count"]) {
+                const v = response[k];
+                if (typeof v === "number" || typeof v === "bigint")
+                    flat.push(k.replace(/_count$/, "s") + "=" + String(v));
+            }
+            if (typeof response.embed_backend === "string")
+                flat.push(response.embed_backend);
+            if (flat.length > 0)
+                title.push(flat.join(" "));
+        }
+    }
+    const ms = typeof details.wallMs === "number" ? details.wallMs : typeof details.activationMs === "number" ? details.activationMs : undefined;
+    if (ms !== undefined)
+        title.push(fmtMs(ms));
+    if (typeof details.backend === "string")
+        title.push(details.backend);
+    const trace = Array.isArray(details.trace) ? details.trace : undefined;
+    const ops = trace?.map((t) => ({ tool: t.tool, target: t.target ?? "", ok: t.ok !== false, ms: typeof t.ms === "number" ? t.ms : 0 }));
+    const hits = hitsOf(response) ?? hitsOf(details.result);
+    const resultEdits = editsOf(details.result) ?? editsOf(response);
+    // read envelopes carry windows: preview each window's first lines.
+    const windows = command === "read" && response && Array.isArray(response.windows)
+        ? response.windows
+        : undefined;
+    const readLines = windows?.flatMap((w) => [
+        (w.path ?? "?") + ":" + (w.start ?? 1) + "-" + (w.end ?? ""),
+        ...(typeof w.text === "string" ? w.text.split("\n").slice(0, expanded ? 20 : 6).map((l) => "  " + l) : []),
+    ]);
+    // When edits carry diffs they are the interesting part of the result.
+    const resultLines = hits || resultEdits ? undefined : (readLines ?? resultPreviewLines(details.result));
+    const model = { command, title, expanded };
+    if (ops && ops.length > 0)
+        model.ops = ops;
+    if (hits)
+        model.hits = hits;
+    if (resultEdits)
+        model.edits = resultEdits;
+    if (resultLines)
+        model.resultLines = resultLines;
+    return model;
+}
+/** renderResult entrypoint: bind one card per result slot, feed it details. */
+export function renderAsgrepResult(result, options, theme, context) {
+    const prev = context?.lastComponent;
+    const card = prev instanceof AsgrepCard ? prev : new AsgrepCard();
+    card.set(theme, cardModel(result, options));
+    if (context)
+        context.lastComponent = card;
+    return card;
+}

package/dist/{present.d.ts → ui/present.d.ts}

@@ -25,8 +25,12 @@ export type EnvelopeLike = {
     backend?: unknown;
     [key: string]: unknown;
 };
-export declare const ASGREP_PROMPT_SNIPPET = "Search this repo by intent, symbol, callers, defs, pattern, or chain (in-process asgrep; use without being asked)";
-export declare const ASGREP_PROMPT_GUIDELINES: readonly ["For any code lookup (find a function, callers, defs, intent, structural pattern, or imports), call asgrep or asgrep_search immediately. Do not wait for the user to mention ast-sgrep.", "Prefer the asgrep Code Mode tool when you need more than one lookup, filtering, or parallel work. Write JavaScript that calls asgrep.search / semantic / chain / defs / callers / imports / indexStatus / indexRepo and return a small shaped value.", "Use grep only for exact log strings, filenames, or config keys. Use Pi write/edit to change files; asgrep does not mutate source."];
+export declare const ASGREP_PROMPT_SNIPPET = "Search this repo by intent, symbol, callers, defs, or pattern (asgrep; use without being asked)";
+export declare const ASGREP_PROMPT_GUIDELINES: readonly ["For any code lookup (find a function, callers, defs, intent, or structural pattern), call asgrep immediately. Do not wait for the user to mention ast-sgrep.", "Prefer the asgrep Code Mode tool. Write JavaScript: asgrep.search(\"query\"), asgrep.defs(\"Symbol\"), asgrep.callers(\"Symbol\"), asgrep.read({ refs }). Independent lookups: Promise.all. Return a small shaped value.", "Use grep only for exact log strings, filenames, or config keys. asgrep.edit does unique string replace plus targeted reindex; oldText must match exactly once.", "If a search returns 0 hits, use suggested_next or retry with asgrep.find, asgrep.defs, or asgrep.search(query, { in: \"src\" })."];
+export declare function paint(theme: PresentTheme | undefined, role: string, text: string, bold?: boolean): string;
+export declare function hitLocation(hit: HitLike): string;
+export declare function hitLabel(hit: HitLike): string;
+export declare function header(theme: PresentTheme | undefined, verb: string, bits: Array<string | null | undefined>): string;
 export declare function formatSearchCall(params: {
     query?: string;
     mode?: string;
@@ -35,6 +39,20 @@ export declare function formatSearchCall(params: {
 }, theme?: PresentTheme): string;
 export declare function formatIndexCall(force: boolean, theme?: PresentTheme): string;
 export declare function formatStatusCall(theme?: PresentTheme): string;
+export declare function formatEditCall(params: {
+    path?: string;
+    edits?: unknown[];
+}, theme?: PresentTheme): string;
+export declare function formatReadCall(params: {
+    path?: string;
+    ref?: string;
+    start?: number;
+    end?: number;
+}, theme?: PresentTheme): string;
+/** Model-visible text for an edit envelope: what changed, per file. */
+export declare function formatEditResult(response: EnvelopeLike, theme?: PresentTheme): string;
+/** Model-visible text for a read envelope: the window contents themselves. */
+export declare function formatReadResult(response: EnvelopeLike, theme?: PresentTheme): string;
 export declare function formatCodemodeCall(code: string, theme?: PresentTheme): string;
 export declare function formatSearchResult(response: EnvelopeLike, meta: {
     command: string;

package/dist/{present.js → ui/present.js}

@@ -1,15 +1,16 @@
 /** Neat asgrep tool chrome for the Pi TUI and the model-visible content. */
-export const ASGREP_PROMPT_SNIPPET = "Search this repo by intent, symbol, callers, defs, pattern, or chain (in-process asgrep; use without being asked)";
+export const ASGREP_PROMPT_SNIPPET = "Search this repo by intent, symbol, callers, defs, or pattern (asgrep; use without being asked)";
 export const ASGREP_PROMPT_GUIDELINES = [
-    "For any code lookup (find a function, callers, defs, intent, structural pattern, or imports), call asgrep or asgrep_search immediately. Do not wait for the user to mention ast-sgrep.",
-    "Prefer the asgrep Code Mode tool when you need more than one lookup, filtering, or parallel work. Write JavaScript that calls asgrep.search / semantic / chain / defs / callers / imports / indexStatus / indexRepo and return a small shaped value.",
-    "Use grep only for exact log strings, filenames, or config keys. Use Pi write/edit to change files; asgrep does not mutate source.",
+    "For any code lookup (find a function, callers, defs, intent, or structural pattern), call asgrep immediately. Do not wait for the user to mention ast-sgrep.",
+    "Prefer the asgrep Code Mode tool. Write JavaScript: asgrep.search(\"query\"), asgrep.defs(\"Symbol\"), asgrep.callers(\"Symbol\"), asgrep.read({ refs }). Independent lookups: Promise.all. Return a small shaped value.",
+    "Use grep only for exact log strings, filenames, or config keys. asgrep.edit does unique string replace plus targeted reindex; oldText must match exactly once.",
+    "If a search returns 0 hits, use suggested_next or retry with asgrep.find, asgrep.defs, or asgrep.search(query, { in: \"src\" }).",
 ];
-function paint(theme, role, text, bold = false) {
+export function paint(theme, role, text, bold = false) {
     const body = bold && theme ? theme.bold(text) : text;
     return theme ? theme.fg(role, body) : body;
 }
-function hitLocation(hit) {
+export function hitLocation(hit) {
     const file = String(hit.file ?? hit.path ?? "");
     const line = hit.start_line ?? hit.line ?? hit.lines;
     if (typeof line === "number")
@@ -20,13 +21,13 @@ function hitLocation(hit) {
         return hit.ref;
     return file || "?";
 }
-function hitLabel(hit) {
+export function hitLabel(hit) {
     const symbol = typeof hit.symbol === "string" ? hit.symbol : "";
     const kind = typeof hit.kind === "string" ? hit.kind : "";
     const preview = typeof hit.preview === "string" ? hit.preview.replace(/\s+/g, " ").trim() : "";
     return [symbol, kind, preview && preview.length < 80 ? preview : ""].filter(Boolean).join("  ");
 }
-function header(theme, verb, bits) {
+export function header(theme, verb, bits) {
     return [paint(theme, "toolTitle", "asgrep", true), paint(theme, "accent", verb), ...bits.filter((bit) => Boolean(bit))].join("  ·  ");
 }
 export function formatSearchCall(params, theme) {
@@ -43,6 +44,44 @@ export function formatIndexCall(force, theme) {
 export function formatStatusCall(theme) {
     return header(theme, "status", []);
 }
+export function formatEditCall(params, theme) {
+    const n = Array.isArray(params.edits) ? params.edits.length : 0;
+    return header(theme, "edit", [params.path, n > 1 ? n + " edits" : undefined]);
+}
+export function formatReadCall(params, theme) {
+    const target = params.path ?? params.ref;
+    const range = params.start !== undefined ? "L" + params.start + "-L" + (params.end ?? "") : undefined;
+    return header(theme, "read", [target, range]);
+}
+/** Model-visible text for an edit envelope: what changed, per file. */
+export function formatEditResult(response, theme) {
+    const edits = Array.isArray(response.edits) ? response.edits : [];
+    const changed = edits.filter((e) => e.changed === true).length;
+    const title = header(theme, "edit", [changed + "/" + edits.length + " changed"]);
+    const rows = edits.slice(0, 12).map((e) => {
+        const path = typeof e.path === "string" ? e.path : "?";
+        const line = typeof e.line === "number" ? ":" + e.line : "";
+        return paint(theme, "toolOutput", "  " + path + line);
+    });
+    return [title, ...rows].join("\n");
+}
+/** Model-visible text for a read envelope: the window contents themselves. */
+export function formatReadResult(response, theme) {
+    const windows = Array.isArray(response.windows) ? response.windows : [];
+    if (windows.length === 0)
+        return header(theme, "read", ["0 windows"]);
+    const out = [];
+    for (const w of windows.slice(0, 8)) {
+        const path = typeof w.path === "string" ? w.path : "?";
+        out.push(header(theme, "read", [path + "#L" + (w.start ?? 1) + "-L" + (w.end ?? "")]));
+        const text = typeof w.text === "string" ? w.text : "";
+        for (const line of text.split("\n").slice(0, 80))
+            out.push(line);
+    }
+    if (windows.length > 8)
+        out.push("… " + (windows.length - 8) + " more windows");
+    return out.join("\n");
+}
 export function formatCodemodeCall(code, theme) {
     const preview = code.trim().replace(/\s+/g, " ").slice(0, 80);
     return header(theme, "codemode", [`${preview}${code.trim().length > 80 ? "…" : ""}`]);
@@ -61,6 +100,20 @@ export function formatSearchResult(response, meta, theme) {
         const label = hitLabel(hit);
         return paint(theme, "toolOutput", label ? `  ${loc}  ${label}` : `  ${loc}`);
     });
+    if (hits.length === 0) {
+        rows.push(paint(theme, "muted", "  0 hits"));
+        const next = Array.isArray(response.suggested_next)
+            ? response.suggested_next.filter((item) => typeof item === "string")
+            : [];
+        if (next.length > 0) {
+            for (const query of next.slice(0, 4)) {
+                rows.push(paint(theme, "toolOutput", `  try  ${query}`));
+            }
+        }
+        else {
+            rows.push(paint(theme, "toolOutput", "  try  asgrep.find(query) or asgrep.defs(symbol) or asgrep.search(query, { in: \"src\" })"));
+        }
+    }
     if (hits.length > 24) {
         rows.push(paint(theme, "muted", `  … ${hits.length - 24} more`));
     }
@@ -173,7 +226,10 @@ export function truncateToWidth(text, maxWidth, ellipsis = "...") {
         width += cell.width;
         index += cell.length;
     }
-    return `${kept}${ellipsis}`;
+    // The cut can land inside a painted span — its closing SGR is past the
+    // budget, so the ellipsis and everything after would inherit the open color.
+    // Close it explicitly; harmless when the kept spans were already balanced.
+    return kept + (kept.includes("\u001b[") ? "\u001b[0m" : "") + ellipsis;
 }
 function compactValue(value) {
     if (value === null || value === undefined)
@@ -221,6 +277,9 @@ export function formatCodemodeResult(value, meta = {}, theme) {
     if (meta.wallMs !== undefined)
         bits.push(`${meta.wallMs}ms`);
     const title = header(theme, "codemode", bits);
+    if (value === undefined) {
+        return `${title}\n${paint(theme, "muted", "  (no return statement; add `return` to send a value to the model)")}`;
+    }
     if (value && typeof value === "object" && !Array.isArray(value)) {
         const rows = Object.entries(value).slice(0, 16).map(([key, entry]) => paint(theme, "toolOutput", `  ${key}: ${compactValue(entry)}`));
         return [title, ...rows].join("\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ast-sgrep",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "description": "Native Code Mode, structural, graph, and semantic code search for Pi",
   "type": "module",
   "license": "MIT",
@@ -36,8 +36,8 @@
       "import": "./dist/index.js"
     },
     "./runtime": {
-      "types": "./dist/runtime.d.ts",
-      "import": "./dist/runtime.js"
+      "types": "./dist/runtime/runtime.d.ts",
+      "import": "./dist/runtime/runtime.js"
     },
     "./code-mode": {
       "types": "./dist/code-mode.d.ts",
@@ -51,9 +51,9 @@
     "image": "./assets/preview.png"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node scripts/copy-guest-worker.mjs",
     "build:native": "cargo build -p ast-sgrep-codemode-napi --release && node ./scripts/copy-native.mjs",
-    "test": "ASGREP_CODEMODE_BACKEND=cli node --import tsx --test ../../../tests/pi/extension/code-mode.test.ts ../../../tests/pi/extension/codemode.test.ts ../../../tests/pi/extension/commands.test.ts ../../../tests/pi/extension/present.test.ts ../../../tests/pi/extension/runtime.test.ts ../../../tests/pi/extension/security.test.ts ../../../tests/pi/extension/session-pool.test.ts ../../../tests/pi/extension/skill-workflow.test.ts ../../../tests/pi/extension/tools.test.ts",
+    "test": "ASGREP_CODEMODE_BACKEND=cli node --import tsx --test ../../../tests/pi/extension/code-mode.test.ts ../../../tests/pi/extension/codemode.test.ts ../../../tests/pi/extension/commands.test.ts ../../../tests/pi/extension/present.test.ts ../../../tests/pi/extension/runtime.test.ts ../../../tests/pi/extension/security.test.ts ../../../tests/pi/extension/session-pool.test.ts ../../../tests/pi/extension/skill-workflow.test.ts ../../../tests/pi/extension/sqlite.test.ts ../../../tests/pi/extension/tools.test.ts",
     "test:native": "node --import tsx --test ../../../tests/pi/extension/native-inprocess.test.ts",
     "test:all": "npm test && npm run test:native",
     "prepack": "npm run build"
@@ -62,7 +62,7 @@
     "node": ">=22.19.0"
   },
   "dependencies": {
-    "ast-sgrep": "2.0.0",
+    "ast-sgrep": ">=2.0.0 <3",
     "typebox": "^1.0.0"
   },
   "peerDependencies": {

package/dist/codemode/sandbox-worker.d.ts

@@ -1 +0,0 @@
-export {};