@graphpilot-oss/graphpilot 0.0.1 → 0.1.0

package/tests/lint-policy.test.ts

@@ -1,106 +0,0 @@
-/**
- * Meta-tests for the ESLint policy (T12).
- *
- * These tests use the ESLint Node API to verify that:
- *   - A `src/` file importing a banned network module is flagged
- *   - A `src/` file importing child_process is flagged
- *   - The same imports in tests/ and scripts/ are allowed (they need to
- *     spawn subprocesses for the smoke runner / bench harness)
- *
- * Why this matters: a future PR could quietly relax the rule. CI would
- * still pass because no current src/ file imports banned modules. These
- * tests assert that the policy stays in force by feeding ESLint
- * adversarial sources and checking the verdict.
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import { ESLint } from 'eslint';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
-let eslint: ESLint;
-
-beforeAll(async () => {
-  eslint = new ESLint({ cwd: repoRoot });
-});
-
-// Helper: lint a synthetic file at a given (real) path with a given source.
-// The path is required so the flat-config file-pattern matchers fire.
-async function lintAs(filePath: string, source: string) {
-  const results = await eslint.lintText(source, { filePath });
-  return results[0];
-}
-
-describe('T12 — banned network imports in src/', () => {
-  const bannedNetwork = [
-    'http',
-    'https',
-    'node:http',
-    'node:https',
-    'undici',
-    'axios',
-    'node-fetch',
-    'cross-fetch',
-    'got',
-  ];
-
-  for (const mod of bannedNetwork) {
-    it(`flags "import ... from '${mod}'" inside src/`, async () => {
-      const result = await lintAs(
-        join(repoRoot, 'src', '_fake.ts'),
-        `import x from '${mod}';\nexport const v = x;\n`,
-      );
-      expect(result.errorCount).toBeGreaterThanOrEqual(1);
-      const restricted = result.messages.find((m) => m.ruleId === 'no-restricted-imports');
-      expect(restricted).toBeDefined();
-      expect(restricted!.message).toContain('No network code in src/');
-    });
-  }
-});
-
-describe('T6 — child_process banned in src/', () => {
-  for (const mod of ['child_process', 'node:child_process']) {
-    it(`flags "import ... from '${mod}'" inside src/`, async () => {
-      const result = await lintAs(
-        join(repoRoot, 'src', '_fake.ts'),
-        `import cp from '${mod}';\nexport const v = cp;\n`,
-      );
-      expect(result.errorCount).toBeGreaterThanOrEqual(1);
-      const restricted = result.messages.find((m) => m.ruleId === 'no-restricted-imports');
-      expect(restricted).toBeDefined();
-      expect(restricted!.message).toContain('No child_process in src/');
-    });
-  }
-});
-
-describe('Looser rules in tests/ and scripts/', () => {
-  it('allows child_process inside tests/ (subprocess test needs it)', async () => {
-    const result = await lintAs(
-      join(repoRoot, 'tests', '_fake.test.ts'),
-      `import cp from 'child_process';\nexport const v = cp;\n`,
-    );
-    const restricted = result.messages.find((m) => m.ruleId === 'no-restricted-imports');
-    expect(restricted).toBeUndefined();
-  });
-
-  it('allows child_process inside scripts/', async () => {
-    const result = await lintAs(
-      join(repoRoot, 'scripts', '_fake.mjs'),
-      `import cp from 'child_process';\nexport const v = cp;\n`,
-    );
-    const restricted = result.messages.find((m) => m.ruleId === 'no-restricted-imports');
-    expect(restricted).toBeUndefined();
-  });
-});
-
-describe('Normal imports in src/ pass clean', () => {
-  it('allows internal imports in src/', async () => {
-    const result = await lintAs(
-      join(repoRoot, 'src', '_fake.ts'),
-      `import { join } from 'node:path';\nexport const v = join('a', 'b');\n`,
-    );
-    const restricted = result.messages.find((m) => m.ruleId === 'no-restricted-imports');
-    expect(restricted).toBeUndefined();
-  });
-});

package/tests/mcp-stdio.test.ts

@@ -1,171 +0,0 @@
-/**
- * Real-subprocess test of the MCP server over stdio. The other mcp.test.ts
- * uses InMemoryTransport which would not have caught the
- * "process.exit() kills the server before initialize completes" regression
- * that bit us during Day-10 testing.
- *
- * Each test spawns `node dist/cli.js mcp`, drives it via JSON-RPC over its
- * stdin/stdout, and tears it down by closing stdin.
- */
-
-import { describe, it, expect } from 'vitest';
-import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { existsSync } from 'node:fs';
-
-const here = dirname(fileURLToPath(import.meta.url));
-const cli = join(here, '..', 'dist', 'cli.js');
-
-const isWindows = process.platform === 'win32';
-
-// These tests require the built artifact. Skip locally before the first
-// build; CI runs `pnpm build` before tests so this is fine there.
-const shouldSkip = !existsSync(cli) || isWindows;
-
-interface Driver {
-  proc: ChildProcessWithoutNullstreams;
-  send: (method: string, params?: unknown) => void;
-  awaitReplies: (n: number, timeoutMs?: number) => Promise<any[]>;
-  replies: any[];
-  stderr: string;
-  close: () => Promise<void>;
-}
-
-function spawnMcp(): Driver {
-  const proc = spawn('node', [cli, 'mcp'], {
-    stdio: ['pipe', 'pipe', 'pipe'],
-  }) as ChildProcessWithoutNullStreams;
-
-  const replies: any[] = [];
-  let stderr = '';
-  let buffer = '';
-
-  proc.stderr.on('data', (d: Buffer) => (stderr += d.toString()));
-  proc.stdout.on('data', (chunk: Buffer) => {
-    buffer += chunk.toString();
-    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 {
-        // ignore
-      }
-    }
-  });
-
-  let nextId = 1;
-  function send(method: string, params: unknown = {}) {
-    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');
-  }
-
-  async function awaitReplies(n: number, timeoutMs = 4000) {
-    const deadline = Date.now() + timeoutMs;
-    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, 20));
-    }
-    return replies.slice(0, n);
-  }
-
-  async function close() {
-    proc.stdin.end();
-    await new Promise<void>((resolve) => {
-      const t = setTimeout(() => {
-        proc.kill('SIGKILL');
-        resolve();
-      }, 1000);
-      proc.once('exit', () => {
-        clearTimeout(t);
-        resolve();
-      });
-    });
-  }
-
-  return {
-    proc,
-    send,
-    awaitReplies,
-    replies,
-    get stderr() {
-      return stderr;
-    },
-    close,
-  } as Driver;
-}
-
-describe.skipIf(shouldSkip)('MCP server over real stdio (subprocess)', () => {
-  it('responds to initialize within 4s', async () => {
-    const d = spawnMcp();
-    try {
-      d.send('initialize', {
-        protocolVersion: '2024-11-05',
-        capabilities: {},
-        clientInfo: { name: 'test', version: '0' },
-      });
-      const [init] = await d.awaitReplies(1);
-      expect(init.id).toBe(1);
-      expect(init.result?.serverInfo?.name).toBe('graphpilot');
-    } finally {
-      await d.close();
-    }
-  });
-
-  it('completes initialize → tools/list → tools/call without exiting', async () => {
-    const d = spawnMcp();
-    try {
-      d.send('initialize', {
-        protocolVersion: '2024-11-05',
-        capabilities: {},
-        clientInfo: { name: 'test', version: '0' },
-      });
-      await d.awaitReplies(1);
-      d.send('notifications/initialized');
-      d.send('tools/list');
-      const replies = await d.awaitReplies(2);
-      const list = replies[1];
-      const names = (list.result?.tools ?? []).map((t: any) => t.name).sort();
-      expect(names).toEqual(['gp_callers', 'gp_impact', 'gp_index', 'gp_recall', 'gp_stats']);
-
-      // Now call a tool — proves the process is still alive after tools/list
-      d.send('tools/call', {
-        name: 'gp_stats',
-        arguments: { path: '/tmp/graphpilot-definitely-not-indexed' },
-      });
-      const replies2 = await d.awaitReplies(3);
-      const call = replies2[2];
-      // We expect isError true (no index) but the IMPORTANT thing is that
-      // the server replied at all — i.e., didn't exit after initialize.
-      expect(call.result?.isError).toBe(true);
-    } finally {
-      await d.close();
-    }
-  });
-
-  it('exits cleanly when stdin closes', async () => {
-    const d = spawnMcp();
-    d.send('initialize', {
-      protocolVersion: '2024-11-05',
-      capabilities: {},
-      clientInfo: { name: 'test', version: '0' },
-    });
-    await d.awaitReplies(1);
-    d.proc.stdin.end();
-    const exitCode: number | null = await new Promise((resolve) => {
-      d.proc.once('exit', (code) => resolve(code));
-    });
-    // 0 or null are both acceptable (different platforms, different SIGPIPE behaviour)
-    expect(exitCode === 0 || exitCode === null).toBe(true);
-  });
-});

package/tests/mcp.test.ts

@@ -1,335 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { writeFileSync, mkdtempSync, rmSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
-import { buildMcpServer } from '../src/mcp.js';
-import { indexDirectory } from '../src/indexer.js';
-import { saveGraph, repoIdFor, type Graph } from '../src/storage.js';
-
-/**
- * End-to-end test: spin up the MCP server in-process, paired with an MCP
- * client over an in-memory transport. Exercises the full protocol path
- * (initialize -> tools/list -> tools/call) without spawning a subprocess.
- */
-
-let workDir: string;
-let client: Client;
-
-beforeAll(async () => {
-  // Make a tiny repo and index it so gp_stats has something to report.
-  workDir = mkdtempSync(join(tmpdir(), 'graphpilot-mcp-'));
-  writeFileSync(join(workDir, 'hello.ts'), 'export function hello() { return 1; }\n');
-  const result = await indexDirectory(workDir);
-  const graph: Graph = {
-    version: 1,
-    repoId: repoIdFor(workDir),
-    rootPath: workDir,
-    indexedAt: new Date().toISOString(),
-    filesIndexed: result.filesIndexed,
-    symbolCount: result.symbols.length,
-    edgeCount: result.edges.length,
-    symbols: result.symbols,
-    edges: result.edges,
-  };
-  saveGraph(graph);
-
-  // Wire client + server over an in-memory pipe.
-  const server = buildMcpServer();
-  const [serverTransport, clientTransport] = InMemoryTransport.createLinkedPair();
-  client = new Client({ name: 'graphpilot-test', version: '0.0.0' }, { capabilities: {} });
-  await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
-});
-
-afterAll(async () => {
-  await client?.close();
-  if (workDir && existsSync(workDir)) {
-    rmSync(workDir, { recursive: true, force: true });
-  }
-});
-
-describe('MCP server: protocol handshake + tool catalog', () => {
-  it('lists the v0.1 tools', async () => {
-    const { tools } = await client.listTools();
-    const names = tools.map((t) => t.name).sort();
-    expect(names).toEqual(['gp_callers', 'gp_impact', 'gp_index', 'gp_recall', 'gp_stats']);
-  });
-
-  it('every tool has a description and an object input schema', async () => {
-    const { tools } = await client.listTools();
-    for (const t of tools) {
-      expect(t.description?.length).toBeGreaterThan(20);
-      expect(t.inputSchema?.type).toBe('object');
-    }
-  });
-});
-
-describe('MCP server: gp_stats tool', () => {
-  it('returns index summary for a known repo', async () => {
-    const res = await client.callTool({
-      name: 'gp_stats',
-      arguments: { path: workDir },
-    });
-    expect(res.isError).not.toBe(true);
-    const text = (res.content as Array<{ type: string; text: string }>)
-      .filter((c) => c.type === 'text')
-      .map((c) => c.text)
-      .join('\n');
-    expect(text).toContain('Symbols:');
-    expect(text).toContain('Calls:');
-    expect(text).toContain(workDir);
-  });
-
-  it('returns a friendly error for an un-indexed path', async () => {
-    const fakePath = join(tmpdir(), `graphpilot-noindex-${Date.now()}`);
-    const res = await client.callTool({
-      name: 'gp_stats',
-      arguments: { path: fakePath },
-    });
-    expect(res.isError).toBe(true);
-    const text = (res.content as Array<{ type: string; text: string }>)
-      .map((c) => c.text)
-      .join('\n');
-    expect(text).toMatch(/No GraphPilot index/i);
-  });
-});
-
-describe('MCP server: unknown tool', () => {
-  it('responds with isError true for tools we did not register', async () => {
-    // Call a tool that doesn't exist. The SDK may either throw or surface an
-    // error in the response — we accept both shapes.
-    let caught = false;
-    let res: Awaited<ReturnType<Client['callTool']>> | null = null;
-    try {
-      res = await client.callTool({ name: 'gp_does_not_exist', arguments: {} });
-    } catch {
-      caught = true;
-    }
-    if (!caught) {
-      expect(res?.isError).toBe(true);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Day-9 tools
-// ---------------------------------------------------------------------------
-
-function textOf(res: Awaited<ReturnType<Client['callTool']>>): string {
-  return (res.content as Array<{ type: string; text: string }>)
-    .filter((c) => c.type === 'text')
-    .map((c) => c.text)
-    .join('\n');
-}
-
-describe('MCP server: gp_recall', () => {
-  it('finds the seeded symbol by name', async () => {
-    const res = await client.callTool({
-      name: 'gp_recall',
-      arguments: { query: 'hello', path: workDir },
-    });
-    expect(res.isError).not.toBe(true);
-    const text = textOf(res);
-    expect(text).toContain('hello');
-    expect(text).toContain('hello.ts');
-  });
-
-  it('handles "no match" gracefully', async () => {
-    const res = await client.callTool({
-      name: 'gp_recall',
-      arguments: { query: 'definitelyNotHere', path: workDir },
-    });
-    expect(res.isError).not.toBe(true);
-    expect(textOf(res)).toMatch(/no symbols match/i);
-  });
-
-  it('rejects empty queries', async () => {
-    const res = await client.callTool({
-      name: 'gp_recall',
-      arguments: { query: '', path: workDir },
-    });
-    expect(res.isError).toBe(true);
-    expect(textOf(res)).toMatch(/Invalid input/i);
-  });
-
-  it('rejects unknown fields', async () => {
-    const res = await client.callTool({
-      name: 'gp_recall',
-      arguments: { query: 'hello', shellOut: 'rm -rf', path: workDir },
-    });
-    expect(res.isError).toBe(true);
-    expect(textOf(res)).toMatch(/shellOut/);
-  });
-
-  it('rejects out-of-range limit', async () => {
-    const res = await client.callTool({
-      name: 'gp_recall',
-      arguments: { query: 'hello', limit: 9999, path: workDir },
-    });
-    expect(res.isError).toBe(true);
-  });
-});
-
-describe('MCP server: gp_callers', () => {
-  it('returns isError when the symbol is unknown', async () => {
-    const res = await client.callTool({
-      name: 'gp_callers',
-      arguments: { symbol: 'doesNotExist', path: workDir },
-    });
-    expect(res.isError).toBe(true);
-    expect(textOf(res)).toMatch(/no symbol found/i);
-  });
-
-  it('rejects invalid direction', async () => {
-    const res = await client.callTool({
-      name: 'gp_callers',
-      arguments: { symbol: 'hello', direction: 'sideways', path: workDir },
-    });
-    expect(res.isError).toBe(true);
-    expect(textOf(res)).toMatch(/direction/i);
-  });
-
-  it("returns 'no callers found' when target exists but nothing calls it", async () => {
-    const res = await client.callTool({
-      name: 'gp_callers',
-      arguments: { symbol: 'hello', direction: 'callers', path: workDir },
-    });
-    expect(res.isError).not.toBe(true);
-    expect(textOf(res)).toMatch(/no callers/i);
-  });
-});
-
-describe('MCP server: gp_index', () => {
-  it('re-indexes the repo end-to-end', async () => {
-    const res = await client.callTool({
-      name: 'gp_index',
-      arguments: { path: workDir },
-    });
-    expect(res.isError).not.toBe(true);
-    const text = textOf(res);
-    expect(text).toContain('Indexed');
-    expect(text).toContain('Files:');
-    expect(text).toContain('Symbols:');
-  });
-});
-
-describe('MCP server: gp_impact', () => {
-  // Build a richer fixture with a real caller chain so blast-radius output
-  // is non-trivial.
-  let impactDir: string;
-
-  beforeAll(async () => {
-    impactDir = mkdtempSync(join(tmpdir(), 'graphpilot-mcp-impact-'));
-    writeFileSync(
-      join(impactDir, 'auth.ts'),
-      `export function parseToken(t: string): string {\n` +
-        `  return t.trim();\n` +
-        `}\n` +
-        `\n` +
-        `export function authenticate(t: string): boolean {\n` +
-        `  return parseToken(t).length > 0;\n` +
-        `}\n`,
-    );
-    writeFileSync(
-      join(impactDir, 'api.ts'),
-      `import { parseToken } from './auth';\n` +
-        `\n` +
-        `export function handleLogin(t: string): string {\n` +
-        `  return parseToken(t);\n` +
-        `}\n`,
-    );
-    writeFileSync(
-      join(impactDir, 'auth.test.ts'),
-      `import { parseToken } from './auth';\n` +
-        `\n` +
-        `function testParse() {\n` +
-        `  return parseToken('x');\n` +
-        `}\n`,
-    );
-
-    const r = await indexDirectory(impactDir);
-    saveGraph({
-      version: 1,
-      repoId: repoIdFor(impactDir),
-      rootPath: impactDir,
-      indexedAt: new Date().toISOString(),
-      filesIndexed: r.filesIndexed,
-      symbolCount: r.symbols.length,
-      edgeCount: r.edges.length,
-      symbols: r.symbols,
-      edges: r.edges,
-    });
-  });
-
-  afterAll(() => {
-    if (impactDir && existsSync(impactDir)) {
-      rmSync(impactDir, { recursive: true, force: true });
-    }
-  });
-
-  it('returns isError when the symbol is unknown', async () => {
-    const res = await client.callTool({
-      name: 'gp_impact',
-      arguments: { symbol: 'doesNotExist', path: impactDir },
-    });
-    expect(res.isError).toBe(true);
-    expect(textOf(res)).toMatch(/no symbol found/i);
-  });
-
-  it('reports direct + transitive callers + public-API flag', async () => {
-    const res = await client.callTool({
-      name: 'gp_impact',
-      arguments: { symbol: 'parseToken', path: impactDir },
-    });
-    expect(res.isError).not.toBe(true);
-    const text = textOf(res);
-    // The target line
-    expect(text).toMatch(/Impact of changing parseToken/);
-    // Direct callers
-    expect(text).toMatch(/Direct callers/);
-    expect(text).toMatch(/authenticate/);
-    expect(text).toMatch(/handleLogin/);
-    // Test affected
-    expect(text).toMatch(/Tests likely affected/);
-    expect(text).toMatch(/auth\.test\.ts/);
-    // Public API
-    expect(text).toMatch(/Public API: YES/);
-    expect(text).toMatch(/BREAKING/i);
-    // Summary
-    expect(text).toMatch(/Summary:/);
-  });
-
-  it('respects the depth argument', async () => {
-    const res = await client.callTool({
-      name: 'gp_impact',
-      arguments: { symbol: 'parseToken', depth: 1, path: impactDir },
-    });
-    expect(res.isError).not.toBe(true);
-    // depth=1 should NOT include a Transitive section header
-    const text = textOf(res);
-    expect(text).toMatch(/Direct callers/);
-    expect(text).not.toMatch(/Transitive callers/);
-  });
-
-  it('rejects depth out of range', async () => {
-    const res = await client.callTool({
-      name: 'gp_impact',
-      arguments: { symbol: 'parseToken', depth: 99, path: impactDir },
-    });
-    expect(res.isError).toBe(true);
-  });
-
-  it('rejects unknown fields', async () => {
-    const res = await client.callTool({
-      name: 'gp_impact',
-      arguments: {
-        symbol: 'parseToken',
-        evilExtra: true,
-        path: impactDir,
-      },
-    });
-    expect(res.isError).toBe(true);
-    expect(textOf(res)).toMatch(/evilExtra/);
-  });
-});

package/tests/parser.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseFile, listFunctions } from '../src/parser.js';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const here = dirname(fileURLToPath(import.meta.url));
-const fixture = (name: string) => join(here, 'fixtures', name);
-
-describe('parser', () => {
-  it('parses a TypeScript file', () => {
-    const parsed = parseFile(fixture('sample.ts'));
-    expect(parsed).not.toBeNull();
-    expect(parsed!.lang).toBe('typescript');
-    expect(parsed!.tree.rootNode.type).toBe('program');
-  });
-
-  it('lists all function-like names in sample.ts', () => {
-    const parsed = parseFile(fixture('sample.ts'))!;
-    const names = listFunctions(parsed);
-    expect(names).toContain('parseToken');
-    expect(names).toContain('validateJwt');
-    expect(names).toContain('internalHelper');
-    expect(names).toContain('authenticate');
-    expect(names).toContain('fetchUser');
-  });
-
-  it('returns null for unsupported extensions', () => {
-    const parsed = parseFile(fixture('sample.ts').replace('.ts', '.txt'));
-    expect(parsed).toBeNull();
-  });
-});