pi-ast-sgrep 2.0.0 → 2.0.2

package/README.md

@@ -132,9 +132,9 @@ Code Mode and `ast-sgrep-mcp` are separate front ends over the same Rust search
 
 Start Pi in the repository you want to search. The first search validates the index and lazily creates `<project-root>/.asgrep/` when needed. Run `/asgrep-index` if you want to build it before searching.
 
-After a successful Pi `write` or `edit`, the extension marks the affected path dirty and updates only known changed paths before the next search. It also watches the project for external filesystem changes: known file changes receive the same targeted update, while renames, directory changes, ignore-file edits, watcher errors, and ambiguous events trigger a correctness scan. `.asgrep` writes are excluded so indexing cannot dirty itself. If recursive watching is unavailable, an immediate scan plus the periodic full scan preserve correctness. Concurrent searches for the same root share one in-flight refresh.
+After a successful Pi `write` or `edit`, the extension marks the affected path dirty and updates only known changed paths before the next search. It also watches the project for external filesystem changes: known file changes receive the same targeted update, while renames, directory changes, ignore-file edits, watcher errors, and ambiguous events trigger a correctness scan. `.asgrep` writes are excluded so indexing cannot dirty itself. If recursive watching is unavailable, an immediate scan on first use preserves correctness. A ready index is not walked on first search or on the refresh interval; the interval only re-checks index health. Concurrent searches for the same root share one in-flight refresh. The last cancelled waiter aborts that shared index so Pi cannot leave workers running after a search is cancelled. In-process indexing uses the host's available parallelism by default.
 
-The periodic interval forces a full incremental reconciliation even when the watcher reports nothing, covering dropped or coalesced filesystem events. Run `/asgrep-index` when you need freshness immediately after a large external operation; use `/asgrep-reindex` only for an incompatible or corrupt index, or when you explicitly need a strict full rebuild.
+The refresh interval does not force a full tree walk. Run `/asgrep-index` when you need freshness immediately after a large external operation the watcher did not see; use `/asgrep-reindex` only for an incompatible or corrupt index, or when you explicitly need a strict full rebuild.
 
 The package never edits `.gitignore`. Add this entry yourself if index data must stay untracked:
 
@@ -209,6 +209,7 @@ Defaults are a 30-second operation timeout, 4 MiB output limit, and 30-second fr
 | `ASGREP_TIMEOUT_MS` | Set the native operation timeout. |
 | `ASGREP_MAX_OUTPUT_BYTES` | Bound native output. |
 | `ASGREP_REFRESH_INTERVAL_MS` | Set the idle freshness-check interval. |
+| `ASGREP_INDEX_THREADS` | Cap in-process Code Mode indexing threads (default: host parallelism). |
 | `ASGREP_BIN` | Override the packaged binary for development. |
 
 Explicit project configuration can opt into `allowOutsideProject`; global settings and environment variables cannot relax the default project boundary. See the [complete package guide](https://github.com/AdityaVG13/ast-sgrep/blob/main/docs/pi-package.md) for schema and precedence details.

package/dist/present.d.ts

@@ -45,6 +45,9 @@ export declare function formatSearchResult(response: EnvelopeLike, meta: {
 }, theme?: PresentTheme): string;
 export declare function formatStatusResult(response: EnvelopeLike, theme?: PresentTheme): string;
 export declare function formatIndexResult(command: string, response: EnvelopeLike, theme?: PresentTheme): string;
+/** Local stand-in so we do not take a pi-tui dependency. Over-counts wide glyphs rather than under-count. */
+export declare function visibleWidth(text: string): number;
+export declare function truncateToWidth(text: string, maxWidth: number, ellipsis?: string): string;
 export declare function formatCodemodeResult(value: unknown, meta?: {
     stats?: {
         calls: number;
@@ -62,6 +65,6 @@ export declare class AsgrepText {
     constructor(text?: string);
     setText(text: string): void;
     invalidate(): void;
-    render(_width: number): string[];
+    render(width: number): string[];
 }
 export declare function presentText(formatted: string, last: unknown): AsgrepText;

package/dist/present.js

@@ -84,6 +84,97 @@ export function formatIndexResult(command, response, theme) {
     const tail = count === undefined ? "done" : `${count} file${count === 1 ? "" : "s"}`;
     return header(theme, command, [tail]);
 }
+function ansiLengthAt(text, index) {
+    if (text.charCodeAt(index) !== 0x1b)
+        return 0;
+    const next = text[index + 1];
+    if (next === "[") {
+        let cursor = index + 2;
+        while (cursor < text.length) {
+            const code = text.charCodeAt(cursor);
+            if (code >= 0x40 && code <= 0x7e)
+                return cursor - index + 1;
+            cursor += 1;
+        }
+        return text.length - index;
+    }
+    if (next === "]") {
+        let cursor = index + 2;
+        while (cursor < text.length) {
+            if (text.charCodeAt(cursor) === 0x07)
+                return cursor - index + 1;
+            if (text.charCodeAt(cursor) === 0x1b && text[cursor + 1] === "\\")
+                return cursor - index + 2;
+            cursor += 1;
+        }
+        return text.length - index;
+    }
+    if (next === "P" || next === "X" || next === "^" || next === "_") {
+        let cursor = index + 2;
+        while (cursor < text.length) {
+            if (text.charCodeAt(cursor) === 0x1b && text[cursor + 1] === "\\")
+                return cursor - index + 2;
+            cursor += 1;
+        }
+        return text.length - index;
+    }
+    return Math.min(2, text.length - index);
+}
+function cellWidthAt(text, index) {
+    const code = text.charCodeAt(index);
+    if (code === 0x09)
+        return { width: 3, length: 1 };
+    if (code >= 0xd800 && code <= 0xdbff)
+        return { width: 2, length: 2 };
+    if (code <= 0x1f || (code >= 0x7f && code <= 0x9f))
+        return { width: 0, length: 1 };
+    if (code <= 0x7e)
+        return { width: 1, length: 1 };
+    return { width: 2, length: 1 };
+}
+/** Local stand-in so we do not take a pi-tui dependency. Over-counts wide glyphs rather than under-count. */
+export function visibleWidth(text) {
+    let width = 0;
+    for (let index = 0; index < text.length;) {
+        const ansi = ansiLengthAt(text, index);
+        if (ansi > 0) {
+            index += ansi;
+            continue;
+        }
+        const cell = cellWidthAt(text, index);
+        width += cell.width;
+        index += cell.length;
+    }
+    return width;
+}
+export function truncateToWidth(text, maxWidth, ellipsis = "...") {
+    const limit = Math.max(0, maxWidth);
+    if (limit <= 0)
+        return "";
+    if (visibleWidth(text) <= limit)
+        return text;
+    const ellipsisWidth = visibleWidth(ellipsis);
+    if (ellipsisWidth >= limit)
+        return ellipsis.slice(0, limit);
+    const budget = limit - ellipsisWidth;
+    let kept = "";
+    let width = 0;
+    for (let index = 0; index < text.length;) {
+        const ansi = ansiLengthAt(text, index);
+        if (ansi > 0) {
+            kept += text.slice(index, index + ansi);
+            index += ansi;
+            continue;
+        }
+        const cell = cellWidthAt(text, index);
+        if (width + cell.width > budget)
+            break;
+        kept += text.slice(index, index + cell.length);
+        width += cell.width;
+        index += cell.length;
+    }
+    return `${kept}${ellipsis}`;
+}
 function compactValue(value) {
     if (value === null || value === undefined)
         return String(value);
@@ -149,8 +240,11 @@ export class AsgrepText {
         this.#text = text;
     }
     invalidate() { }
-    render(_width) {
-        return this.#text.length === 0 ? [""] : this.#text.split("\n");
+    render(width) {
+        const maxWidth = Math.max(1, width);
+        if (this.#text.length === 0)
+            return [""];
+        return this.#text.split("\n").map((line) => truncateToWidth(line, maxWidth));
     }
 }
 export function presentText(formatted, last) {

package/dist/runtime.js

@@ -312,6 +312,21 @@ function waitForRefresh(refresh, signal) {
         });
     });
 }
+/** Shared refresh continues while other waiters remain; the last cancel stops it. */
+function attachRefreshWaiter(state, refresh, signal) {
+    state.waiterCount += 1;
+    let cancelledByWaiter = false;
+    const wait = waitForRefresh(refresh, signal).catch((cause) => {
+        cancelledByWaiter = cause instanceof RuntimeError && cause.code === "CANCELLED" && signal?.aborted === true;
+        throw cause;
+    });
+    return wait.finally(() => {
+        state.waiterCount = Math.max(0, state.waiterCount - 1);
+        if (cancelledByWaiter && state.waiterCount === 0 && state.inFlight !== undefined) {
+            state.refreshAbort?.abort();
+        }
+    });
+}
 export class FreshnessCoordinator {
     #states = new Map();
     #pending = new Map();
@@ -373,7 +388,7 @@ export class FreshnessCoordinator {
         }
     }
     async ensureFresh(runtime, context, options = {}) {
-        const root = await runtime.resolveRoot(context);
+        const root = canonicalizeRootPath(await runtime.resolveRoot(context));
         const rootContext = { cwd: root, [RESOLVED_ROOT]: true };
         let state = this.#states.get(root);
         if (!state) {
@@ -385,6 +400,8 @@ export class FreshnessCoordinator {
                 initialized: false,
                 lastRefreshAt: 0,
                 inFlight: undefined,
+                refreshAbort: undefined,
+                waiterCount: 0,
                 watcher: undefined,
             };
             this.#states.set(root, state);
@@ -413,12 +430,16 @@ export class FreshnessCoordinator {
                 this.#pending.delete(pendingRoot);
         }
         if (state.inFlight) {
-            await waitForRefresh(state.inFlight, options.signal);
+            await attachRefreshWaiter(state, state.inFlight, options.signal);
             return this.ensureFresh(runtime, rootContext, options);
         }
+        if (options.signal?.aborted)
+            throw cancelledRefreshWait();
         const now = this.#now();
         const elapsed = now - state.lastRefreshAt;
         // Lease expiry: initialized and interval elapsed (or clock went backwards).
+        // Expiry re-probes status (missing/incompatible) but must not walk a ready
+        // index. First search of a ready, clean index is the same: status only.
         const expired = state.initialized && (elapsed < 0 || elapsed >= this.#interval);
         if (state.initialized && state.cleanGeneration === state.dirtyGeneration && !expired)
             return root;
@@ -427,8 +448,12 @@ export class FreshnessCoordinator {
         const fullScanRequired = state.fullScanRequired;
         // Correctness work belongs to the root, not to whichever request happened
         // to start it. Individual callers may stop waiting, but cannot cancel the
-        // shared refresh while other callers depend on it.
-        const sharedOptions = {};
+        // shared refresh while other callers still depend on it. The last waiter
+        // abort stops the in-flight index so Pi/tool cancel cannot leave rayon
+        // workers burning CPU.
+        const refreshAbort = new AbortController();
+        state.refreshAbort = refreshAbort;
+        const sharedOptions = { signal: refreshAbort.signal };
         if (options.timeoutMs !== undefined)
             sharedOptions.timeoutMs = options.timeoutMs;
         if (options.env !== undefined)
@@ -443,7 +468,10 @@ export class FreshnessCoordinator {
                 else
                     await runIndex(runtime, true, rootContext, sharedOptions);
             }
-            else if (health === "missing" || !state.initialized || expired || (dirty && (fullScanRequired || refreshPaths.length === 0))) {
+            else if (health === "missing") {
+                await runIndex(runtime, false, rootContext, sharedOptions);
+            }
+            else if (dirty && (fullScanRequired || refreshPaths.length === 0)) {
                 await runIndex(runtime, false, rootContext, sharedOptions);
             }
             else if (dirty) {
@@ -459,14 +487,16 @@ export class FreshnessCoordinator {
         })();
         let tracked;
         tracked = refresh.finally(() => {
-            if (state.inFlight === tracked)
+            if (state.inFlight === tracked) {
                 state.inFlight = undefined;
+                state.refreshAbort = undefined;
+            }
         });
         state.inFlight = tracked;
         // If every waiter is cancelled, the root-owned refresh still needs a
         // rejection handler while it finishes in the background.
         void tracked.catch(() => undefined);
-        await waitForRefresh(tracked, options.signal);
+        await attachRefreshWaiter(state, tracked, options.signal);
         if (state.cleanGeneration !== state.dirtyGeneration) {
             return this.ensureFresh(runtime, rootContext, options);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ast-sgrep",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Native Code Mode, structural, graph, and semantic code search for Pi",
   "type": "module",
   "license": "MIT",