@vndv/pi-codegraph 0.1.2 → 0.1.4

package/README.md

@@ -88,6 +88,8 @@ CodeGraph must be installed and available on `PATH`:
 npm install -g @colbymchenry/codegraph
 ```
 
+This extension is tested against the `@colbymchenry/codegraph` npm package declared in `devDependencies`. Dependabot watches that package and opens update PRs when CodeGraph releases a new version.
+
 Each project must be indexed before pi can query it:
 
 ```bash
@@ -211,6 +213,8 @@ npm ci
 npm run ci
 ```
 
+`npm run ci` type-checks the extension, runs tests, verifies the pinned CodeGraph CLI can start, and dry-runs the npm package.
+
 Install the local checkout into pi:
 
 ```bash

package/extensions/codegraph.ts

@@ -135,6 +135,10 @@ const ToolDefinitions = [
 type ToolName = (typeof ToolDefinitions)[number]["name"];
 type ToolParams = Record<string, unknown> & { projectPath?: string };
 type JsonRpcRequest = (method: string, params: Record<string, unknown>) => Promise<any>;
+type PendingJsonRpcRequests = Map<number, {
+  resolve: (value: any) => void;
+  reject: (error: Error) => void;
+}>;
 
 const MaxDiagnosticLength = 1000;
 
@@ -194,67 +198,106 @@ async function runJsonRpcSession<T>(
   signal: AbortSignal | undefined,
   fn: (request: JsonRpcRequest) => Promise<T>,
 ): Promise<T> {
-  let nextId = 1;
-  let stdout = "";
-  let stderr = "";
-  const pending = new Map<number, {
-    resolve: (value: any) => void;
-    reject: (error: Error) => void;
-  }>();
-
-  const cleanup = () => {
-    for (const entry of pending.values()) {
-      entry.reject(new Error("CodeGraph MCP process closed before responding."));
-    }
-    pending.clear();
-    if (!child.killed) child.kill();
-  };
-
+  const pending: PendingJsonRpcRequests = new Map();
+  const stderr = { value: "" };
+  const cleanup = () => cleanupJsonRpcChild(child, pending);
   const onAbort = () => cleanup();
+
   signal?.addEventListener("abort", onAbort, { once: true });
+  attachJsonRpcHandlers(child, pending, stderr);
+
+  try {
+    const sendRequest = createJsonRpcRequestSender(child, pending);
+    await initializeJsonRpcSession(cwd, sendRequest, sendJsonRpcNotification.bind(undefined, child));
+    return await fn(sendRequest);
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    cleanup();
+  }
+}
+
+function cleanupJsonRpcChild(
+  child: ChildProcessWithoutNullStreams,
+  pending: PendingJsonRpcRequests,
+): void {
+  rejectPendingJsonRpcRequests(
+    pending,
+    new Error("CodeGraph MCP process closed before responding."),
+  );
+  if (!child.killed) child.kill();
+}
+
+function rejectPendingJsonRpcRequests(
+  pending: PendingJsonRpcRequests,
+  error: Error,
+): void {
+  for (const entry of pending.values()) entry.reject(error);
+  pending.clear();
+}
+
+function attachJsonRpcHandlers(
+  child: ChildProcessWithoutNullStreams,
+  pending: PendingJsonRpcRequests,
+  stderr: { value: string },
+): void {
+  const stdout = { value: "" };
 
   child.stdout.on("data", (chunk) => {
-    stdout += chunk.toString("utf-8");
-    let newline;
-    while ((newline = stdout.indexOf("\n")) !== -1) {
-      const line = stdout.slice(0, newline).trim();
-      stdout = stdout.slice(newline + 1);
-      if (!line) continue;
-
-      let msg: any;
-      try {
-        msg = JSON.parse(line);
-      } catch {
-        continue;
-      }
-
-      if (msg.id !== undefined && pending.has(msg.id)) {
-        const { resolve, reject } = pending.get(msg.id)!;
-        pending.delete(msg.id);
-        if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
-        else resolve(msg.result);
-      }
-    }
+    handleJsonRpcStdout(chunk, stdout, pending);
   });
-
   child.stderr.on("data", (chunk) => {
-    stderr += chunk.toString("utf-8");
+    stderr.value += chunk.toString("utf-8");
   });
+  child.on("error", (err) => rejectPendingJsonRpcRequests(pending, err));
+  child.on("exit", (code) => rejectPendingJsonRpcOnExit(pending, stderr.value, code));
+}
 
-  child.on("error", (err) => {
-    for (const entry of pending.values()) entry.reject(err);
-    pending.clear();
-  });
+function handleJsonRpcStdout(
+  chunk: Buffer,
+  stdout: { value: string },
+  pending: PendingJsonRpcRequests,
+): void {
+  stdout.value += chunk.toString("utf-8");
+  let newline;
+  while ((newline = stdout.value.indexOf("\n")) !== -1) {
+    const line = stdout.value.slice(0, newline).trim();
+    stdout.value = stdout.value.slice(newline + 1);
+    if (line) resolveJsonRpcLine(line, pending);
+  }
+}
 
-  child.on("exit", (code) => {
-    if (pending.size === 0) return;
-    const diagnostic = sanitizeDiagnostic(stderr.trim());
-    const msg = diagnostic || `CodeGraph MCP process exited with code ${code}`;
-    for (const entry of pending.values()) entry.reject(new Error(msg));
-    pending.clear();
-  });
+function resolveJsonRpcLine(line: string, pending: PendingJsonRpcRequests): void {
+  let msg: any;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (msg.id === undefined || !pending.has(msg.id)) return;
+  const { resolve, reject } = pending.get(msg.id)!;
+  pending.delete(msg.id);
+  if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+  else resolve(msg.result);
+}
+
+function rejectPendingJsonRpcOnExit(
+  pending: PendingJsonRpcRequests,
+  stderr: string,
+  code: number | null,
+): void {
+  if (pending.size === 0) return;
+  const diagnostic = sanitizeDiagnostic(stderr.trim());
+  const msg = diagnostic || `CodeGraph MCP process exited with code ${code}`;
+  rejectPendingJsonRpcRequests(pending, new Error(msg));
+}
 
-  const sendRequest: JsonRpcRequest = (method, params) => {
+function createJsonRpcRequestSender(
+  child: ChildProcessWithoutNullStreams,
+  pending: PendingJsonRpcRequests,
+): JsonRpcRequest {
+  let nextId = 1;
+  return (method, params) => {
     const id = nextId++;
     const payload = { jsonrpc: "2.0", id, method, params };
     const promise = new Promise<any>((resolve, reject) => {
@@ -263,26 +306,30 @@ async function runJsonRpcSession<T>(
     child.stdin.write(`${JSON.stringify(payload)}\n`);
     return promise;
   };
+}
 
-  const sendNotification = (method: string, params: Record<string, unknown>) => {
-    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
-  };
+function sendJsonRpcNotification(
+  child: ChildProcessWithoutNullStreams,
+  method: string,
+  params: Record<string, unknown>,
+): void {
+  child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+}
 
-  try {
-    const rootUri = pathToFileURL(cwd).href;
-    await sendRequest("initialize", {
-      protocolVersion: "2024-11-05",
-      rootUri,
-      workspaceFolders: [{ uri: rootUri, name: cwd.split(/[\\/]/).pop() || cwd }],
-      capabilities: {},
-      clientInfo: { name: "pi-codegraph", version: "0.1.0" },
-    });
-    sendNotification("initialized", {});
-    return await fn(sendRequest);
-  } finally {
-    signal?.removeEventListener("abort", onAbort);
-    cleanup();
-  }
+async function initializeJsonRpcSession(
+  cwd: string,
+  sendRequest: JsonRpcRequest,
+  sendNotification: (method: string, params: Record<string, unknown>) => void,
+): Promise<void> {
+  const rootUri = pathToFileURL(cwd).href;
+  await sendRequest("initialize", {
+    protocolVersion: "2024-11-05",
+    rootUri,
+    workspaceFolders: [{ uri: rootUri, name: cwd.split(/[\\/]/).pop() || cwd }],
+    capabilities: {},
+    clientInfo: { name: "pi-codegraph", version: "0.1.0" },
+  });
+  sendNotification("initialized", {});
 }
 
 export async function callCodeGraphTool(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vndv/pi-codegraph",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "CodeGraph tools for Pi Agent.",
   "license": "MIT",
   "type": "module",
@@ -35,9 +35,10 @@
     ]
   },
   "scripts": {
-    "ci": "npm run typecheck && npm test && npm pack --dry-run",
+    "ci": "npm run typecheck && npm test && npm run compat:codegraph && npm pack --dry-run",
+    "compat:codegraph": "codegraph --version",
     "local-release": "changeset version && changeset publish",
-    "publish-packages": "npm publish --access public --provenance",
+    "publish-packages": "node -e \"const {execSync}=require('node:child_process'); const p=require('./package.json'); const spec=p.name+'@'+p.version; try { execSync('npm view '+spec+' version', {stdio:'ignore'}); console.log(spec+' already published; skipping.'); } catch { execSync('npm publish --access public --provenance --ignore-scripts', {stdio:'inherit'}); }\"",
     "prepack": "npm run typecheck && npm test",
     "prepublishOnly": "npm run ci",
     "typecheck": "tsc --noEmit",
@@ -56,9 +57,10 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
-    "@earendil-works/pi-coding-agent": "^0.76.0",
-    "@types/node": "^20.19.30",
-    "typescript": "^5.0.0",
-    "vitest": "^2.1.9"
+    "@colbymchenry/codegraph": "^0.9.7",
+    "@earendil-works/pi-coding-agent": "^0.78.0",
+    "@types/node": "^25.9.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
   }
 }