@graphpilot-oss/graphpilot 0.0.1 → 0.1.0

package/scripts/smoke-stdio.mjs

@@ -1,97 +0,0 @@
-#!/usr/bin/env node
-// Spawns the MCP server over stdio exactly like Claude Code would, sends
-// initialize -> notifications/initialized -> tools/list -> tools/call, and
-// prints every response. Exits non-zero on protocol failure or timeout.
-
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const here = dirname(fileURLToPath(import.meta.url));
-const cli = join(here, '..', 'dist', 'cli.js');
-
-const proc = spawn('node', [cli, 'mcp'], {
-  stdio: ['pipe', 'pipe', 'pipe'],
-});
-
-let stderr = '';
-proc.stderr.on('data', (d) => (stderr += d.toString()));
-
-const replies = [];
-let buffer = '';
-proc.stdout.on('data', (chunk) => {
-  buffer += chunk.toString();
-  // MCP stdio framing is newline-delimited JSON.
-  const lines = buffer.split('\n');
-  buffer = lines.pop() ?? '';
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      replies.push(JSON.parse(trimmed));
-    } catch {
-      console.error('parse error on line:', JSON.stringify(trimmed));
-    }
-  }
-});
-
-let nextId = 1;
-function send(method, params) {
-  const isNotif = method.startsWith('notifications/');
-  const msg = isNotif
-    ? { jsonrpc: '2.0', method, params }
-    : { jsonrpc: '2.0', id: nextId++, method, params };
-  proc.stdin.write(JSON.stringify(msg) + '\n');
-}
-
-const TIMEOUT_MS = 5000;
-async function awaitReplyCount(n) {
-  const deadline = Date.now() + TIMEOUT_MS;
-  while (replies.length < n) {
-    if (Date.now() > deadline) {
-      throw new Error(
-        `Timed out waiting for ${n} replies (got ${replies.length}). ` + `STDERR was:\n${stderr}`,
-      );
-    }
-    await new Promise((r) => setTimeout(r, 50));
-  }
-}
-
-(async () => {
-  // 1. initialize
-  send('initialize', {
-    protocolVersion: '2024-11-05',
-    capabilities: {},
-    clientInfo: { name: 'graphpilot-smoke', version: '0.0.0' },
-  });
-  await awaitReplyCount(1);
-  const init = replies[0];
-  console.log('✓ initialize:', JSON.stringify(init.result?.serverInfo));
-
-  // 2. initialized notification (no reply expected)
-  send('notifications/initialized', {});
-
-  // 3. tools/list
-  send('tools/list', {});
-  await awaitReplyCount(2);
-  const list = replies[1];
-  const names = (list.result?.tools ?? []).map((t) => t.name).sort();
-  console.log('✓ tools/list:', names.join(', '));
-
-  // 4. tools/call gp_stats on cwd (no index expected — should return isError)
-  send('tools/call', { name: 'gp_stats', arguments: { path: process.cwd() } });
-  await awaitReplyCount(3);
-  const call = replies[2];
-  console.log('✓ tools/call gp_stats. isError=', call.result?.isError);
-  const firstText = call.result?.content?.[0]?.text ?? '<no text>';
-  console.log('  first line:', firstText.split('\n')[0]);
-
-  proc.stdin.end();
-  await new Promise((r) => proc.once('exit', r));
-  console.log('✓ server exited cleanly after stdin close');
-  process.exit(0);
-})().catch((err) => {
-  console.error('SMOKE FAIL:', err.message);
-  proc.kill('SIGKILL');
-  process.exit(1);
-});

package/src/cli.ts

@@ -1,171 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from 'node:path';
-import { indexDirectory } from './indexer.js';
-import { saveGraph, loadGraph, graphPath, repoIdFor, type Graph } from './storage.js';
-import { validateRootPath } from './validation.js';
-import { startMcpServer } from './mcp.js';
-import { GraphWatcher } from './watcher.js';
-import { resolveIndexRoot } from './git.js';
-
-const HELP = `graphpilot — structural memory for coding agents
-
-Usage:
-  graphpilot index <path>     Index a TypeScript/JavaScript repo
-  graphpilot status <path>    Show info about an indexed repo
-  graphpilot watch <path>     Watch the repo and update the index on save
-  graphpilot mcp              Start the MCP server (stdio)
-  graphpilot help             Show this help
-
-Examples:
-  graphpilot index .
-  graphpilot status .
-  graphpilot watch .          # keeps the index fresh as you edit
-  graphpilot mcp              # used by MCP clients (Claude Code, Cursor, ...)
-`;
-
-async function cmdIndex(pathArg: string, opts: { noWorktree?: boolean } = {}): Promise<number> {
-  const requested = resolve(pathArg);
-  // Worktree-scope: by default, if the user pointed inside a git worktree
-  // we re-root to the worktree top so the index covers the full branch.
-  // Pass --no-worktree to disable.
-  const { root: absRoot, redirected } = resolveIndexRoot(requested, { disable: opts.noWorktree });
-  if (redirected) {
-    process.stdout.write(
-      `[graphpilot] Re-rooting index to git worktree top: ${absRoot}\n` +
-        `             (Pass --no-worktree to index ${requested} directly.)\n`,
-    );
-  }
-  // T10 defence: refuse `/`, `/etc`, `~`, and friends before walking.
-  const refusal = validateRootPath(absRoot);
-  if (refusal) {
-    process.stderr.write(`Error: ${refusal}\n`);
-    return 2;
-  }
-  process.stdout.write(`Indexing ${absRoot} ...\n`);
-  const result = await indexDirectory(absRoot);
-  const graph: Graph = {
-    version: 1,
-    repoId: repoIdFor(absRoot),
-    rootPath: absRoot,
-    indexedAt: new Date().toISOString(),
-    filesIndexed: result.filesIndexed,
-    symbolCount: result.symbols.length,
-    edgeCount: result.edges.length,
-    symbols: result.symbols,
-    edges: result.edges,
-    indexedSha: result.git.sha,
-    indexedBranch: result.git.branch,
-  };
-  const saved = saveGraph(graph);
-  const resolved = result.edges.filter((e) => e.toId !== null).length;
-  // Build the git stamp line lazily — only printed when we're in a git repo.
-  let gitLine = '';
-  if (result.git.shortSha || result.git.branch) {
-    const parts: string[] = [];
-    if (result.git.branch) parts.push(`branch ${result.git.branch}`);
-    if (result.git.shortSha) parts.push(`sha ${result.git.shortSha}`);
-    gitLine = `  Git:        ${parts.join(' @ ')}\n`;
-  }
-  process.stdout.write(
-    `\n✓ Remembered ${result.symbols.length} symbols, ${result.edges.length} calls ` +
-      `(${resolved} resolved) across ${result.filesIndexed} files in ${result.durationMs}ms.\n` +
-      `  Repo id:    ${graph.repoId}\n` +
-      gitLine +
-      `  Graph file: ${saved}\n` +
-      (result.filesFailed ? `  Failed:     ${result.filesFailed} file(s)\n` : ''),
-  );
-  return 0;
-}
-
-function cmdStatus(pathArg: string): number {
-  const absRoot = resolve(pathArg);
-  const graph = loadGraph(absRoot);
-  if (!graph) {
-    process.stderr.write(`No index found for ${absRoot}\n` + `Run: graphpilot index ${pathArg}\n`);
-    return 1;
-  }
-  // Compose a git line if the indexed repo had provenance at the time.
-  let gitLine = '';
-  if (graph.indexedSha || graph.indexedBranch) {
-    const parts: string[] = [];
-    if (graph.indexedBranch) parts.push(`branch ${graph.indexedBranch}`);
-    if (graph.indexedSha) parts.push(`sha ${graph.indexedSha.slice(0, 7)}`);
-    gitLine = `Git:          ${parts.join(' @ ')}\n`;
-  }
-  process.stdout.write(
-    `Repo id:      ${graph.repoId}\n` +
-      `Root:         ${graph.rootPath}\n` +
-      `Indexed at:   ${graph.indexedAt}\n` +
-      gitLine +
-      `Files:        ${graph.filesIndexed}\n` +
-      `Symbols:      ${graph.symbolCount}\n` +
-      `Calls:        ${graph.edgeCount ?? 0}\n` +
-      `Graph file:   ${graphPath(absRoot)}\n`,
-  );
-  return 0;
-}
-
-async function main(): Promise<number> {
-  const [, , cmd, ...rest] = process.argv;
-  switch (cmd) {
-    case 'index': {
-      const noWorktree = rest.includes('--no-worktree');
-      const path = rest.find((a) => !a.startsWith('--')) ?? '.';
-      return cmdIndex(path, { noWorktree });
-    }
-    case 'status': {
-      const path = rest[0] ?? '.';
-      return cmdStatus(path);
-    }
-    case 'mcp': {
-      // Server runs until stdin closes (MCP client disconnect). Never
-      // returns under normal operation.
-      await startMcpServer();
-      return 0;
-    }
-    case 'watch': {
-      const noWorktree = rest.includes('--no-worktree');
-      const path = rest.find((a) => !a.startsWith('--')) ?? '.';
-      const requested = resolve(path);
-      const { root: absRoot, redirected } = resolveIndexRoot(requested, { disable: noWorktree });
-      if (redirected) {
-        process.stderr.write(`[graphpilot:watch] Re-rooting to worktree top: ${absRoot}\n`);
-      }
-      const refusal = validateRootPath(absRoot);
-      if (refusal) {
-        process.stderr.write(`Error: ${refusal}\n`);
-        return 2;
-      }
-      const watcher = new GraphWatcher(absRoot);
-      await watcher.start();
-      process.stderr.write(`[graphpilot:watch] Ctrl+C to stop.\n`);
-      // Hold the process open until SIGINT or stdin EOF.
-      await new Promise<void>((res) => {
-        const finish = (): void => res();
-        process.once('SIGINT', finish);
-        process.once('SIGTERM', finish);
-        process.stdin.once('end', finish);
-        process.stdin.once('close', finish);
-      });
-      await watcher.stop();
-      return 0;
-    }
-    case 'help':
-    case '--help':
-    case '-h':
-    case undefined:
-      process.stdout.write(HELP);
-      return 0;
-    default:
-      process.stderr.write(`Unknown command: ${cmd}\n\n${HELP}`);
-      return 2;
-  }
-}
-
-main().then(
-  (code) => process.exit(code),
-  (err) => {
-    process.stderr.write(`Error: ${err?.stack ?? err}\n`);
-    process.exit(1);
-  },
-);

package/src/edges.ts

@@ -1,202 +0,0 @@
-import type Parser from 'tree-sitter';
-import { walk, type ParsedFile } from './parser.js';
-import type { SymbolRecord } from './symbols.js';
-
-/**
- * A resolved call edge.
- *
- * `toId` is null when the call's target couldn't be resolved to a known symbol
- * (e.g. it's a stdlib call like `Array.from`, a third-party import, or a
- * dynamic dispatch we don't track in v1). `toName` is always set, so the agent
- * still knows what was called.
- */
-export interface CallEdge {
-  fromId: string;
-  toId: string | null;
-  toName: string;
-  file: string;
-  line: number;
-  column: number;
-}
-
-/**
- * A pre-resolution call site. Same shape as CallEdge minus `toId`. Used during
- * indexing before we have the full symbol table.
- */
-export interface RawCall {
-  fromId: string;
-  toName: string;
-  file: string;
-  line: number;
-  column: number;
-}
-
-const FUNCTION_NODE_TYPES = new Set([
-  'function_declaration',
-  'generator_function_declaration',
-  'function_expression',
-  'arrow_function',
-  'method_definition',
-]);
-
-/**
- * Walk a function body, but stop descending into nested function definitions.
- * This way a call inside `(_ => foo())` placed inside `outer()` is attributed
- * to the arrow, not to `outer`. (When the arrow itself has a SymbolRecord —
- * because it was assigned to a const — we'll visit it separately.)
- */
-function* walkBodyExcludingNestedFns(rootNode: Parser.SyntaxNode): Generator<Parser.SyntaxNode> {
-  const stack: { node: Parser.SyntaxNode; isRoot: boolean }[] = [{ node: rootNode, isRoot: true }];
-  while (stack.length > 0) {
-    const { node, isRoot } = stack.pop()!;
-    if (!isRoot && FUNCTION_NODE_TYPES.has(node.type)) continue;
-    yield node;
-    for (let i = node.childCount - 1; i >= 0; i--) {
-      const child = node.child(i);
-      if (child) stack.push({ node: child, isRoot: false });
-    }
-  }
-}
-
-/**
- * Extract the callee name from a `call_expression` or `new_expression` node.
- * Returns null for dynamic forms we don't try to resolve in v1.
- *
- * Examples handled:
- *   foo()                  -> "foo"
- *   obj.method()           -> "method"
- *   this.helper()          -> "helper"
- *   new Foo()              -> "Foo"
- *
- * Examples not handled (returns null):
- *   arr[x]()
- *   (function(){})()
- *   func.call(this, ...)   (we'd just see "call", which is fine — it's a
- *                           known limitation. Agent can still find the call.)
- */
-function calleeName(callNode: Parser.SyntaxNode): string | null {
-  const fnField =
-    callNode.childForFieldName('function') ?? callNode.childForFieldName('constructor');
-  if (!fnField) return null;
-  if (fnField.type === 'identifier' || fnField.type === 'type_identifier') {
-    return fnField.text;
-  }
-  if (fnField.type === 'member_expression') {
-    const prop = fnField.childForFieldName('property');
-    return prop?.text ?? null;
-  }
-  return null;
-}
-
-/**
- * Match the AST node a SymbolRecord was extracted from. We use line+name as
- * the key; collisions are vanishingly rare (would need two same-named symbols
- * on the same line, which TS would reject).
- */
-function nodeMatchKey(node: Parser.SyntaxNode): string | null {
-  if (
-    node.type === 'function_declaration' ||
-    node.type === 'generator_function_declaration' ||
-    node.type === 'method_definition'
-  ) {
-    const name = node.childForFieldName('name')?.text;
-    if (!name) return null;
-    return `${node.startPosition.row + 1}:${name}`;
-  }
-  if (node.type === 'arrow_function' || node.type === 'function_expression') {
-    // We stored these under their variable name; the variable_declarator is
-    // the parent we need. The declarator's startLine matches the SymbolRecord
-    // line (we record the declarator, not the value).
-    const parent = node.parent;
-    if (parent?.type === 'variable_declarator') {
-      const name = parent.childForFieldName('name')?.text;
-      if (!name) return null;
-      return `${parent.startPosition.row + 1}:${name}`;
-    }
-  }
-  return null;
-}
-
-/**
- * For every function-like symbol in `fileSymbols`, walk its body and emit a
- * RawCall for every call/new expression directly inside it.
- *
- * Returns calls keyed by *line+name lookup* so resolution can happen later.
- */
-export function extractRawCalls(parsed: ParsedFile, fileSymbols: SymbolRecord[]): RawCall[] {
-  const calls: RawCall[] = [];
-
-  // Index symbols by line:name so we can match an AST node back to its record.
-  const symByKey = new Map<string, SymbolRecord>();
-  for (const s of fileSymbols) {
-    symByKey.set(`${s.line}:${s.name}`, s);
-  }
-
-  for (const node of walk(parsed.tree.rootNode)) {
-    if (!FUNCTION_NODE_TYPES.has(node.type)) continue;
-    const key = nodeMatchKey(node);
-    if (!key) continue;
-    const sym = symByKey.get(key);
-    if (!sym) continue;
-
-    const body = node.childForFieldName('body');
-    if (!body) continue;
-
-    for (const sub of walkBodyExcludingNestedFns(body)) {
-      if (sub.type !== 'call_expression' && sub.type !== 'new_expression') {
-        continue;
-      }
-      const name = calleeName(sub);
-      if (!name) continue;
-      calls.push({
-        fromId: sym.id,
-        toName: name,
-        file: parsed.path,
-        line: sub.startPosition.row + 1,
-        column: sub.startPosition.column + 1,
-      });
-    }
-  }
-
-  return calls;
-}
-
-/**
- * Second-pass resolver. Given the full symbol table and a list of raw calls,
- * fill in `toId` where the callee name matches a known symbol.
- *
- * Resolution strategy (v1 — deliberately dumb):
- *   1. Prefer a symbol with the same name in the same file (likely the right one)
- *   2. Otherwise pick any symbol with that name (first match — non-deterministic
- *      across reruns of ambiguous names, but stable within a single index)
- *   3. Otherwise leave toId null
- *
- * Known limitations (documented as v1 caveats):
- *   - No import resolution: if `parseToken` is imported from another file we'll
- *     still find it globally, but if two files both export `parseToken` we may
- *     pick the wrong one.
- *   - No method-of-class disambiguation: `obj.method()` resolves to the first
- *     symbol named `method`, regardless of receiver type.
- *   - No re-export chains.
- *
- * These are fine for v1; the goal is "better than grep" not "compiler-grade".
- */
-export function resolveCallEdges(rawCalls: RawCall[], allSymbols: SymbolRecord[]): CallEdge[] {
-  const byName = new Map<string, SymbolRecord[]>();
-  for (const s of allSymbols) {
-    const list = byName.get(s.name);
-    if (list) list.push(s);
-    else byName.set(s.name, [s]);
-  }
-
-  return rawCalls.map((c) => {
-    const candidates = byName.get(c.toName);
-    if (!candidates || candidates.length === 0) {
-      return { ...c, toId: null };
-    }
-    // Prefer same-file candidates first.
-    const sameFile = candidates.find((s) => s.file === c.file);
-    if (sameFile) return { ...c, toId: sameFile.id };
-    return { ...c, toId: candidates[0].id };
-  });
-}