pi-ast-sgrep 1.4.0 → 2.0.0

package/dist/index.js

@@ -1,11 +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";
+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;
 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([
@@ -37,17 +37,18 @@ const codemodeParameters = Type.Object({
 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) }],
+        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 } },
+        details: { ok: true, command, response: { ...response, command }, ...extra },
     };
 }
 function errorDetails(cause, signal) {
@@ -101,9 +102,12 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
     ? 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;
@@ -118,6 +122,8 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
                 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";
             }
@@ -128,8 +134,47 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
         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);
@@ -137,8 +182,8 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
         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);
+        // 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 = {
@@ -146,28 +191,60 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
         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 = (context, options) => runtime.rebuildIncompatibleIndex(context, options);
+        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);
     });
-    // Primary surface: Code Mode — in-process NAPI (MCP-class), compose in JS.
+    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_codemode",
-        label: "ast-sgrep Code Mode",
+        name: "asgrep",
+        label: "asgrep",
+        promptSnippet: ASGREP_PROMPT_SNIPPET,
+        promptGuidelines: [...ASGREP_PROMPT_GUIDELINES],
         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.",
+            "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,
             "",
@@ -184,13 +261,29 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
             "}",
         ].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 options = signal ? { signal } : {};
-                await freshness.ensureFresh(warmRuntime, { cwd: ctx.cwd }, options);
+                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 resolveRoot(ctx.cwd);
+                const root = await freshness.ensureFresh(warmRuntime, { cwd: ctx.cwd }, options);
                 const env = runtime.nativeEnv?.() ?? { NO_COLOR: "1" };
                 let binary = null;
                 try {
@@ -217,25 +310,25 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
                             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 };
-                if (runtime.config?.timeoutMs !== undefined)
-                    codemodeOptions.timeoutMs = runtime.config.timeoutMs;
-                if (signal)
-                    codemodeOptions.signal = signal;
+                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 ?? "unknown error"}`) }],
+                        content: [{ type: "text", text: bounded(`codemode failed: ${outcome.error}`) }],
                         details: {
                             ok: false,
                             command: "codemode",
-                            error: { code: "CODEMODE_ERROR", message: outcome.error ?? "unknown error", details: { logs: outcome.logs, stats: outcome.stats } },
+                            error: { code: "CODEMODE_ERROR", message: outcome.error, details: { logs: outcome.logs, stats: outcome.stats } },
                             code: outcome.code,
                             stats: outcome.stats,
                             wallMs: outcome.wallMs,
@@ -243,9 +336,14 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
                         },
                     };
                 }
-                const rendered = safeRender(outcome.result);
+                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(summarizeCodemode(outcome.result, outcome.stats, outcome.wallMs, pool.backend())) }],
+                    content: [{ type: "text", text: bounded(rendered) }],
                     details: {
                         ok: true,
                         command: "codemode",
@@ -254,6 +352,7 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
                         rendered,
                         stats: outcome.stats,
                         wallMs: outcome.wallMs,
+                        activationMs,
                         backend: pool.backend(),
                     },
                 };
@@ -263,26 +362,39 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
             }
         },
     });
-    // Escape hatches: one-shot tools for simple lookups. Prefer asgrep_codemode.
+    // 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: "One-shot search. Prefer asgrep_codemode for anything multi-step, parallel, or filtered.",
+        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 } : {};
+            const started = performance.now();
             report(onUpdate, "search", "started");
             try {
-                await freshness.ensureFresh(warmRuntime, { cwd: ctx.cwd }, options);
                 ensurePool();
-                const root = await resolveRoot(ctx.cwd);
+                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 runtime.run(searchArgs(params), { cwd: ctx.cwd }, options);
+                    : await runCli(searchArgs(params), { cwd: ctx.cwd }, options);
                 report(onUpdate, "search", "completed");
-                return success("search", response);
+                return success("search", response, {
+                    query: params.query,
+                    mode: params.mode ?? "natural",
+                    activationMs: performance.now() - started,
+                    backend: pool.backend(),
+                });
             }
             catch (cause) {
                 return failure("search", cause);
@@ -291,9 +403,17 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
     });
     pi.registerTool({
         name: "asgrep_index",
-        label: "ast-sgrep index",
-        description: "Build or rebuild the index. Prefer asgrep.indexRepo inside asgrep_codemode.",
+        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 force = params.force === true;
             const command = force ? "reindex" : "index";
@@ -304,7 +424,7 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
                 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 } : {});
+                    : await runCli([command, ".", "--json"], { cwd: ctx.cwd }, signal ? { signal } : {});
                 report(onUpdate, command, "completed");
                 return success(command, response);
             }
@@ -315,9 +435,17 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
     });
     pi.registerTool({
         name: "asgrep_status",
-        label: "ast-sgrep status",
-        description: "Index/runtime status. Prefer asgrep.indexStatus inside asgrep_codemode.",
+        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) {
             report(onUpdate, "status", "started");
             try {
@@ -326,7 +454,7 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
                 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 } : {});
+                    : await runCli(["status", ".", "--json"], { cwd: ctx.cwd }, signal ? { signal } : {});
                 report(onUpdate, "status", "completed");
                 return success("status", response);
             }
@@ -336,77 +464,35 @@ export function registerAstSgrepTools(pi, runtime = new AstSgrepRuntime(pi), fre
         },
     });
 }
-/** Map one-shot search params to typed sticky tool+args. */
+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;
-    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" }];
-        }
+    const spec = SEARCH_CALL_SPEC[mode];
+    if (spec.tool === "semantic") {
+        return ["semantic", { 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 (spec.tool === "chain") {
+        return ["chain", { query: params.query, limit, top_n: 20 }];
     }
-    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 (spec.tool === "search") {
+        const query = spec.prefix ? `${spec.prefix}: ${params.query}` : params.query;
+        return ["search", { query, limit, excerpt_lines, format: "capsule" }];
     }
-    if (wallMs !== undefined)
-        parts.push(`${wallMs}ms`);
-    return parts.join(" · ");
+    // 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"],

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;