pi-ast-sgrep 1.3.2 → 2.0.0

package/dist/index.js

@@ -1,5 +1,7 @@
 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";
+import { ASGREP_PROMPT_GUIDELINES, ASGREP_PROMPT_SNIPPET, formatCodemodeCall, formatCodemodeResult, formatIndexCall, formatIndexResult, formatSearchCall, formatSearchResult, formatStatusCall, formatStatusResult, presentText, } from "./present.js";
 const DEFAULT_LIMIT = 8;
 const MAX_LIMIT = 100;
 const MAX_EXCERPT_LINES = 100;
@@ -25,26 +27,40 @@ 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)}…`;
 }
-function success(command, response) {
-    const count = Array.isArray(response.hits) ? response.hits.length :
-        typeof response.count === "number" ? response.count :
-            typeof response.total === "number" ? response.total : undefined;
-    const summary = count === undefined ? `${command} completed` : `${command} completed: ${count} result${count === 1 ? "" : "s"}`;
+function success(command, response, extra = {}) {
+    const text = command === "status"
+        ? formatStatusResult(response)
+        : command === "index" || command === "reindex"
+            ? formatIndexResult(command, response)
+            : formatSearchResult(response, { command, ...extra });
     return {
-        content: [{ type: "text", text: bounded(summary) }],
-        details: { ok: true, command, response },
+        content: [{ type: "text", text: bounded(text) }],
+        // 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 }, ...extra },
     };
 }
-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,43 +101,399 @@ 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();
+    let poolConfigured = false;
+    // Prefer a registration-local pool so tests / multi-agent hosts do not share
+    // sticky state. sharedNativePool remains for advanced single-session reuse.
+    const ensurePool = () => {
+        if (poolConfigured)
+            return;
+        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 (runtime.config?.maxOutputBytes !== undefined)
+                opts.maxOutputBytes = runtime.config.maxOutputBytes;
+            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({});
+        }
+        poolConfigured = true;
+    };
+    const resolveRoot = async (cwd) => runtime.resolveRoot ? await runtime.resolveRoot({ cwd }) : cwd;
+    const probeCli = (options = {}) => {
+        // Test fixtures inject `run` without a resolver; production always has resolveBinaryPath.
+        if (typeof runtime.resolveBinaryPath !== "function")
+            return { kind: "cli" };
+        try {
+            const base = runtime.nativeEnv?.() ?? {};
+            if (options.env) {
+                runtime.resolveBinaryPath({ env: { ...base, ...options.env } });
+            }
+            else {
+                runtime.resolveBinaryPath({ env: base });
+            }
+            return { kind: "cli" };
+        }
+        catch (cause) {
+            return {
+                kind: "unavailable",
+                cause: cause instanceof Error ? cause.message : String(cause),
+            };
+        }
+    };
+    const requireBackend = (availability, context) => {
+        if (availability.kind !== "unavailable")
+            return;
+        throw new RuntimeError("BACKEND_UNAVAILABLE", "ast-sgrep backend unavailable (no NAPI session and no CLI binary)", {
+            backend: "unavailable",
+            // Agent-facing mirrors of the closed unavailable variant (not an open product).
+            napi: false,
+            cli: false,
+            cwd: context.cwd,
+            hint: "Install @ast-sgrep/<platform> or run npm run build:native in packages/pi/extension",
+            ...(availability.cause ? { cause: availability.cause } : {}),
+        });
+    };
+    const runCli = async (args, context, options = {}) => {
+        requireBackend(probeCli(options), context);
+        return runtime.run(args, context, options);
+    };
+    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 } : {}));
+        }
+        // Cold CLI only when a real binary resolves -- never remap missing natives to BINARY_RESOLUTION_FAILED.
+        return runCli(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.watchExternalChanges !== undefined) {
+        warmRuntime.watchExternalChanges = runtime.watchExternalChanges;
+    }
+    if (runtime.resolveIndexPath) {
+        warmRuntime.resolveIndexPath = (root) => runtime.resolveIndexPath(root);
+    }
+    if (runtime.inspectIndexCompatibility) {
+        warmRuntime.inspectIndexCompatibility = (context) => runtime.inspectIndexCompatibility(context);
+    }
+    if (runtime.rebuildIncompatibleIndex) {
+        warmRuntime.rebuildIncompatibleIndex = async (context, options) => {
+            const root = await resolveRoot(context.cwd);
+            await pool.invalidate(root);
+            return runtime.rebuildIncompatibleIndex(context, options);
+        };
+    }
     pi.on("tool_result", (event, ctx) => {
-        if (event.isError || (event.toolName !== "write" && event.toolName !== "edit"))
+        if (event.isError)
+            return;
+        if (event.toolName !== "write" && event.toolName !== "edit")
             return;
         const path = event.input.path;
         if (typeof path === "string")
             freshness.markAffectedPath(path, ctx.cwd);
     });
+    pi.on("session_start", (_event, ctx) => {
+        // Warm the in-process Searcher at session start so the first asgrep
+        // search does not pay NAPI/SQLite open on the user's first lookup.
+        void (async () => {
+            try {
+                ensurePool();
+                const root = await resolveRoot(ctx.cwd);
+                await pool.acquire(root);
+            }
+            catch {
+                // Doctor reports backend errors; a failed warmup must not block the session.
+            }
+        })();
+    });
+    pi.on("session_shutdown", () => {
+        freshness.shutdown?.();
+        void pool.shutdown();
+    });
+    // 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",
+        label: "asgrep",
+        promptSnippet: ASGREP_PROMPT_SNIPPET,
+        promptGuidelines: [...ASGREP_PROMPT_GUIDELINES],
+        description: [
+            "Primary code-search tool for this project. Call it whenever you need to find, trace, or understand code — do not wait for the user to mention asgrep.",
+            "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) with a 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,
+        renderCall(args, theme, context) {
+            return presentText(formatCodemodeCall(args.code, theme), context.lastComponent);
+        },
+        renderResult(result, options, theme, context) {
+            const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+            const lines = text.split("\n");
+            const max = options.expanded ? lines.length : 16;
+            const shown = lines.slice(0, max).join("\n");
+            const rest = lines.length > max ? `\n… ${lines.length - max} more` : "";
+            return presentText(shown + rest, context.lastComponent);
+        },
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            report(onUpdate, "codemode", "started");
+            try {
+                const timeoutMs = runtime.config?.timeoutMs ?? 30_000;
+                const deadline = Date.now() + timeoutMs;
+                const timeoutSignal = AbortSignal.timeout(timeoutMs);
+                const operationSignal = signal
+                    ? AbortSignal.any([signal, timeoutSignal])
+                    : timeoutSignal;
+                const options = { signal: operationSignal };
+                ensurePool();
+                const root = await freshness.ensureFresh(warmRuntime, { cwd: ctx.cwd }, options);
+                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;
+                        if (runtime.config?.maxOutputBytes !== undefined)
+                            stdinOpts.maxOutputBytes = runtime.config.maxOutputBytes;
+                        return runBatchViaStdin(stdinOpts);
+                    });
+                }
+                const bundle = createAsgrepConnector(batchHost, { cwd: ctx.cwd }, options);
+                bundle.resetStats();
+                const codemodeOptions = { stats: bundle.stats };
+                codemodeOptions.timeoutMs = Math.max(1, deadline - Date.now());
+                codemodeOptions.signal = operationSignal;
+                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}`) }],
+                        details: {
+                            ok: false,
+                            command: "codemode",
+                            error: { code: "CODEMODE_ERROR", message: outcome.error, details: { logs: outcome.logs, stats: outcome.stats } },
+                            code: outcome.code,
+                            stats: outcome.stats,
+                            wallMs: outcome.wallMs,
+                            backend: pool.backend(),
+                        },
+                    };
+                }
+                const rendered = formatCodemodeResult(outcome.result, {
+                    ...(outcome.stats ? { stats: outcome.stats } : {}),
+                    wallMs: outcome.wallMs,
+                    backend: pool.backend(),
+                });
+                const activationMs = outcome.wallMs;
+                return {
+                    content: [{ type: "text", text: bounded(rendered) }],
+                    details: {
+                        ok: true,
+                        command: "codemode",
+                        result: outcome.result,
+                        logs: outcome.logs,
+                        rendered,
+                        stats: outcome.stats,
+                        wallMs: outcome.wallMs,
+                        activationMs,
+                        backend: pool.backend(),
+                    },
+                };
+            }
+            catch (cause) {
+                return failure("codemode", cause);
+            }
+        },
+    });
+    // Escape hatches: one-shot tools for simple lookups. Prefer asgrep.
+    // 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.",
+        label: "asgrep search",
+        promptSnippet: "One-shot asgrep search (natural, defs, callers, pattern, chain, semantic)",
+        description: "One-shot search. Prefer asgrep for anything multi-step, parallel, or filtered. Call this on your own whenever a single lookup is enough.",
         parameters: searchParameters,
+        renderCall(args, theme, context) {
+            return presentText(formatSearchCall(args, theme), context.lastComponent);
+        },
+        renderResult(result, _options, _theme, context) {
+            const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+            return presentText(text, context.lastComponent);
+        },
         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));
+            const started = performance.now();
+            report(onUpdate, "search", "started");
+            try {
+                ensurePool();
+                const root = await freshness.ensureFresh(warmRuntime, { cwd: ctx.cwd }, options);
+                const sticky = await pool.acquire(root);
+                const response = sticky
+                    ? await sticky.call(...searchToolCall(params), options)
+                    : await runCli(searchArgs(params), { cwd: ctx.cwd }, options);
+                report(onUpdate, "search", "completed");
+                return success("search", response, {
+                    query: params.query,
+                    mode: params.mode ?? "natural",
+                    activationMs: performance.now() - started,
+                    backend: pool.backend(),
+                });
+            }
+            catch (cause) {
+                return failure("search", cause);
+            }
         },
     });
     pi.registerTool({
         name: "asgrep_index",
-        label: "ast-sgrep index",
-        description: "Build or rebuild the ast-sgrep project index.",
+        label: "asgrep index",
+        promptSnippet: "Build or rebuild the asgrep index",
+        description: "Build or rebuild the index. Prefer asgrep.indexRepo inside asgrep.",
         parameters: indexParameters,
+        renderCall(args, theme, context) {
+            return presentText(formatIndexCall(args.force === true, theme), context.lastComponent);
+        },
+        renderResult(result, _options, _theme, context) {
+            const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+            return presentText(text, context.lastComponent);
+        },
         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 runCli([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.",
+        label: "asgrep status",
+        promptSnippet: "asgrep index and backend status",
+        description: "Index/runtime status. Prefer asgrep.indexStatus inside asgrep.",
         parameters: statusParameters,
+        renderCall(_args, theme, context) {
+            return presentText(formatStatusCall(theme), context.lastComponent);
+        },
+        renderResult(result, _options, _theme, context) {
+            const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+            return presentText(text, context.lastComponent);
+        },
         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 runCli(["status", ".", "--json"], { cwd: ctx.cwd }, signal ? { signal } : {});
+                report(onUpdate, "status", "completed");
+                return success("status", response);
+            }
+            catch (cause) {
+                return failure("status", cause);
+            }
         },
     });
 }
+const SEARCH_CALL_SPEC = {
+    semantic: { tool: "semantic" },
+    chain: { tool: "chain" },
+    defs: { tool: "defs", key: "symbol" },
+    callers: { tool: "callers", key: "symbol" },
+    imports: { tool: "imports", key: "module" },
+    pattern: { tool: "search", prefix: "pattern" },
+    word: { tool: "search", prefix: "word" },
+    literal: { tool: "search", prefix: "literal" },
+    regex: { tool: "search", prefix: "regex" },
+    natural: { tool: "search" },
+};
+function searchToolCall(params) {
+    const mode = params.mode ?? "natural";
+    const limit = params.limit ?? DEFAULT_LIMIT;
+    const excerpt_lines = params.excerptLines ?? 0;
+    const spec = SEARCH_CALL_SPEC[mode];
+    if (spec.tool === "semantic") {
+        return ["semantic", { query: params.query, limit, excerpt_lines, format: "capsule" }];
+    }
+    if (spec.tool === "chain") {
+        return ["chain", { query: params.query, limit, top_n: 20 }];
+    }
+    if (spec.tool === "search") {
+        const query = spec.prefix ? `${spec.prefix}: ${params.query}` : params.query;
+        return ["search", { query, limit, excerpt_lines, format: "capsule" }];
+    }
+    // defs / callers / imports
+    return [spec.tool, { [spec.key]: params.query, limit, excerpt_lines }];
+}
 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"],

package/dist/present.d.ts

@@ -0,0 +1,67 @@
+/** Neat asgrep tool chrome for the Pi TUI and the model-visible content. */
+export type PresentTheme = {
+    bold(text: string): string;
+    fg(role: string, text: string): string;
+};
+export type HitLike = {
+    file?: unknown;
+    path?: unknown;
+    ref?: unknown;
+    symbol?: unknown;
+    kind?: unknown;
+    preview?: unknown;
+    start_line?: unknown;
+    line?: unknown;
+    lines?: unknown;
+};
+export type EnvelopeLike = {
+    ok?: unknown;
+    hits?: unknown;
+    count?: unknown;
+    total?: unknown;
+    status?: unknown;
+    index_status?: unknown;
+    counts?: unknown;
+    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 function formatSearchCall(params: {
+    query?: string;
+    mode?: string;
+    limit?: number;
+    excerptLines?: number;
+}, theme?: PresentTheme): string;
+export declare function formatIndexCall(force: boolean, theme?: PresentTheme): string;
+export declare function formatStatusCall(theme?: PresentTheme): string;
+export declare function formatCodemodeCall(code: string, theme?: PresentTheme): string;
+export declare function formatSearchResult(response: EnvelopeLike, meta: {
+    command: string;
+    query?: string;
+    mode?: string;
+    activationMs?: number;
+    backend?: string;
+}, theme?: PresentTheme): string;
+export declare function formatStatusResult(response: EnvelopeLike, theme?: PresentTheme): string;
+export declare function formatIndexResult(command: string, response: EnvelopeLike, theme?: PresentTheme): string;
+export declare function formatCodemodeResult(value: unknown, meta?: {
+    stats?: {
+        calls: number;
+        batchedCalls: number;
+        parallelSpawnCalls: number;
+        stickyCalls?: number;
+        waves: number;
+    };
+    wallMs?: number;
+    backend?: string;
+}, theme?: PresentTheme): string;
+/** Minimal pi-tui Text stand-in so we do not take a TUI package dependency. */
+export declare class AsgrepText {
+    #private;
+    constructor(text?: string);
+    setText(text: string): void;
+    invalidate(): void;
+    render(_width: number): string[];
+}
+export declare function presentText(formatted: string, last: unknown): AsgrepText;