@henryqw/pi-codegraph 0.3.1 → 0.3.2

package/README.md

@@ -16,7 +16,7 @@ Requires only the `codegraph` executable on Pi's `PATH`. No MCP server or MCP co
 | Package | Relationship | Purpose |
 | --- | --- | --- |
 | [`@colbymchenry/codegraph`](https://github.com/colbymchenry/codegraph) | Required | Builds the indexes and answers `codegraph explore` queries. |
-| [`@henryqw/pi-footer`](https://pi.henry.wang/extensions/pi-footer) | Improves | Shows a compact CodeGraph index badge and tool activity when loaded. |
+| [`@henryqw/pi-footer`](https://pi.henry.wang/extensions/pi-footer) | Improves | Shows quiet CodeGraph setup progress and direct tool activity when loaded. |
 
 ## Use
 
@@ -31,18 +31,20 @@ Then launch `pi` in a linked worktree. When the primary checkout has an index, p
 | Surface | Type | Purpose |
 | --- | --- | --- |
 | `codegraph_explore` | tool | Lets agents explore the indexed code. It returns the source of the relevant symbols grouped by file, plus the call path between them. |
-| CodeGraph setup status | ui | Shows users setup progress and errors, and confirms a new worktree index is ready. |
+| CodeGraph setup status | ui | Shows a dim footer spinner and elapsed time during setup. Clears silently when done; setup errors remain visible with recovery instructions. |
 
 `codegraph_explore` takes a `query`, an optional `maxFiles` (default 12), and an optional `projectPath` (defaults to Pi's working directory). It runs `codegraph explore --path <projectPath> --max-files <maxFiles> <query>` and returns the output as-is. If the command exits with an error or runs longer than 120 seconds, the tool call fails and shows the end of CodeGraph's error output.
 
 ## Flow
 
 - A missing worktree index is built only when the primary checkout already has `.codegraph/codegraph.db`.
-- Initialization happens when Pi launches, not when Git creates the worktree.
+- Initialization happens when Pi launches, not when Git creates the worktree. In TUI mode it runs in the background so the footer and later startup handlers can load.
 - Each linked worktree keeps its own `.codegraph`; databases are never copied or shared between branches.
 - Non-Git directories and repositories without a primary index are not initialized.
-- The extension reports `checking index…` and `indexing…` during setup, `indexed` when a database file exists, `missing` when no index was built, `prerequisites missing` when setup was skipped, and `setup failed` on an error. `indexed` does not guarantee database health.
-- If `pi-footer` is also loaded, it places a compact `CG` badge first on its third line: `✓ CG` indexed, `○ CG` missing, `◐ CG` checking or indexing, `! CG` setup problem, or `? CG` unknown state. It temporarily shows `● CG` only during `codegraph_explore` calls.
+- Setup shows a dim footer status such as `⠋ codegraph · indexing 8s`, or `waiting for index` when another session holds the initialization lock. Only TUI mode animates the spinner. Progress disappears when setup finishes; there is no success message or idle index badge.
+- Missing prerequisites and setup failures remain visible with a theme-colored `!` icon, meaningful text, and an actionable notification.
+- Creating, resuming, or forking a session waits for in-flight worktree initialization instead of interrupting it. Repeated startup events reuse that initialization. Quitting or reloading Pi cancels the initializer and every Git probe; interrupted initialization keeps the lock for explicit recovery.
+- If `pi-footer` is also loaded, it preserves the setup status on its third line and temporarily shows `● CG` during direct `codegraph_explore` calls.
 
 ## State and storage
 

package/extensions/codegraph.ts

@@ -7,8 +7,31 @@ import { Type } from "typebox";
 const LOCK_WAIT_MS = 5 * 60_000;
 const INIT_TIMEOUT_MS = 10 * 60_000;
 const EXPLORE_TIMEOUT_MS = 120_000;
-const WIDGET_KEY = "pi-codegraph";
-const SUCCESS_TTL_MS = 5000;
+const STATUS_KEY = "pi-codegraph";
+const SPINNER_INTERVAL_MS = 100;
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function showProgress(ctx: ExtensionContext, action: string, signal: AbortSignal): () => void {
+	if (!ctx.hasUI) return () => {};
+	signal.throwIfAborted();
+	const startedAt = Date.now();
+	const update = () => {
+		const frame = SPINNER_FRAMES[Math.floor(Date.now() / SPINNER_INTERVAL_MS) % SPINNER_FRAMES.length]!;
+		const seconds = Math.max(0, Math.floor((Date.now() - startedAt) / 1000));
+		const elapsed = seconds >= 60 ? `${Math.floor(seconds / 60)}m ${seconds % 60}s` : `${seconds}s`;
+		ctx.ui.setStatus(STATUS_KEY, ctx.ui.theme.fg("dim", `${frame} codegraph · ${action} ${elapsed}`));
+	};
+	update();
+	const timer = ctx.mode === "tui" ? setInterval(update, SPINNER_INTERVAL_MS) : undefined;
+	timer?.unref();
+	const stop = () => {
+		if (timer) clearInterval(timer);
+		signal.removeEventListener("abort", stop);
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+	};
+	signal.addEventListener("abort", stop, { once: true });
+	return stop;
+}
 
 async function hasIndex(root: string): Promise<boolean> {
 	try {
@@ -19,26 +42,29 @@ async function hasIndex(root: string): Promise<boolean> {
 	}
 }
 
-async function git(pi: ExtensionAPI, cwd: string, args: string[]): Promise<string> {
-	const result = await pi.exec("git", args, { cwd, timeout: 10_000 });
+async function git(pi: ExtensionAPI, cwd: string, args: string[], signal: AbortSignal): Promise<string> {
+	const result = await pi.exec("git", args, { cwd, timeout: 10_000, signal });
+	signal.throwIfAborted();
 	if (result.code !== 0 || result.killed) {
 		throw new Error(`git ${args.join(" ")} failed: ${result.stderr.trim() || `exit ${result.code}`}`);
 	}
 	return result.stdout.replace(/\r?\n$/, "");
 }
 
-async function initialize(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
-	const version = await pi.exec("codegraph", ["--version"], { cwd: ctx.cwd, timeout: 10_000 });
+async function initialize(pi: ExtensionAPI, ctx: ExtensionContext, signal: AbortSignal): Promise<void> {
+	ctx.ui.setStatus(STATUS_KEY, undefined);
+	const version = await pi.exec("codegraph", ["--version"], { cwd: ctx.cwd, timeout: 10_000, signal });
+	signal.throwIfAborted();
 	if (version.code !== 0 || version.killed) {
 		const detail = version.killed ? "timed out or killed" : version.stderr.trim().slice(-1000) || `exit ${version.code}`;
 		const message = `pi-codegraph: setup skipped.\ncodegraph --version failed (${detail}). Install CodeGraph: npm install -g @colbymchenry/codegraph. If already installed, check that codegraph runs on Pi's PATH.\nThen restart Pi or /reload.`;
-		ctx.ui.setStatus("pi-codegraph", "pi-codegraph: prerequisites missing");
+		ctx.ui.setStatus(STATUS_KEY, `${ctx.ui.theme.fg("warning", "!")} pi-codegraph: prerequisites missing`);
 		if (ctx.hasUI) ctx.ui.notify(message, "warning");
 		else console.warn(message);
 		return;
 	}
-	ctx.ui.setStatus("pi-codegraph", "pi-codegraph: missing");
-	const rootResult = await pi.exec("git", ["rev-parse", "--show-toplevel"], { cwd: ctx.cwd, timeout: 10_000 });
+	const rootResult = await pi.exec("git", ["rev-parse", "--show-toplevel"], { cwd: ctx.cwd, timeout: 10_000, signal });
+	signal.throwIfAborted();
 	if (rootResult.code !== 0 || rootResult.killed) {
 		if (!rootResult.killed && rootResult.stderr.includes("not a git repository")) return;
 		throw new Error(`Cannot locate Git worktree: ${rootResult.stderr.trim() || `exit ${rootResult.code}`}`);
@@ -48,24 +74,29 @@ async function initialize(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void
 	if (process.env.CODEGRAPH_DIR && process.env.CODEGRAPH_DIR !== ".codegraph") {
 		throw new Error("pi-codegraph requires the default CODEGRAPH_DIR (.codegraph). Unset CODEGRAPH_DIR before launching Pi.");
 	}
-	const gitDir = await git(pi, root, ["rev-parse", "--absolute-git-dir"]);
+	const gitDir = await git(pi, root, ["rev-parse", "--absolute-git-dir"], signal);
 	if (!gitDir) throw new Error("Git returned an empty metadata directory.");
 	const lock = join(gitDir, "pi-codegraph-init.lock");
 	// Check the lock before the database: an in-progress/failed init can leave a partial DB.
 	const recovery = `Inspect CodeGraph in ${root}. If no initializer is running, run codegraph index in that directory, then remove ${lock} with rmdir and /reload.`;
 	const deadline = Date.now() + LOCK_WAIT_MS;
-	ctx.ui.setStatus("pi-codegraph", "pi-codegraph: checking index…");
+	let stopProgress = () => {};
+	let waiting = false;
 	let indexed = false;
 	try {
 		while (true) {
+			signal.throwIfAborted();
 			try {
 				await mkdir(lock);
 				break;
 			} catch (error) {
 				if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
 				if (Date.now() >= deadline) throw new Error(`Timed out waiting for CodeGraph initialization. ${recovery}`);
-				ctx.ui.setStatus("pi-codegraph", "pi-codegraph: indexing…");
-				await delay(250);
+				if (!waiting) {
+					stopProgress = showProgress(ctx, "waiting for index", signal);
+					waiting = true;
+				}
+				await delay(250, undefined, { signal });
 			}
 		}
 		let attempted = false;
@@ -74,24 +105,20 @@ async function initialize(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void
 				indexed = true;
 				return;
 			}
-			const worktrees = await git(pi, root, ["worktree", "list", "--porcelain", "-z"]);
+			const worktrees = await git(pi, root, ["worktree", "list", "--porcelain", "-z"], signal);
 			const first = worktrees.split("\0", 1)[0];
 			if (!first?.startsWith("worktree ")) throw new Error("Git returned an invalid primary worktree.");
 			const primary = first.slice("worktree ".length);
 			if (!primary || primary === root || !(await hasIndex(primary))) return;
-			ctx.ui.setStatus("pi-codegraph", "pi-codegraph: indexing…");
+			stopProgress();
+			stopProgress = showProgress(ctx, "indexing", signal);
 			attempted = true;
-			const result = await pi.exec("codegraph", ["init", "--yes", root], { cwd: root, timeout: INIT_TIMEOUT_MS });
+			const result = await pi.exec("codegraph", ["init", "--yes", root], { cwd: root, timeout: INIT_TIMEOUT_MS, signal });
+			signal.throwIfAborted();
 			if (result.code !== 0 || result.killed || !(await hasIndex(root))) {
 				throw new Error(`CodeGraph init failed (${result.killed ? "timed out or killed" : `exit ${result.code}`}): ${(result.stderr || result.stdout).trim().slice(-2000)}`);
 			}
 			indexed = true;
-			if (ctx.hasUI) {
-				ctx.ui.setWidget(WIDGET_KEY, ["pi-codegraph: index ready"]);
-				setTimeout(() => ctx.ui.setWidget(WIDGET_KEY, undefined), SUCCESS_TTL_MS);
-			} else {
-				ctx.ui.notify("CodeGraph worktree index ready.", "info");
-			}
 		} catch (error) {
 			if (attempted) throw new Error(`${error instanceof Error ? error.message : String(error)}\n${recovery}`, { cause: error });
 			throw error;
@@ -100,11 +127,21 @@ async function initialize(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void
 			if (!attempted || indexed) await rmdir(lock);
 		}
 	} finally {
-		ctx.ui.setStatus("pi-codegraph", indexed ? "pi-codegraph: indexed" : "pi-codegraph: missing");
+		if (!signal.aborted) {
+			stopProgress();
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+		}
 	}
 }
 
 export default function codegraphExtension(pi: ExtensionAPI): void {
+	let initializer: AbortController | undefined;
+	let setup: Promise<void> | undefined;
+	pi.on("session_shutdown", (event) => {
+		// Session replacement waits for worktree-scoped indexing instead of abandoning its lock.
+		if (event.reason !== "new" && event.reason !== "resume" && event.reason !== "fork") initializer?.abort();
+		return setup;
+	});
 	pi.registerTool({
 		name: "codegraph_explore",
 		label: "CodeGraph explore",
@@ -124,14 +161,19 @@ export default function codegraphExtension(pi: ExtensionAPI): void {
 			return { content: [{ type: "text", text: result.stdout }], details: undefined };
 		},
 	});
-	pi.on("session_start", async (_event, ctx) => {
-		try {
-			await initialize(pi, ctx);
-		} catch (error) {
+	pi.on("session_start", (_event, ctx) => {
+		if (setup) return ctx.mode === "tui" ? undefined : setup;
+		const controller = initializer = new AbortController();
+		setup = initialize(pi, ctx, controller.signal).catch((error) => {
+			if (controller.signal.aborted) return;
 			const message = `pi-codegraph: ${error instanceof Error ? error.message : String(error)}`;
-			ctx.ui.setStatus("pi-codegraph", "pi-codegraph: setup failed");
+			ctx.ui.setStatus(STATUS_KEY, `${ctx.ui.theme.fg("error", "!")} pi-codegraph: setup failed`);
 			if (ctx.hasUI) ctx.ui.notify(message, "error");
 			else throw new Error(message, { cause: error });
-		}
+		}).finally(() => {
+			setup = undefined;
+			initializer = undefined;
+		});
+		if (ctx.mode !== "tui") return setup;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-codegraph",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Initialize CodeGraph indexes in opted-in Git worktrees and expose codegraph_explore as a Pi tool.",
   "keywords": [
     "pi-package",