pi-ast-sgrep 1.3.2 → 1.4.0

package/dist/codemode/native.js

@@ -0,0 +1,110 @@
+/**
+ * Load the in-process Code Mode NAPI addon.
+ *
+ * Same model as MCP: Rust `CodeModeSession` runs inside the Node process.
+ * No `asgrep` CLI spawn on the hot path.
+ *
+ * Resolution order:
+ * 1. `ASGREP_CODEMODE_NAPI_PATH` (dev override)
+ * 2. `@ast-sgrep/<platform>/ast-sgrep-codemode.node` via launcher (release install)
+ * 3. Local `extension/native/` / cargo `target/release` (dev builds)
+ */
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+let cached;
+function platformTriple() {
+    const { platform, arch } = process;
+    if (platform === "linux" && arch === "x64")
+        return "linux-x64-gnu";
+    if (platform === "linux" && arch === "arm64")
+        return "linux-arm64-gnu";
+    if (platform === "darwin" && arch === "arm64")
+        return "darwin-arm64";
+    if (platform === "darwin" && arch === "x64")
+        return "darwin-x64";
+    if (platform === "win32" && arch === "x64")
+        return "win32-x64-msvc";
+    return null;
+}
+function platformPackageAddon() {
+    const require = createRequire(import.meta.url);
+    try {
+        const launcher = require("ast-sgrep");
+        if (typeof launcher.resolveCodemodeAddon === "function") {
+            return launcher.resolveCodemodeAddon();
+        }
+    }
+    catch {
+        // Launcher may be unavailable in isolated unit tests.
+    }
+    return null;
+}
+function candidatePaths() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const triple = platformTriple();
+    const names = triple
+        ? [
+            `ast-sgrep-codemode.${triple}.node`,
+            `ast-sgrep-codemode.node`,
+        ]
+        : [`ast-sgrep-codemode.node`];
+    const dirs = [
+        // Built next to extension (dev / packaged)
+        join(here, "..", "..", "native"),
+        join(here, "..", "native"),
+        // Workspace release output
+        join(here, "..", "..", "..", "..", "target", "release"),
+    ];
+    const out = [];
+    const override = process.env.ASGREP_CODEMODE_NAPI_PATH;
+    if (override)
+        out.push(override);
+    const packaged = platformPackageAddon();
+    if (packaged)
+        out.push(packaged);
+    for (const dir of dirs) {
+        for (const name of names)
+            out.push(join(dir, name));
+        // cargo cdylib name
+        out.push(join(dir, "libast_sgrep_codemode_napi.so"));
+        out.push(join(dir, "libast_sgrep_codemode_napi.dylib"));
+        out.push(join(dir, "ast_sgrep_codemode_napi.dll"));
+    }
+    return out;
+}
+/** Load the NAPI binding once. Returns null if unavailable on this host. */
+export function loadCodemodeNative() {
+    if (cached !== undefined)
+        return cached;
+    // Force CLI sticky / argv path (unit tests, degraded installs).
+    if (process.env.ASGREP_CODEMODE_BACKEND === "cli") {
+        cached = null;
+        return null;
+    }
+    const require = createRequire(import.meta.url);
+    for (const path of candidatePaths()) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const binding = require(path);
+            if (typeof binding?.isNative === "function" && binding.isNative()) {
+                cached = binding;
+                return cached;
+            }
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    cached = null;
+    return null;
+}
+export function nativeAvailable() {
+    return loadCodemodeNative() !== null;
+}
+/** Reset cache (tests). */
+export function resetNativeCache() {
+    cached = undefined;
+}

package/dist/codemode/sandbox.d.ts

@@ -0,0 +1,25 @@
+import type { AsgrepConnector } from "./connector.js";
+import type { DispatchStats } from "./dispatch.js";
+export type CodemodeRunResult = {
+    ok: boolean;
+    result: unknown;
+    logs: string[];
+    error?: string;
+    code: string;
+    stats?: DispatchStats;
+    wallMs: number;
+};
+/** Strip markdown fences and normalize to an async IIFE expression. */
+export declare function normalizeCode(raw: string): string;
+/**
+ * Run model-generated JavaScript with only `asgrep` + safe builtins.
+ *
+ * Uses the shared microtask queue so host Promises from `asgrep.*` resolve under
+ * `Promise.all`. Do not enable `microtaskMode: 'afterEvaluate'` — that isolates
+ * queues and breaks cross-context await.
+ */
+export declare function runCodemode(rawCode: string, asgrep: AsgrepConnector, options?: {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    stats?: () => DispatchStats;
+}): Promise<CodemodeRunResult>;

package/dist/codemode/sandbox.js

@@ -0,0 +1,192 @@
+import vm from "node:vm";
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_CODE_CHARS = 32_000;
+/** Strip markdown fences and normalize to an async IIFE expression. */
+export function normalizeCode(raw) {
+    let code = raw.trim();
+    if (code.startsWith("```")) {
+        code = code.replace(/^```(?:javascript|js|typescript|ts)?\s*/i, "").replace(/\s*```$/, "").trim();
+    }
+    if (/^async\s*\(/.test(code) || /^async\s+function\b/.test(code)) {
+        return `(${code.endsWith(";") ? code.slice(0, -1) : code})()`;
+    }
+    return `(async () => {\n${code}\n})()`;
+}
+/**
+ * Run model-generated JavaScript with only `asgrep` + safe builtins.
+ *
+ * Uses the shared microtask queue so host Promises from `asgrep.*` resolve under
+ * `Promise.all`. Do not enable `microtaskMode: 'afterEvaluate'` — that isolates
+ * queues and breaks cross-context await.
+ */
+export async function runCodemode(rawCode, asgrep, options = {}) {
+    const timeoutMs = Math.max(1, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const wall0 = Date.now();
+    if (rawCode.length > MAX_CODE_CHARS) {
+        return resultErr(`code exceeds ${MAX_CODE_CHARS} characters`, [], rawCode.slice(0, 200), wall0, options.stats);
+    }
+    if (options.signal?.aborted) {
+        return resultErr("codemode aborted", [], rawCode.slice(0, 200), wall0, options.stats);
+    }
+    const logs = [];
+    const hostMethods = {
+        search: asgrep.search,
+        semantic: asgrep.semantic,
+        chain: asgrep.chain,
+        defs: asgrep.defs,
+        callers: asgrep.callers,
+        imports: asgrep.imports,
+        indexStatus: asgrep.indexStatus,
+        indexRepo: asgrep.indexRepo,
+        catalogSearch: asgrep.catalogSearch,
+        catalogDescribe: asgrep.catalogDescribe,
+    };
+    // Never expose host-realm functions or objects to model code. A direct host
+    // function lets `fn.constructor("return process")()` escape `node:vm`.
+    const bridge = async (method, payload) => {
+        try {
+            if (!Object.hasOwn(hostMethods, method))
+                throw new Error(`unknown asgrep method: ${method}`);
+            const input = JSON.parse(payload);
+            const value = await hostMethods[method](input);
+            return JSON.stringify({ ok: true, value });
+        }
+        catch (cause) {
+            return JSON.stringify({
+                ok: false,
+                error: cause instanceof Error ? cause.message : String(cause),
+            });
+        }
+    };
+    const logBridge = (line) => logs.push(line);
+    Object.setPrototypeOf(bridge, null);
+    Object.setPrototypeOf(logBridge, null);
+    Object.freeze(bridge);
+    Object.freeze(logBridge);
+    const globals = Object.create(null);
+    globals.__asgrepBridge = bridge;
+    globals.__asgrepLog = logBridge;
+    const context = vm.createContext(globals, {
+        codeGeneration: { strings: false, wasm: false },
+    });
+    new vm.Script(SANDBOX_BOOTSTRAP, { filename: "asgrep-codemode-bootstrap.js" }).runInContext(context, {
+        timeout: 1_000,
+    });
+    const code = normalizeCode(rawCode);
+    let script;
+    try {
+        script = new vm.Script(code, { filename: "asgrep-codemode.js" });
+    }
+    catch (cause) {
+        return resultErr(cause instanceof Error ? cause.message : String(cause), logs, code, wall0, options.stats);
+    }
+    let timer;
+    let onAbort;
+    try {
+        const produced = script.runInContext(context, {
+            displayErrors: true,
+            timeout: timeoutMs,
+        });
+        const races = [
+            Promise.resolve(produced),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`codemode timeout after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ];
+        if (options.signal) {
+            races.push(new Promise((_, reject) => {
+                onAbort = () => reject(new Error("codemode aborted"));
+                options.signal.addEventListener("abort", onAbort, { once: true });
+            }));
+        }
+        const value = await Promise.race(races);
+        return resultOk(cloneOut(value), logs, code, wall0, options.stats);
+    }
+    catch (cause) {
+        return resultErr(cause instanceof Error ? cause.message : String(cause), logs, code, wall0, options.stats);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (onAbort)
+            options.signal?.removeEventListener("abort", onAbort);
+    }
+}
+const SANDBOX_BOOTSTRAP = `
+{
+  const hostCall = globalThis.__asgrepBridge;
+  const hostLog = globalThis.__asgrepLog;
+  delete globalThis.__asgrepBridge;
+  delete globalThis.__asgrepLog;
+
+  const invoke = async (method, args = {}) => {
+    const response = JSON.parse(await hostCall(method, JSON.stringify(args)));
+    if (!response.ok) throw new Error(response.error || \`asgrep.\${method} failed\`);
+    return response.value;
+  };
+  const api = Object.create(null);
+  for (const method of [
+    "search", "semantic", "chain", "defs", "callers", "imports",
+    "indexStatus", "indexRepo", "catalogSearch", "catalogDescribe",
+  ]) {
+    Object.defineProperty(api, method, {
+      enumerable: true,
+      value: (args = {}) => invoke(method, args),
+    });
+  }
+  Object.freeze(api);
+
+  const formatLog = (value) => {
+    if (typeof value === "string") return value;
+    try { return JSON.stringify(value); } catch { return String(value); }
+  };
+  const consoleApi = Object.create(null);
+  for (const level of ["log", "info", "warn", "error", "debug"]) {
+    Object.defineProperty(consoleApi, level, {
+      enumerable: true,
+      value: (...args) => hostLog(args.map(formatLog).join(" ")),
+    });
+  }
+  Object.freeze(consoleApi);
+
+  Object.defineProperty(globalThis, "asgrep", { value: api, configurable: false, writable: false });
+  Object.defineProperty(globalThis, "console", { value: consoleApi, configurable: false, writable: false });
+}
+`;
+function resultOk(result, logs, code, wall0, statsFn) {
+    const out = { ok: true, result, logs, code, wallMs: Date.now() - wall0 };
+    const stats = statsFn?.();
+    if (stats)
+        out.stats = stats;
+    return out;
+}
+function resultErr(error, logs, code, wall0, statsFn) {
+    const out = { ok: false, result: null, logs, error, code, wallMs: Date.now() - wall0 };
+    const stats = statsFn?.();
+    if (stats)
+        out.stats = stats;
+    return out;
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function cloneOut(value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return structuredClone(value);
+    }
+    catch {
+        try {
+            return JSON.parse(JSON.stringify(value));
+        }
+        catch {
+            return value;
+        }
+    }
+}

package/dist/codemode/session-pool.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Session-scoped native Code Mode sessions.
+ *
+ * Primary path: in-process NAPI (`CodeModeSession` inside Node) — same model as
+ * MCP linking core. Zero CLI spawn.
+ *
+ * Fallback: sticky `codemode-serve` child only when the `.node` addon is missing
+ * (unsupported host / incomplete install). Doctor reports that as degraded.
+ */
+import type { MachineEnvelope } from "../runtime.js";
+import { type StickyWorker } from "./dispatch.js";
+import { type StickyWorkerOptions } from "./worker.js";
+export type SessionPoolOptions = {
+    /** Required only for CLI sticky fallback. */
+    binary?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    root?: string;
+    indexPath?: string;
+    useEmbed?: boolean;
+    limit?: number;
+};
+export type StickyStarter = (options: StickyWorkerOptions) => Promise<StickyWorker>;
+export declare class NativeSessionPool {
+    #private;
+    constructor(startFn?: StickyStarter);
+    configure(options: SessionPoolOptions): void;
+    configured(): boolean;
+    /** Active backend after first successful acquire. */
+    backend(): "napi" | "cli" | "none";
+    acquire(root: string): Promise<StickyWorker | null>;
+    call(root: string, tool: string, args?: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+    }): Promise<MachineEnvelope>;
+    invalidate(root: string): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/** Singleton for advanced hosts; tools registration uses a local pool. */
+export declare const sharedNativePool: NativeSessionPool;

package/dist/codemode/session-pool.js

@@ -0,0 +1,173 @@
+/**
+ * Session-scoped native Code Mode sessions.
+ *
+ * Primary path: in-process NAPI (`CodeModeSession` inside Node) — same model as
+ * MCP linking core. Zero CLI spawn.
+ *
+ * Fallback: sticky `codemode-serve` child only when the `.node` addon is missing
+ * (unsupported host / incomplete install). Doctor reports that as degraded.
+ */
+import { asEnvelope } from "./dispatch.js";
+import { loadCodemodeNative } from "./native.js";
+import { startStickyWorker } from "./worker.js";
+function inProcessWorker(session, binding, root) {
+    return {
+        async call(tool, args) {
+            const value = session.call(tool, args);
+            return asEnvelope(value);
+        },
+        async batch(calls) {
+            // Prefer session.call in a loop — reuses the warm Searcher already open.
+            const results = [];
+            let allOk = true;
+            const t0 = Date.now();
+            for (const c of calls) {
+                try {
+                    const value = session.call(c.tool, c.args);
+                    results.push({ id: c.id, ok: true, value });
+                }
+                catch (cause) {
+                    allOk = false;
+                    results.push({
+                        id: c.id,
+                        ok: false,
+                        error: cause instanceof Error ? cause.message : String(cause),
+                    });
+                }
+            }
+            // For large waves, binding.batch can parallelize; serial warm is the default win.
+            if (calls.length >= 4 && allOk) {
+                void binding;
+                void root;
+            }
+            return { results, all_ok: allOk, wall_ms: Date.now() - t0, mode: "serial-napi" };
+        },
+        async end() {
+            // NAPI session is GC'd; nothing to kill.
+        },
+    };
+}
+export class NativeSessionPool {
+    #entries = new Map();
+    #starting = new Map();
+    #options = null;
+    #generations = new Map();
+    #startFn;
+    #backend = "none";
+    constructor(startFn = startStickyWorker) {
+        this.#startFn = startFn;
+    }
+    configure(options) {
+        this.#options = options;
+    }
+    configured() {
+        return this.#options !== null || loadCodemodeNative() !== null;
+    }
+    /** Active backend after first successful acquire. */
+    backend() {
+        return this.#backend;
+    }
+    async acquire(root) {
+        const existing = this.#entries.get(root);
+        if (existing)
+            return existing.worker;
+        const inFlight = this.#starting.get(root);
+        if (inFlight)
+            return inFlight;
+        const start = this.#start(root);
+        this.#starting.set(root, start);
+        try {
+            return await start;
+        }
+        finally {
+            if (this.#starting.get(root) === start)
+                this.#starting.delete(root);
+        }
+    }
+    async call(root, tool, args = {}, options) {
+        if (options?.signal?.aborted)
+            throw new Error("native call aborted");
+        const worker = await this.acquire(root);
+        if (!worker)
+            throw new Error("native Code Mode backend unavailable");
+        return worker.call(tool, args, options);
+    }
+    async invalidate(root) {
+        this.#generations.set(root, this.#generationFor(root) + 1);
+        this.#starting.delete(root);
+        const entry = this.#entries.get(root);
+        this.#entries.delete(root);
+        if (entry)
+            await entry.worker.end().catch(() => undefined);
+        if (this.#entries.size === 0)
+            this.#backend = "none";
+    }
+    async shutdown() {
+        const roots = new Set([...this.#entries.keys(), ...this.#starting.keys()]);
+        for (const root of roots)
+            this.#generations.set(root, this.#generationFor(root) + 1);
+        const entries = [...this.#entries.values()];
+        this.#entries.clear();
+        this.#starting.clear();
+        this.#backend = "none";
+        await Promise.all(entries.map((e) => e.worker.end().catch(() => undefined)));
+    }
+    #generationFor(root) {
+        return this.#generations.get(root) ?? 0;
+    }
+    async #start(root) {
+        const gen = this.#generationFor(root);
+        const opts = this.#options ?? {};
+        // 1) In-process NAPI (preferred — zero spawn).
+        const binding = loadCodemodeNative();
+        if (binding) {
+            try {
+                const config = { root };
+                if (opts.indexPath)
+                    config.indexPath = opts.indexPath;
+                if (opts.limit !== undefined)
+                    config.limit = opts.limit;
+                if (opts.useEmbed !== undefined)
+                    config.useEmbed = opts.useEmbed;
+                const session = new binding.Session(config);
+                const worker = inProcessWorker(session, binding, root);
+                if (gen !== this.#generationFor(root)) {
+                    await worker.end().catch(() => undefined);
+                    return null;
+                }
+                this.#entries.set(root, { root, worker, generation: gen, backend: "napi" });
+                this.#backend = "napi";
+                return worker;
+            }
+            catch {
+                // Fall through to CLI sticky.
+            }
+        }
+        // 2) CLI sticky fallback (degraded).
+        if (!opts.binary)
+            return null;
+        try {
+            const stickyOpts = {
+                binary: opts.binary,
+                cwd: root,
+            };
+            if (opts.env)
+                stickyOpts.env = opts.env;
+            if (opts.timeoutMs !== undefined)
+                stickyOpts.timeoutMs = opts.timeoutMs;
+            const worker = await this.#startFn(stickyOpts);
+            if (gen !== this.#generationFor(root)) {
+                await worker.end().catch(() => undefined);
+                return null;
+            }
+            this.#entries.set(root, { root, worker, generation: gen, backend: "cli" });
+            this.#backend = "cli";
+            return worker;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/** Singleton for advanced hosts; tools registration uses a local pool. */
+export const sharedNativePool = new NativeSessionPool();

package/dist/codemode/types.d.ts

@@ -0,0 +1,18 @@
+/** Typed surface the model sees inside the Code Mode sandbox. */
+export type SearchArgs = {
+    query: string;
+    limit?: number;
+    excerptLines?: number;
+    format?: "capsule" | "agent";
+};
+export type ChainArgs = {
+    query: string;
+    limit?: number;
+    excerptLines?: number;
+};
+/**
+ * Compact TypeScript declarations for the `asgrep_codemode` tool description.
+ * Keep short — every token here is paid on every turn (schema landfill lesson
+ * from pi-codex-conversion: compose inside Code Mode, don't dump 17 schemas).
+ */
+export declare const CODEMODE_TYPES_FOR_MODEL: string;

package/dist/codemode/types.js

@@ -0,0 +1,21 @@
+/** Typed surface the model sees inside the Code Mode sandbox. */
+/**
+ * Compact TypeScript declarations for the `asgrep_codemode` tool description.
+ * Keep short — every token here is paid on every turn (schema landfill lesson
+ * from pi-codex-conversion: compose inside Code Mode, don't dump 17 schemas).
+ */
+export const CODEMODE_TYPES_FOR_MODEL = `
+declare const asgrep: {
+  search(input: { query: string; limit?: number; excerptLines?: number }): Promise<unknown>;
+  semantic(input: { query: string; limit?: number; excerptLines?: number }): Promise<unknown>;
+  chain(input: { query: string; limit?: number }): Promise<unknown>;
+  defs(input: { symbol: string; limit?: number }): Promise<unknown>;
+  callers(input: { symbol: string; limit?: number }): Promise<unknown>;
+  imports(input: { module: string; limit?: number }): Promise<unknown>;
+  indexStatus(): Promise<unknown>;
+  indexRepo(input?: { force?: boolean }): Promise<unknown>;
+  catalogSearch(input: { query: string }): Promise<unknown>;
+  catalogDescribe(input: { name: string }): Promise<unknown>;
+};
+/** JS: Promise, JSON, Array, Object, Map, Set, Math. No require/process/fetch/fs. */
+`.trim();

package/dist/codemode/worker.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 type { MachineEnvelope } from "../runtime.js";
+import { type StickyWorker } from "./dispatch.js";
+export type StickyWorkerOptions = {
+    binary: string;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
+    /** Kill worker when one request exceeds this duration (ms). */
+    timeoutMs?: number;
+};
+export declare function startStickyWorker(options: StickyWorkerOptions): Promise<StickyWorker>;
+/** One-shot batch via stdin (avoids tempfile). */
+export declare function runBatchViaStdin(options: {
+    binary: string;
+    cwd: string;
+    body: string;
+    env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<MachineEnvelope>;