@isac322/pi-codegraph 0.2.0 → 0.3.1

package/lib/jsonrpc.mjs

@@ -1,90 +0,0 @@
-export class JsonRpcPeer {
-  constructor(readable, writable, options = {}) {
-    this.readable = readable;
-    this.writable = writable;
-    this.name = options.name || "JSON-RPC peer";
-    this.nextId = 1;
-    this.pending = new Map();
-    this.buffer = "";
-    this.closed = false;
-    readable.on("data", (chunk) => this.#onData(chunk));
-    readable.on("error", (error) => this.close(error));
-    readable.on("end", () => this.close(new Error(`${this.name} closed`)));
-  }
-
-  request(method, params = {}, options = {}) {
-    if (this.closed) return Promise.reject(new Error(`${this.name} is closed`));
-    const id = this.nextId++;
-    const timeoutMs = options.timeoutMs || 30_000;
-    return new Promise((resolve, reject) => {
-      let timer;
-      const finish = (error, value) => {
-        clearTimeout(timer);
-        options.signal?.removeEventListener("abort", onAbort);
-        this.pending.delete(id);
-        error ? reject(error) : resolve(value);
-      };
-      const onAbort = () => {
-        this.notify("notifications/cancelled", { requestId: id, reason: "aborted" });
-        const error = new Error(`${method} aborted`);
-        error.name = "AbortError";
-        finish(error);
-      };
-      timer = setTimeout(() => {
-        this.notify("notifications/cancelled", { requestId: id, reason: "timeout" });
-        const error = new Error(`${method} timed out after ${timeoutMs}ms`);
-        error.code = "ETIMEDOUT";
-        finish(error);
-      }, timeoutMs);
-      timer.unref?.();
-      options.signal?.addEventListener("abort", onAbort, { once: true });
-      this.pending.set(id, { finish });
-      this.#write({ jsonrpc: "2.0", id, method, params });
-    });
-  }
-
-  notify(method, params = {}) {
-    if (!this.closed) this.#write({ jsonrpc: "2.0", method, params });
-  }
-
-  close(error = new Error(`${this.name} closed`)) {
-    if (this.closed) return;
-    this.closed = true;
-    for (const pending of this.pending.values()) pending.finish(error);
-    this.pending.clear();
-  }
-
-  #write(message) {
-    try {
-      this.writable.write(`${JSON.stringify(message)}\n`);
-    } catch (error) {
-      this.close(error);
-    }
-  }
-
-  #onData(chunk) {
-    this.buffer += chunk.toString("utf8");
-    let newline;
-    while ((newline = this.buffer.indexOf("\n")) !== -1) {
-      const line = this.buffer.slice(0, newline).trim();
-      this.buffer = this.buffer.slice(newline + 1);
-      if (!line) continue;
-      let message;
-      try {
-        message = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (message.id === undefined || (!Object.hasOwn(message, "result") && !Object.hasOwn(message, "error"))) continue;
-      const pending = this.pending.get(message.id);
-      if (!pending) continue;
-      if (message.error) {
-        const error = new Error(message.error.message || JSON.stringify(message.error));
-        error.code = message.error.code;
-        pending.finish(error);
-      } else {
-        pending.finish(undefined, message.result);
-      }
-    }
-  }
-}

package/lib/pi-mcp-client.mjs

@@ -1,68 +0,0 @@
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { JsonRpcPeer } from "./jsonrpc.mjs";
-import { sanitizeDiagnostic } from "./codegraph.mjs";
-import { settingsEnvironment } from "./config.mjs";
-
-const serverPath = fileURLToPath(new URL("../bin/codegraph-mcp.mjs", import.meta.url));
-
-export class PiCodeGraphClient {
-  constructor(settings, baseRoot) {
-    this.settings = settings;
-    this.baseRoot = baseRoot;
-    this.startPromise = undefined;
-    this.child = undefined;
-    this.peer = undefined;
-  }
-
-  async start() {
-    if (this.peer) return;
-    if (this.startPromise) return this.startPromise;
-    this.startPromise = this.#start().finally(() => { this.startPromise = undefined; });
-    return this.startPromise;
-  }
-
-  async #start() {
-    const child = spawn(process.execPath, [serverPath], {
-      cwd: this.baseRoot,
-      env: { ...process.env, ...settingsEnvironment(this.settings, this.baseRoot, true) },
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => { stderr = `${stderr}${chunk.toString("utf8")}`.slice(-8_000); });
-    const peer = new JsonRpcPeer(child.stdout, child.stdin, { name: "pi-codegraph MCP facade" });
-    child.on("error", (error) => peer.close(error));
-    child.on("exit", (code) => peer.close(new Error(sanitizeDiagnostic(stderr) || `pi-codegraph MCP facade exited with code ${code}`)));
-    this.child = child;
-    this.peer = peer;
-    try {
-      await peer.request("initialize", {
-        protocolVersion: "2024-11-05",
-        capabilities: {},
-        clientInfo: { name: "pi-codegraph-pi", version: "0.2.0" },
-      }, { timeoutMs: this.settings.requestTimeoutMs });
-      peer.notify("initialized", {});
-    } catch (error) {
-      await this.close();
-      throw error;
-    }
-  }
-
-  async request(method, params = {}, signal) {
-    await this.start();
-    return this.peer.request(method, params, { signal, timeoutMs: this.settings.requestTimeoutMs });
-  }
-
-  async callTool(name, args, signal) {
-    return this.request("tools/call", { name, arguments: args }, signal);
-  }
-
-  async close() {
-    const peer = this.peer;
-    const child = this.child;
-    this.peer = undefined;
-    this.child = undefined;
-    peer?.close(new Error("Pi session closed"));
-    if (child && !child.killed) child.kill();
-  }
-}

package/lib/prompt.mjs

@@ -1,15 +0,0 @@
-export function buildCodeGraphPrompt({ runtime, cwd, status }) {
-  const projectRule = runtime === "omp"
-    ? `Always pass projectPath=\"${cwd}\" so parent and child agents query the correct worktree.`
-    : `The extension automatically binds omitted projectPath to \"${cwd}\".`;
-  const state = status.identityMatches === false ? "identity-mismatch" : status.state;
-  return [
-    "CodeGraph structural tools are available as codegraph_* tools.",
-    `Active project: ${cwd}`,
-    `Index state: ${state}${status.lastSyncAt ? `; last sync: ${status.lastSyncAt}` : ""}`,
-    projectRule,
-    "For architecture, execution flow, symbol location, dependency impact, and project navigation, use CodeGraph before grep/read.",
-    "Use codegraph_explore for broad flows, codegraph_search for symbol names, codegraph_node for a known symbol, codegraph_files for structure, and codegraph_callers/codegraph_impact before shared API changes.",
-    "Use grep/read for literal text, generated names, or when CodeGraph is insufficient.",
-  ].join("\n");
-}

package/lib/tool-metadata.mjs

@@ -1,97 +0,0 @@
-const projectPath = {
-  type: "string",
-  description: "Absolute path to the target project or worktree. Pi fills this with the active cwd when omitted; OMP child agents should pass their exact worktree path.",
-};
-
-const kind = {
-  type: "string",
-  enum: ["function", "method", "class", "interface", "type", "variable", "route", "component"],
-};
-
-function object(properties, required = []) {
-  return { type: "object", properties, required, additionalProperties: false };
-}
-
-export const codegraphTools = Object.freeze([
-  {
-    name: "codegraph_search",
-    label: "CodeGraph Search",
-    description: "Search indexed declarations by symbol name. Use this before text search when you know all or part of a symbol name.",
-    promptSnippet: "Find declarations and symbol locations by name in the active CodeGraph index.",
-    promptGuidelines: ["Use for symbol names, not literal strings.", "Follow a result with codegraph_node when implementation or relationships are needed."],
-    inputSchema: object({ query: { type: "string", description: "Symbol name or partial name." }, kind, limit: { type: "number", default: 10 }, projectPath }, ["query"]),
-  },
-  {
-    name: "codegraph_node",
-    label: "CodeGraph Node",
-    description: "Inspect one known symbol, including signature, location, source, callers, and callees.",
-    promptSnippet: "Inspect a known symbol and its immediate relationships.",
-    promptGuidelines: ["Use after codegraph_search identifies the symbol.", "Set includeCode only when source is necessary."],
-    inputSchema: object({ symbol: { type: "string", description: "Exact or unambiguous symbol name." }, includeCode: { type: "boolean", default: false }, projectPath }, ["symbol"]),
-  },
-  {
-    name: "codegraph_files",
-    label: "CodeGraph Files",
-    description: "Read the indexed project file tree. Paths are normalized to repo-relative POSIX prefixes.",
-    promptSnippet: "Inspect indexed project structure without filesystem traversal.",
-    promptGuidelines: ["Use before read/glob for architectural navigation.", "Pass a repo-relative directory prefix such as src/components."],
-    inputSchema: object({ path: { type: "string", description: "Repo-relative path prefix." }, pattern: { type: "string" }, format: { type: "string", enum: ["tree", "flat", "grouped"], default: "tree" }, includeMetadata: { type: "boolean", default: true }, maxDepth: { type: "number" }, projectPath }),
-  },
-  {
-    name: "codegraph_callers",
-    label: "CodeGraph Callers",
-    description: "Find functions and methods that call a symbol.",
-    promptSnippet: "Trace inbound calls to a known symbol.",
-    promptGuidelines: ["Use for inbound flow and direct impact."],
-    inputSchema: object({ symbol: { type: "string" }, limit: { type: "number", default: 20 }, projectPath }, ["symbol"]),
-  },
-  {
-    name: "codegraph_callees",
-    label: "CodeGraph Callees",
-    description: "Find functions and methods called by a symbol.",
-    promptSnippet: "Trace outbound calls from a known symbol.",
-    promptGuidelines: ["Use for downstream execution flow."],
-    inputSchema: object({ symbol: { type: "string" }, limit: { type: "number", default: 20 }, projectPath }, ["symbol"]),
-  },
-  {
-    name: "codegraph_impact",
-    label: "CodeGraph Impact",
-    description: "Analyze the transitive impact radius of changing a symbol.",
-    promptSnippet: "Estimate what a symbol change can affect.",
-    promptGuidelines: ["Use before editing shared APIs or heavily referenced symbols."],
-    inputSchema: object({ symbol: { type: "string" }, depth: { type: "number", default: 2 }, projectPath }, ["symbol"]),
-  },
-  {
-    name: "codegraph_explore",
-    label: "CodeGraph Explore",
-    description: "Explore several related symbols and source locations grouped by file. Best first tool for broad architecture and flow questions.",
-    promptSnippet: "Explore a feature, flow, or architectural concept across related symbols.",
-    promptGuidelines: ["Prefer this first for broad how-does-it-work questions.", "Narrow the query before increasing maxFiles."],
-    inputSchema: object({ query: { type: "string", description: "Specific symbols, files, or code terms to explore." }, maxFiles: { type: "number", default: 12 }, projectPath }, ["query"]),
-  },
-  {
-    name: "codegraph_status",
-    label: "CodeGraph Status",
-    description: "Report CodeGraph index health and pending synchronization state.",
-    promptSnippet: "Check whether the active project index is ready and current.",
-    promptGuidelines: ["Use when another CodeGraph tool reports an index or lock error."],
-    inputSchema: object({ projectPath }),
-  },
-]);
-
-export const codegraphToolNames = Object.freeze(codegraphTools.map((tool) => tool.name));
-
-export function toolCallLabel(name, args = {}) {
-  const value = args.query || args.symbol || args.path || "status";
-  const project = typeof args.projectPath === "string" ? args.projectPath.split(/[\\/]/).filter(Boolean).at(-1) : "current";
-  return `${value} · ${project}`;
-}
-
-export function summarizeToolText(text) {
-  const lines = String(text || "").split("\n").filter((line) => line.trim());
-  return {
-    firstLine: lines[0] || "No output",
-    lineCount: lines.length,
-    truncated: String(text || "").includes("[pi-codegraph output truncated]"),
-  };
-}

package/lib/worker-pool.mjs

@@ -1,107 +0,0 @@
-import { spawn } from "node:child_process";
-import { pathToFileURL } from "node:url";
-import { JsonRpcPeer } from "./jsonrpc.mjs";
-import { resolveCodeGraphLaunch, sanitizeDiagnostic } from "./codegraph.mjs";
-
-export class CodeGraphWorkerPool {
-  constructor(settings) {
-    this.settings = settings;
-    this.entries = new Map();
-    this.creating = new Map();
-    this.closed = false;
-  }
-
-  activeProjects() {
-    return new Set(this.entries.keys());
-  }
-
-  async call(projectPath, toolName, args, signal) {
-    const entry = await this.#get(projectPath);
-    entry.busy += 1;
-    clearTimeout(entry.idleTimer);
-    try {
-      return await entry.peer.request("tools/call", { name: toolName, arguments: args }, { signal, timeoutMs: this.settings.requestTimeoutMs });
-    } catch (error) {
-      if (error?.name === "AbortError" || error?.code === "ETIMEDOUT") await this.closeProject(projectPath, error);
-      throw error;
-    } finally {
-      entry.busy -= 1;
-      entry.lastUsed = Date.now();
-      if (this.entries.get(projectPath) === entry) this.#scheduleIdle(entry);
-    }
-  }
-
-  async #get(projectPath) {
-    if (this.closed) throw new Error("CodeGraph worker pool is closed");
-    const existing = this.entries.get(projectPath);
-    if (existing) return existing;
-    const pending = this.creating.get(projectPath);
-    if (pending) return pending;
-    const creation = this.#create(projectPath).finally(() => this.creating.delete(projectPath));
-    this.creating.set(projectPath, creation);
-    return creation;
-  }
-
-  async #create(projectPath) {
-    await this.#evictForCapacity();
-    const launch = await resolveCodeGraphLaunch(this.settings, ["serve", "--mcp", "--path", projectPath]);
-    const child = spawn(launch.command, launch.args, { cwd: projectPath, env: process.env, stdio: ["pipe", "pipe", "pipe"] });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => { stderr = `${stderr}${chunk.toString("utf8")}`.slice(-8_000); });
-    const peer = new JsonRpcPeer(child.stdout, child.stdin, { name: `CodeGraph worker (${projectPath})` });
-    const entry = { projectPath, child, peer, busy: 0, lastUsed: Date.now(), idleTimer: undefined };
-    const onExit = (code) => {
-      const diagnostic = sanitizeDiagnostic(stderr) || `CodeGraph worker exited with code ${code}`;
-      peer.close(new Error(diagnostic));
-      if (this.entries.get(projectPath) === entry) this.entries.delete(projectPath);
-    };
-    child.on("error", (error) => peer.close(error));
-    child.on("exit", onExit);
-    try {
-      const rootUri = pathToFileURL(projectPath).href;
-      await peer.request("initialize", {
-        protocolVersion: "2024-11-05",
-        rootUri,
-        workspaceFolders: [{ uri: rootUri, name: projectPath.split(/[\\/]/).at(-1) || projectPath }],
-        capabilities: {},
-        clientInfo: { name: "pi-codegraph", version: "0.2.0" },
-      }, { timeoutMs: this.settings.requestTimeoutMs });
-      peer.notify("initialized", {});
-      this.entries.set(projectPath, entry);
-      this.#scheduleIdle(entry);
-      return entry;
-    } catch (error) {
-      child.kill();
-      peer.close(error);
-      throw error;
-    }
-  }
-
-  #scheduleIdle(entry) {
-    clearTimeout(entry.idleTimer);
-    if (entry.busy > 0) return;
-    entry.idleTimer = setTimeout(() => this.closeProject(entry.projectPath), this.settings.workerIdleTimeoutMs);
-    entry.idleTimer.unref?.();
-  }
-
-  async #evictForCapacity() {
-    if (this.entries.size < this.settings.maxWorkers) return;
-    const idle = [...this.entries.values()].filter((entry) => entry.busy === 0).sort((a, b) => a.lastUsed - b.lastUsed);
-    if (!idle.length) throw new Error(`CodeGraph worker limit reached (${this.settings.maxWorkers}); all workers are busy.`);
-    await this.closeProject(idle[0].projectPath);
-  }
-
-  async closeProject(projectPath, error = new Error("CodeGraph worker closed")) {
-    const entry = this.entries.get(projectPath);
-    if (!entry) return;
-    this.entries.delete(projectPath);
-    clearTimeout(entry.idleTimer);
-    entry.peer.close(error);
-    if (!entry.child.killed) entry.child.kill();
-  }
-
-  async close() {
-    this.closed = true;
-    await Promise.all([...this.entries.keys()].map((projectPath) => this.closeProject(projectPath)));
-  }
-}