pi-ast-sgrep 1.3.2 → 1.4.0

package/dist/codemode/worker.js

@@ -0,0 +1,250 @@
+/**
+ * Sticky NDJSON Code Mode worker (`asgrep codemode-serve`).
+ *
+ * One process, one warm Searcher, for the entire Code Mode program — the biggest
+ * Amdahl win over per-wave `codemode-batch` spawns.
+ */
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { asEnvelope } from "./dispatch.js";
+export async function startStickyWorker(options) {
+    if (options.signal?.aborted) {
+        throw new Error("codemode-serve aborted before start");
+    }
+    const child = spawn(options.binary, ["--root", options.cwd, "codemode-serve"], {
+        cwd: options.cwd,
+        env: { ...process.env, ...options.env, NO_COLOR: "1" },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    const pending = new Map();
+    let nextId = 0;
+    let closed = false;
+    let stderr = "";
+    const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+    const failAll = (err) => {
+        for (const p of pending.values())
+            p.reject(err);
+        pending.clear();
+    };
+    const terminate = (err) => {
+        if (closed)
+            return;
+        closed = true;
+        killChild(child);
+        failAll(err);
+        rl.close();
+    };
+    rl.on("line", (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch (cause) {
+            failAll(new Error(`codemode-serve bad JSON: ${trimmed.slice(0, 200)}`));
+            void cause;
+            return;
+        }
+        const type = msg.type;
+        if (type === "bye")
+            return;
+        const id = typeof msg.id === "string" ? msg.id : undefined;
+        if (!id)
+            return;
+        const waiter = pending.get(id);
+        if (!waiter)
+            return;
+        pending.delete(id);
+        waiter.resolve(msg);
+    });
+    child.stderr.on("data", (chunk) => {
+        stderr += String(chunk);
+        if (stderr.length > 8_192)
+            stderr = stderr.slice(-8_192);
+    });
+    child.on("error", (err) => {
+        closed = true;
+        failAll(err);
+    });
+    child.on("close", (code, signal) => {
+        closed = true;
+        if (pending.size > 0) {
+            failAll(new Error(`codemode-serve exited code=${code ?? "null"} signal=${signal ?? "null"} stderr=${stderr.slice(0, 512)}`));
+        }
+    });
+    const onAbort = () => terminate(new Error("codemode-serve aborted"));
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    const write = (payload) => {
+        if (closed || !child.stdin.writable) {
+            return Promise.reject(new Error("codemode-serve is closed"));
+        }
+        const id = typeof payload.id === "string" ? payload.id : String(nextId++);
+        payload.id = id;
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+            child.stdin.write(`${JSON.stringify(payload)}\n`, (err) => {
+                if (err) {
+                    pending.delete(id);
+                    reject(err);
+                }
+            });
+        });
+    };
+    const writeWithControls = (payload, label, signal) => {
+        if (signal?.aborted)
+            return Promise.reject(new Error(`${label} aborted`));
+        const response = write(payload);
+        return new Promise((resolve, reject) => {
+            let timer;
+            let settled = false;
+            const finish = (action) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                signal?.removeEventListener("abort", onRequestAbort);
+                action();
+            };
+            const fail = (err) => finish(() => {
+                terminate(err);
+                reject(err);
+            });
+            const onRequestAbort = () => fail(new Error(`${label} aborted`));
+            signal?.addEventListener("abort", onRequestAbort, { once: true });
+            if (options.timeoutMs && options.timeoutMs > 0) {
+                timer = setTimeout(() => fail(new Error(`${label} timed out after ${options.timeoutMs}ms`)), options.timeoutMs);
+            }
+            response.then((value) => finish(() => resolve(value)), (cause) => finish(() => reject(cause)));
+        });
+    };
+    // Probe: empty End would close — instead send a tiny catalog call to verify protocol,
+    // or just return and let first real call fail. Prefer lazy: no probe.
+    return {
+        async call(tool, args, callOptions) {
+            const msg = await writeWithControls({ type: "call", tool, args }, "codemode call", callOptions?.signal);
+            if (msg.type === "error") {
+                throw new Error(typeof msg.error === "string" ? msg.error : "codemode-serve error");
+            }
+            if (msg.ok === false) {
+                throw new Error(typeof msg.error === "string" ? msg.error : `codemode ${tool} failed`);
+            }
+            return asEnvelope(msg.value, tool);
+        },
+        async batch(calls, callOptions) {
+            const msg = await writeWithControls({ type: "batch", calls }, "codemode batch", callOptions?.signal);
+            if (msg.type === "error") {
+                throw new Error(typeof msg.error === "string" ? msg.error : "codemode-serve batch error");
+            }
+            const results = Array.isArray(msg.results)
+                ? msg.results
+                : [];
+            const out = { results };
+            if (typeof msg.mode === "string")
+                out.mode = msg.mode;
+            if (typeof msg.wall_ms === "number")
+                out.wall_ms = msg.wall_ms;
+            if (typeof msg.all_ok === "boolean")
+                out.all_ok = msg.all_ok;
+            return out;
+        },
+        async end() {
+            options.signal?.removeEventListener("abort", onAbort);
+            if (closed)
+                return;
+            try {
+                if (child.stdin.writable) {
+                    child.stdin.write(`${JSON.stringify({ type: "end" })}\n`);
+                    child.stdin.end();
+                }
+            }
+            catch {
+                // ignore
+            }
+            killChild(child);
+            closed = true;
+            rl.close();
+        },
+    };
+}
+/** One-shot batch via stdin (avoids tempfile). */
+export async function runBatchViaStdin(options) {
+    if (options.signal?.aborted)
+        throw new Error("codemode-batch aborted");
+    return new Promise((resolve, reject) => {
+        const child = spawn(options.binary, ["codemode-batch", "--requests", "-", "--json"], {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env, NO_COLOR: "1" },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timer = options.timeoutMs && options.timeoutMs > 0
+            ? setTimeout(() => {
+                killChild(child);
+                reject(new Error(`codemode-batch timed out after ${options.timeoutMs}ms`));
+            }, options.timeoutMs)
+            : undefined;
+        const onAbort = () => {
+            killChild(child);
+            reject(new Error("codemode-batch aborted"));
+        };
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        child.stdout.on("data", (c) => {
+            stdout += String(c);
+        });
+        child.stderr.on("data", (c) => {
+            stderr += String(c);
+        });
+        child.on("error", (err) => {
+            if (timer)
+                clearTimeout(timer);
+            options.signal?.removeEventListener("abort", onAbort);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            if (timer)
+                clearTimeout(timer);
+            options.signal?.removeEventListener("abort", onAbort);
+            if (code !== 0) {
+                reject(new Error(`codemode-batch exited ${code}: ${stderr.slice(0, 512) || stdout.slice(0, 512)}`));
+                return;
+            }
+            try {
+                resolve(JSON.parse(stdout));
+            }
+            catch (cause) {
+                reject(cause);
+            }
+        });
+        child.stdin.write(options.body, (err) => {
+            if (err) {
+                killChild(child);
+                reject(err);
+                return;
+            }
+            child.stdin.end();
+        });
+    });
+}
+function killChild(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    try {
+        child.kill("SIGTERM");
+    }
+    catch {
+        return;
+    }
+    setTimeout(() => {
+        try {
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill("SIGKILL");
+        }
+        catch {
+            // ignore
+        }
+    }, 2_000).unref?.();
+}

package/dist/index.d.ts

@@ -1,6 +1,29 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { FreshnessCoordinator, type FreshnessRuntime } from "./runtime.js";
-type RuntimeLike = FreshnessRuntime;
+import { FreshnessCoordinator, type MachineEnvelope, type RunOptions } from "./runtime.js";
+type RuntimeLike = {
+    run(args: readonly string[], context: {
+        cwd: string;
+    }, options?: RunOptions): Promise<MachineEnvelope>;
+    resolveRoot?(context: {
+        cwd: string;
+    }): Promise<string>;
+    resolveBinaryPath?(options?: {
+        env?: NodeJS.ProcessEnv;
+    }): string;
+    nativeEnv?(options?: {
+        env?: NodeJS.ProcessEnv;
+    }): NodeJS.ProcessEnv;
+    config?: {
+        timeoutMs?: number;
+        refreshIntervalMs?: number;
+    };
+    inspectIndexCompatibility?(context: {
+        cwd: string;
+    }): Promise<"ready" | "missing" | "incompatible">;
+    rebuildIncompatibleIndex?(context: {
+        cwd: string;
+    }, options?: RunOptions): Promise<MachineEnvelope>;
+};
 type FreshnessLike = Pick<FreshnessCoordinator, "ensureFresh" | "markAffectedPath">;
 export declare function registerAstSgrepTools(pi: ExtensionAPI, runtime?: RuntimeLike, freshness?: FreshnessLike): void;
 export declare function registerAstSgrepCommands(pi: ExtensionAPI, runtime?: RuntimeLike): void;

package/dist/index.js

@@ -1,9 +1,11 @@
 import { Type } from "typebox";
+import { createAsgrepConnector, runCodemode, runNativeBatch, runBatchViaStdin, CODEMODE_TYPES_FOR_MODEL, NativeSessionPool, argvFor, asEnvelope, } from "./codemode/index.js";
 import { AstSgrepRuntime, FreshnessCoordinator, RuntimeError } from "./runtime.js";
 const DEFAULT_LIMIT = 8;
 const MAX_LIMIT = 100;
 const MAX_EXCERPT_LINES = 100;
 const MAX_CONTENT_CHARS = 1_200;
+const MAX_CODEMODE_RESULT_CHARS = 8_000;
 const searchParameters = Type.Object({
     query: Type.String({ minLength: 1, maxLength: 4_096, description: "Natural-language query, symbol, or structural pattern" }),
     mode: Type.Optional(Type.Union([
@@ -25,6 +27,13 @@ const indexParameters = Type.Object({
     force: Type.Optional(Type.Boolean({ default: false, description: "Rebuild the index from scratch" })),
 }, { additionalProperties: false });
 const statusParameters = Type.Object({}, { additionalProperties: false });
+const codemodeParameters = Type.Object({
+    code: Type.String({
+        minLength: 1,
+        maxLength: 32_000,
+        description: "JavaScript async body that calls asgrep.* methods. Prefer Promise.all for independent lookups. Return only the shaped final value.",
+    }),
+}, { additionalProperties: false });
 function bounded(text) {
     return text.length <= MAX_CONTENT_CHARS ? text : `${text.slice(0, MAX_CONTENT_CHARS - 1)}…`;
 }
@@ -35,16 +44,22 @@ function success(command, response) {
     const summary = count === undefined ? `${command} completed` : `${command} completed: ${count} result${count === 1 ? "" : "s"}`;
     return {
         content: [{ type: "text", text: bounded(summary) }],
-        details: { ok: true, command, response },
+        // The tool execute owns its machine command: normalize the envelope's
+        // command (native catalog names like index_status/index_repo must surface
+        // as the machine commands status/index/reindex).
+        details: { ok: true, command, response: { ...response, command } },
     };
 }
-function errorDetails(cause) {
+function errorDetails(cause, signal) {
+    if (signal?.aborted) {
+        return { code: "CANCELLED", message: "cancelled", details: {} };
+    }
     return cause instanceof RuntimeError
         ? { code: cause.code, message: cause.message, details: cause.details }
         : { code: "UNEXPECTED_ERROR", message: cause instanceof Error ? cause.message : String(cause), details: {} };
 }
-function failure(command, cause) {
-    const error = errorDetails(cause);
+function failure(command, cause, signal) {
+    const error = errorDetails(cause, signal);
     return {
         content: [{ type: "text", text: bounded(`${command} failed [${error.code}]: ${error.message}`) }],
         details: { ok: false, command, error },
@@ -85,6 +100,58 @@ async function execute(runtime, command, args, signal, onUpdate, ctx, before) {
 export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), freshness = runtime instanceof AstSgrepRuntime
     ? new FreshnessCoordinator({ refreshIntervalMs: runtime.config.refreshIntervalMs })
     : new FreshnessCoordinator()) {
+    const pool = new NativeSessionPool();
+    // Prefer a registration-local pool so tests / multi-agent hosts do not share
+    // sticky state. sharedNativePool remains for advanced single-session reuse.
+    const ensurePool = () => {
+        try {
+            const env = runtime.nativeEnv?.() ?? { NO_COLOR: "1" };
+            let binary;
+            try {
+                binary = runtime.resolveBinaryPath?.({ env });
+            }
+            catch {
+                binary = undefined;
+            }
+            const opts = { env };
+            if (binary)
+                opts.binary = binary;
+            if (runtime.config?.timeoutMs !== undefined)
+                opts.timeoutMs = runtime.config.timeoutMs;
+            if (typeof env.ASGREP_NO_EMBED === "string") {
+                opts.useEmbed = env.ASGREP_NO_EMBED !== "1" && env.ASGREP_NO_EMBED !== "true";
+            }
+            if (typeof env.ASGREP_INDEX_PATH === "string")
+                opts.indexPath = env.ASGREP_INDEX_PATH;
+            pool.configure(opts);
+        }
+        catch {
+            pool.configure({});
+        }
+    };
+    const resolveRoot = async (cwd) => runtime.resolveRoot ? await runtime.resolveRoot({ cwd }) : cwd;
+    const nativeCall = async (tool, args, context, options = {}) => {
+        ensurePool();
+        const root = await resolveRoot(context.cwd);
+        const worker = await pool.acquire(root);
+        if (worker) {
+            return asEnvelope(await worker.call(tool, args, options.signal ? { signal: options.signal } : {}));
+        }
+        // Last resort: cold CLI argv (tests without NAPI / missing addon).
+        return runtime.run(argvFor(tool, args), context, options);
+    };
+    // Freshness + tools share the same warm in-process Searcher as Code Mode.
+    const warmRuntime = {
+        run: (args, context, options) => runtime.run(args, context, options),
+        resolveRoot: (context) => resolveRoot(context.cwd),
+        nativeCall,
+    };
+    if (runtime.inspectIndexCompatibility) {
+        warmRuntime.inspectIndexCompatibility = (context) => runtime.inspectIndexCompatibility(context);
+    }
+    if (runtime.rebuildIncompatibleIndex) {
+        warmRuntime.rebuildIncompatibleIndex = (context, options) => runtime.rebuildIncompatibleIndex(context, options);
+    }
     pi.on("tool_result", (event, ctx) => {
         if (event.isError || (event.toolName !== "write" && event.toolName !== "edit"))
             return;
@@ -92,36 +159,255 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
         if (typeof path === "string")
             freshness.markAffectedPath(path, ctx.cwd);
     });
+    // Primary surface: Code Mode — in-process NAPI (MCP-class), compose in JS.
+    // Sibling to MCP: pick one surface; both link core, never each other.
+    pi.registerTool({
+        name: "asgrep_codemode",
+        label: "ast-sgrep Code Mode",
+        description: [
+            "Primary ast-sgrep tool. Write JavaScript that calls typed asgrep.* methods.",
+            "Compose with await / Promise.all, filter in code, return only the shaped final value.",
+            "Runs in-process (native addon) — no CLI spawn; warm Searcher for the Pi session.",
+            "",
+            CODEMODE_TYPES_FOR_MODEL,
+            "",
+            "Example:",
+            "async () => {",
+            "  const [seed, status] = await Promise.all([",
+            "    asgrep.search({ query: 'auth refresh', limit: 5 }),",
+            "    asgrep.indexStatus(),",
+            "  ]);",
+            "  const symbol = seed.hits?.[0]?.symbol;",
+            "  if (!symbol) return { seed, status };",
+            "  const graph = await asgrep.chain({ query: symbol, limit: 20 });",
+            "  return { symbol, nodes: graph.nodes?.slice?.(0, 10) ?? graph, status };",
+            "}",
+        ].join("\n"),
+        parameters: codemodeParameters,
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            report(onUpdate, "codemode", "started");
+            try {
+                const options = signal ? { signal } : {};
+                await freshness.ensureFresh(warmRuntime, { cwd: ctx.cwd }, options);
+                ensurePool();
+                const root = await resolveRoot(ctx.cwd);
+                const env = runtime.nativeEnv?.() ?? { NO_COLOR: "1" };
+                let binary = null;
+                try {
+                    binary = runtime.resolveBinaryPath?.({ env }) ?? null;
+                }
+                catch {
+                    binary = null;
+                }
+                // In-process NAPI first; CLI sticky only if addon missing.
+                const sticky = await pool.acquire(root);
+                const batchHost = {
+                    run: (args, context, runOptions) => runtime.run(args, context, runOptions ?? {}),
+                    sticky,
+                };
+                if (binary) {
+                    batchHost.runBatch = (calls, context, runOptions) => runNativeBatch((a, c, o) => runtime.run(a, c, o ?? {}), calls, context, runOptions, (body, c, o) => {
+                        const stdinOpts = {
+                            binary: binary,
+                            cwd: c.cwd,
+                            body,
+                            env,
+                        };
+                        if (o?.signal)
+                            stdinOpts.signal = o.signal;
+                        if (runtime.config?.timeoutMs !== undefined)
+                            stdinOpts.timeoutMs = runtime.config.timeoutMs;
+                        return runBatchViaStdin(stdinOpts);
+                    });
+                }
+                const bundle = createAsgrepConnector(batchHost, { cwd: ctx.cwd }, options);
+                bundle.resetStats();
+                const codemodeOptions = { stats: bundle.stats };
+                if (runtime.config?.timeoutMs !== undefined)
+                    codemodeOptions.timeoutMs = runtime.config.timeoutMs;
+                if (signal)
+                    codemodeOptions.signal = signal;
+                const outcome = await runCodemode(params.code, bundle.asgrep, codemodeOptions);
+                report(onUpdate, "codemode", "completed");
+                if (!outcome.ok) {
+                    return {
+                        content: [{ type: "text", text: bounded(`codemode failed: ${outcome.error ?? "unknown error"}`) }],
+                        details: {
+                            ok: false,
+                            command: "codemode",
+                            error: { code: "CODEMODE_ERROR", message: outcome.error ?? "unknown error", details: { logs: outcome.logs, stats: outcome.stats } },
+                            code: outcome.code,
+                            stats: outcome.stats,
+                            wallMs: outcome.wallMs,
+                            backend: pool.backend(),
+                        },
+                    };
+                }
+                const rendered = safeRender(outcome.result);
+                return {
+                    content: [{ type: "text", text: bounded(summarizeCodemode(outcome.result, outcome.stats, outcome.wallMs, pool.backend())) }],
+                    details: {
+                        ok: true,
+                        command: "codemode",
+                        result: outcome.result,
+                        logs: outcome.logs,
+                        rendered,
+                        stats: outcome.stats,
+                        wallMs: outcome.wallMs,
+                        backend: pool.backend(),
+                    },
+                };
+            }
+            catch (cause) {
+                return failure("codemode", cause);
+            }
+        },
+    });
+    // Escape hatches: one-shot tools for simple lookups. Prefer asgrep_codemode.
+    // They ride the same session sticky pool when available (no cold spawn).
     pi.registerTool({
         name: "asgrep_search",
         label: "ast-sgrep search",
-        description: "Search project code with natural language, structural patterns, symbol relationships, chains, or semantic retrieval.",
+        description: "One-shot search. Prefer asgrep_codemode for anything multi-step, parallel, or filtered.",
         parameters: searchParameters,
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
             const options = signal ? { signal } : {};
-            return execute(runtime, "search", searchArgs(params), signal, onUpdate, ctx, () => freshness.ensureFresh(runtime, { cwd: ctx.cwd }, options).then(() => undefined));
+            report(onUpdate, "search", "started");
+            try {
+                await freshness.ensureFresh(warmRuntime, { cwd: ctx.cwd }, options);
+                ensurePool();
+                const root = await resolveRoot(ctx.cwd);
+                const sticky = await pool.acquire(root);
+                const response = sticky
+                    ? await sticky.call(...searchToolCall(params), options)
+                    : await runtime.run(searchArgs(params), { cwd: ctx.cwd }, options);
+                report(onUpdate, "search", "completed");
+                return success("search", response);
+            }
+            catch (cause) {
+                return failure("search", cause);
+            }
         },
     });
     pi.registerTool({
         name: "asgrep_index",
         label: "ast-sgrep index",
-        description: "Build or rebuild the ast-sgrep project index.",
+        description: "Build or rebuild the index. Prefer asgrep.indexRepo inside asgrep_codemode.",
         parameters: indexParameters,
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
-            const command = params.force === true ? "reindex" : "index";
-            return execute(runtime, command, [command, ".", "--json"], signal, onUpdate, ctx);
+            const force = params.force === true;
+            const command = force ? "reindex" : "index";
+            report(onUpdate, command, "started");
+            try {
+                ensurePool();
+                const root = await resolveRoot(ctx.cwd);
+                const sticky = await pool.acquire(root);
+                const response = sticky
+                    ? await sticky.call("index_repo", { force }, signal ? { signal } : {})
+                    : await runtime.run([command, ".", "--json"], { cwd: ctx.cwd }, signal ? { signal } : {});
+                report(onUpdate, command, "completed");
+                return success(command, response);
+            }
+            catch (cause) {
+                return failure(command, cause, signal);
+            }
         },
     });
     pi.registerTool({
         name: "asgrep_status",
         label: "ast-sgrep status",
-        description: "Return runtime version, protocol, root, index, counts, backend, IVF, and capability status.",
+        description: "Index/runtime status. Prefer asgrep.indexStatus inside asgrep_codemode.",
         parameters: statusParameters,
         async execute(_toolCallId, _params, signal, onUpdate, ctx) {
-            return execute(runtime, "status", ["status", ".", "--json"], signal, onUpdate, ctx);
+            report(onUpdate, "status", "started");
+            try {
+                ensurePool();
+                const root = await resolveRoot(ctx.cwd);
+                const sticky = await pool.acquire(root);
+                const response = sticky
+                    ? await sticky.call("index_status", {}, signal ? { signal } : {})
+                    : await runtime.run(["status", ".", "--json"], { cwd: ctx.cwd }, signal ? { signal } : {});
+                report(onUpdate, "status", "completed");
+                return success("status", response);
+            }
+            catch (cause) {
+                return failure("status", cause);
+            }
         },
     });
 }
+/** Map one-shot search params to typed sticky tool+args. */
+function searchToolCall(params) {
+    const mode = params.mode ?? "natural";
+    const limit = params.limit ?? DEFAULT_LIMIT;
+    const excerpt_lines = params.excerptLines ?? 0;
+    switch (mode) {
+        case "semantic":
+            return ["semantic", { query: params.query, limit, excerpt_lines, format: "capsule" }];
+        case "chain":
+            return ["chain", { query: params.query, limit, top_n: 20 }];
+        case "defs":
+            return ["defs", { symbol: params.query, limit, excerpt_lines }];
+        case "callers":
+            return ["callers", { symbol: params.query, limit, excerpt_lines }];
+        case "imports":
+            return ["imports", { module: params.query, limit, excerpt_lines }];
+        case "pattern":
+        case "word":
+        case "literal":
+        case "regex":
+            return ["search", { query: `${mode}: ${params.query}`, limit, excerpt_lines, format: "capsule" }];
+        case "natural":
+            return ["search", { query: params.query, limit, excerpt_lines, format: "capsule" }];
+        default: {
+            const _exhaustive = mode;
+            void _exhaustive;
+            return ["search", { query: params.query, limit, excerpt_lines, format: "capsule" }];
+        }
+    }
+}
+function safeRender(value) {
+    try {
+        const text = JSON.stringify(value);
+        if (text === undefined)
+            return String(value);
+        return text.length <= MAX_CODEMODE_RESULT_CHARS ? text : `${text.slice(0, MAX_CODEMODE_RESULT_CHARS - 1)}…`;
+    }
+    catch {
+        return String(value);
+    }
+}
+function summarizeCodemode(value, stats, wallMs, backend) {
+    const parts = ["codemode completed"];
+    if (value && typeof value === "object") {
+        const record = value;
+        if (Array.isArray(record.hits))
+            parts[0] = `codemode completed: ${record.hits.length} hit${record.hits.length === 1 ? "" : "s"}`;
+        else if (typeof record.hit_count === "number")
+            parts[0] = `codemode completed: ${record.hit_count} hit${record.hit_count === 1 ? "" : "s"}`;
+        else if (typeof record.node_count === "number")
+            parts[0] = `codemode completed: ${record.node_count} node${record.node_count === 1 ? "" : "s"}`;
+    }
+    if (backend === "napi")
+        parts.push("in-process");
+    else if (backend === "cli")
+        parts.push("cli-sticky");
+    if (stats && stats.calls > 0) {
+        const via = (stats.stickyCalls ?? 0) > 0
+            ? `native ${stats.stickyCalls}`
+            : stats.batchedCalls > 0
+                ? `batched ${stats.batchedCalls}`
+                : stats.parallelSpawnCalls > 0
+                    ? `parallel-spawn ${stats.parallelSpawnCalls}`
+                    : `${stats.calls} call${stats.calls === 1 ? "" : "s"}`;
+        parts.push(via);
+        if (stats.waves > 1)
+            parts.push(`${stats.waves} waves`);
+    }
+    if (wallMs !== undefined)
+        parts.push(`${wallMs}ms`);
+    return parts.join(" · ");
+}
 const COMMANDS = [
     ["asgrep-doctor", "Check the ast-sgrep runtime, native binary, index, and project configuration", "doctor"],
     ["asgrep-status", "Show ast-sgrep runtime, index, backend, and capability status", "status"],