@gotgenes/pi-colgrep 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [1.2.0](https://github.com/gotgenes/pi-packages/compare/pi-colgrep-v1.1.0...pi-colgrep-v1.2.0) (2026-05-23)
+
+
+### Features
+
+* add debounced reindex scheduling ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([f12bd7d](https://github.com/gotgenes/pi-packages/commit/f12bd7d2fb47b7dbe7edfbfa65705ebe727280cc))
+* add reindexer shutdown ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([55db463](https://github.com/gotgenes/pi-packages/commit/55db4631386856e1bc791f6c01b3f03251f05c23))
+* add reindexer with immediate execution ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([84356be](https://github.com/gotgenes/pi-packages/commit/84356befd9c146ca518919587a27361965671c5f))
+* clean up reindexer on session shutdown ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([9a87869](https://github.com/gotgenes/pi-packages/commit/9a878697f352bf111ca6c1dc86ce99d6c3916eef))
+* handle reindex errors gracefully ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([2ca14d5](https://github.com/gotgenes/pi-packages/commit/2ca14d544275cf16412435079206a0c9184bb266))
+* queue reindex behind in-flight run ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([bb9ccbe](https://github.com/gotgenes/pi-packages/commit/bb9ccbe1eb56df768e547649a069ac3231835bfe))
+* register /colgrep-reindex manual command ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([c591e80](https://github.com/gotgenes/pi-packages/commit/c591e8016ea9dac9db8d47e9fe51e01febc0c5b6))
+* reindex on session start ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([d18cb8a](https://github.com/gotgenes/pi-packages/commit/d18cb8a1de49c7d92535a1b14d8d02cd6a7f93eb))
+* schedule reindex on write/edit tool results ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([bb17ea0](https://github.com/gotgenes/pi-packages/commit/bb17ea0b6bb532f0d1a64e0e07a914f408482633))
+
+
+### Documentation
+
+* plan auto-reindex on session start and file mutations ([#91](https://github.com/gotgenes/pi-packages/issues/91)) ([291d55f](https://github.com/gotgenes/pi-packages/commit/291d55f2a03674c3d84ab2e59d053b72c1b2d9b6))
+
 ## [1.1.0](https://github.com/gotgenes/pi-packages/compare/pi-colgrep-v1.0.0...pi-colgrep-v1.1.0) (2026-05-23)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotgenes/pi-colgrep",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Pi extension that integrates ColGrep semantic code search as an agent tool.",
   "type": "module",
   "files": [

package/src/extension.ts

@@ -1,9 +1,22 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createAvailabilityState } from "./lib/availability.js";
+import { createReindexer, type Reindexer } from "./lib/reindex.js";
 import { registerColGrep } from "./tools/colgrep.js";
 
+const COLGREP_STATUS_KEY = "colgrep";
+
+function setColGrepStatus(
+  ctx: { ui: { setStatus?: (key: string, text: string | undefined) => void } },
+  text: string | undefined,
+): void {
+  if (typeof ctx.ui.setStatus === "function") {
+    ctx.ui.setStatus(COLGREP_STATUS_KEY, text);
+  }
+}
+
 export default function piColGrepExtension(pi: ExtensionAPI): void {
   const availability = createAvailabilityState();
+  let reindexer: Reindexer | undefined;
 
   registerColGrep(pi, {
     exec: (cmd, args, opts) => pi.exec(cmd, args, opts),
@@ -11,7 +24,13 @@ export default function piColGrepExtension(pi: ExtensionAPI): void {
   });
 
   pi.on("session_start", async (_event, ctx) => {
-    await availability.refresh((cmd, args, opts) => pi.exec(cmd, args, opts));
+    const exec = (
+      cmd: string,
+      args: string[],
+      opts?: { cwd?: string; timeout?: number; signal?: AbortSignal },
+    ) => pi.exec(cmd, args, opts);
+
+    await availability.refresh(exec);
 
     if (!availability.available) {
       ctx.ui.notify(
@@ -19,6 +38,57 @@ export default function piColGrepExtension(pi: ExtensionAPI): void {
           "Install from: https://github.com/lightonai/next-plaid#installation",
         "warning",
       );
+      return;
     }
+
+    reindexer = createReindexer({
+      exec,
+      cwd: ctx.cwd,
+      onStatus: (text) => setColGrepStatus(ctx, text),
+    });
+    await reindexer.runNow();
+  });
+
+  pi.on("tool_result", async (event, _ctx) => {
+    if (event.isError) return;
+    if (event.toolName !== "write" && event.toolName !== "edit") return;
+    reindexer?.schedule();
+  });
+
+  pi.on("session_shutdown", async (_event, _ctx) => {
+    await reindexer?.shutdown();
+    reindexer = undefined;
+  });
+
+  pi.registerCommand("colgrep-reindex", {
+    description: "Manually refresh the ColGrep semantic search index",
+    handler: async (_args, ctx) => {
+      if (!availability.available) {
+        ctx.ui.notify(
+          "colgrep is not installed. Install from: https://github.com/lightonai/next-plaid#installation",
+          "warning",
+        );
+        return;
+      }
+
+      const exec = (
+        cmd: string,
+        args: string[],
+        opts?: { cwd?: string; timeout?: number; signal?: AbortSignal },
+      ) => pi.exec(cmd, args, opts);
+
+      // Use the session reindexer if available; otherwise create a one-shot
+      // one (e.g., if the command is invoked before session_start has run).
+      const indexer =
+        reindexer ??
+        createReindexer({
+          exec,
+          cwd: ctx.cwd,
+          onStatus: (text) => setColGrepStatus(ctx, text),
+        });
+
+      await indexer.runNow();
+      ctx.ui.notify("ColGrep index updated.", "info");
+    },
   });
 }

package/src/lib/reindex.ts

@@ -0,0 +1,111 @@
+import type { Exec } from "./exec.js";
+
+export type ReindexStatusCallback = (status: string | undefined) => void;
+
+export interface ReindexerDeps {
+  exec: Exec;
+  cwd: string;
+  onStatus: ReindexStatusCallback;
+  /** Debounce quiet period before a scheduled reindex fires. Defaults to 4000 ms. */
+  debounceMs?: number;
+  /** Exec timeout for the reindex command. Defaults to 300 000 ms (5 min). */
+  timeoutMs?: number;
+}
+
+export interface Reindexer {
+  /** Schedule a debounced reindex. Safe to call repeatedly. */
+  schedule(): void;
+  /** Run a reindex immediately, bypassing debounce. Resolves when complete. */
+  runNow(): Promise<void>;
+  /** Cancel pending timers and wait for any in-flight reindex to finish. */
+  shutdown(): Promise<void>;
+}
+
+const DEFAULT_DEBOUNCE_MS = 4_000;
+const DEFAULT_TIMEOUT_MS = 300_000;
+const INDEXING_STATUS = "colgrep: indexing\u2026";
+const QUEUED_STATUS = "colgrep: indexing\u2026 (queued updates)";
+const INDEXING_FAILED_STATUS = "colgrep: indexing failed";
+
+export function createReindexer(deps: ReindexerDeps): Reindexer {
+  const { exec, cwd, onStatus } = deps;
+  const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const debounceMs = deps.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+
+  let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+  let inFlight = false;
+  let queued = false;
+  let isShutdown = false;
+  let inflightPromise: Promise<void> | undefined;
+
+  async function runReindex(): Promise<void> {
+    inFlight = true;
+    onStatus(INDEXING_STATUS);
+    let failed = false;
+    try {
+      const result = await exec("colgrep", ["init", "-y", "."], {
+        cwd,
+        timeout: timeoutMs,
+      });
+      if (result.code !== 0) {
+        failed = true;
+        const detail = result.stderr.trim();
+        console.error(
+          `colgrep reindex failed: ${detail || `exit code ${result.code}`}`,
+        );
+      }
+    } catch (err) {
+      failed = true;
+      console.error("colgrep reindex failed:", err);
+    }
+    if (failed) {
+      onStatus(INDEXING_FAILED_STATUS);
+    }
+    onStatus(undefined);
+    inFlight = false;
+    inflightPromise = undefined;
+
+    // Drain: if a reindex was queued while we were running, start it now
+    // (unless shut down in the meantime).
+    if (queued && !isShutdown) {
+      queued = false;
+      inflightPromise = runReindex();
+    }
+  }
+
+  return {
+    async runNow(): Promise<void> {
+      await runReindex();
+    },
+    schedule(): void {
+      if (isShutdown) return;
+
+      // While a reindex is in flight, mark a queued follow-up instead of
+      // starting another debounce timer.
+      if (inFlight) {
+        if (!queued) {
+          queued = true;
+          onStatus(QUEUED_STATUS);
+        }
+        return;
+      }
+      if (debounceTimer !== undefined) {
+        clearTimeout(debounceTimer);
+      }
+      debounceTimer = setTimeout(() => {
+        debounceTimer = undefined;
+        inflightPromise = runReindex();
+      }, debounceMs);
+    },
+    async shutdown(): Promise<void> {
+      isShutdown = true;
+      if (debounceTimer !== undefined) {
+        clearTimeout(debounceTimer);
+        debounceTimer = undefined;
+      }
+      if (inflightPromise !== undefined) {
+        await inflightPromise;
+      }
+    },
+  };
+}