@graphpilot-oss/graphpilot 0.0.1 → 1.0.0

package/src/symbols.ts

@@ -1,173 +0,0 @@
-import type Parser from 'tree-sitter';
-import { walk, type ParsedFile } from './parser.js';
-import { redactSecrets } from './redact.js';
-
-export type SymbolKind =
-  | 'function'
-  | 'class'
-  | 'method'
-  | 'interface'
-  | 'type'
-  | 'variable'
-  | 'enum';
-
-export interface SymbolRecord {
-  id: string;
-  name: string;
-  kind: SymbolKind;
-  file: string;
-  line: number;
-  column: number;
-  endLine: number;
-  signature: string;
-  exported: boolean;
-  parent?: string;
-}
-
-/**
- * Extract every symbol-defining node from a parsed file.
- * v1 covers: function decls, arrow/function-expr consts, classes, methods,
- * interfaces, type aliases, enums.
- */
-export function extractSymbols(parsed: ParsedFile): SymbolRecord[] {
-  const out: SymbolRecord[] = [];
-  for (const node of walk(parsed.tree.rootNode)) {
-    extractFromNode(node, parsed, out);
-  }
-  return out;
-}
-
-function extractFromNode(node: Parser.SyntaxNode, parsed: ParsedFile, out: SymbolRecord[]): void {
-  switch (node.type) {
-    case 'function_declaration':
-    case 'generator_function_declaration': {
-      const name = node.childForFieldName('name')?.text;
-      if (!name) return;
-      out.push(record(node, parsed, name, 'function'));
-      return;
-    }
-    case 'class_declaration': {
-      const name = node.childForFieldName('name')?.text;
-      if (!name) return;
-      out.push(record(node, parsed, name, 'class'));
-      extractClassMembers(node, parsed, name, out);
-      return;
-    }
-    case 'interface_declaration': {
-      const name = node.childForFieldName('name')?.text;
-      if (!name) return;
-      out.push(record(node, parsed, name, 'interface'));
-      return;
-    }
-    case 'type_alias_declaration': {
-      const name = node.childForFieldName('name')?.text;
-      if (!name) return;
-      out.push(record(node, parsed, name, 'type'));
-      return;
-    }
-    case 'enum_declaration': {
-      const name = node.childForFieldName('name')?.text;
-      if (!name) return;
-      out.push(record(node, parsed, name, 'enum'));
-      return;
-    }
-    case 'variable_declarator': {
-      // Only emit if value is a function-like (matches Day-2 listFunctions logic).
-      const valueNode = node.childForFieldName('value');
-      if (
-        !valueNode ||
-        !(
-          valueNode.type === 'arrow_function' ||
-          valueNode.type === 'function_expression' ||
-          valueNode.type === 'function'
-        )
-      ) {
-        return;
-      }
-      const name = node.childForFieldName('name')?.text;
-      if (!name) return;
-      out.push(record(node, parsed, name, 'variable'));
-      return;
-    }
-    default:
-      return;
-  }
-}
-
-function extractClassMembers(
-  classNode: Parser.SyntaxNode,
-  parsed: ParsedFile,
-  className: string,
-  out: SymbolRecord[],
-): void {
-  const body = classNode.childForFieldName('body');
-  if (!body) return;
-  for (let i = 0; i < body.childCount; i++) {
-    const member = body.child(i);
-    if (!member) continue;
-    if (member.type === 'method_definition' || member.type === 'method_signature') {
-      const name = member.childForFieldName('name')?.text;
-      if (!name) continue;
-      out.push(record(member, parsed, name, 'method', className));
-    }
-  }
-}
-
-function record(
-  node: Parser.SyntaxNode,
-  parsed: ParsedFile,
-  name: string,
-  kind: SymbolKind,
-  parent?: string,
-): SymbolRecord {
-  const line = node.startPosition.row + 1;
-  const column = node.startPosition.column + 1;
-  const endLine = node.endPosition.row + 1;
-  const signature = oneLineSignature(node, parsed.source);
-  const exported = isExported(node);
-  const id = `${parsed.path}#${parent ? parent + '.' : ''}${name}@${line}`;
-  return {
-    id,
-    name,
-    kind,
-    file: parsed.path,
-    line,
-    column,
-    endLine,
-    signature,
-    exported,
-    parent,
-  };
-}
-
-/**
- * Extract a single-line signature from the node. Takes the first line of
- * text up to the body/value, capped at 200 chars. Secrets matching known
- * patterns (T3 defence) are redacted before the line is returned.
- */
-function oneLineSignature(node: Parser.SyntaxNode, source: string): string {
-  // For variable_declarator, climb to the parent lexical/var declaration so we
-  // capture "export const foo = ..." rather than just "foo = ...".
-  let target: Parser.SyntaxNode = node;
-  if (node.type === 'variable_declarator' && node.parent) {
-    target = node.parent;
-  }
-  const raw = source.slice(target.startIndex, target.endIndex);
-  const firstLine = raw.split('\n')[0].trim();
-  const capped = firstLine.length > 200 ? firstLine.slice(0, 197) + '...' : firstLine;
-  // T3: redact known-format secrets (API keys, tokens, JWTs, PEM headers).
-  return redactSecrets(capped);
-}
-
-/**
- * A node is exported if it (or an ancestor variable/lexical decl) is wrapped
- * in an `export_statement`.
- */
-function isExported(node: Parser.SyntaxNode): boolean {
-  let cur: Parser.SyntaxNode | null = node;
-  while (cur) {
-    if (cur.type === 'export_statement') return true;
-    cur = cur.parent;
-  }
-  return false;
-}

package/src/validation.ts

@@ -1,69 +0,0 @@
-import { realpathSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-
-/** Max bytes per source file we will read. Anything larger is skipped. */
-export const MAX_FILE_BYTES = 5 * 1024 * 1024; // 5 MB
-
-/** Max number of files we will index in one run. Hard fail above this. */
-export const MAX_FILES_PER_INDEX = 50_000;
-
-/**
- * System paths we refuse to index. Indexing these by accident would walk the
- * whole machine, fill disk, and leak system files into ~/.graphpilot/.
- *
- * Each entry must match the *realpath* form (after `fs.realpathSync`). macOS
- * symlinks /etc, /var, /tmp to /private/*, so we include both forms here.
- */
-const DANGEROUS_PATHS = new Set([
-  '/',
-  '/bin',
-  '/sbin',
-  '/usr',
-  '/usr/bin',
-  '/usr/local',
-  '/etc',
-  '/var',
-  '/tmp',
-  '/private',
-  '/private/etc',
-  '/private/var',
-  '/private/tmp',
-  '/Library',
-  '/System',
-  '/Applications',
-  '/Volumes',
-  '/Users',
-  '/home',
-  'C:\\Windows',
-  'C:\\Windows\\System32',
-  'C:\\Program Files',
-  'C:\\Program Files (x86)',
-]);
-
-/**
- * Returns null if the path is safe to index, or a human-readable reason string
- * if it should be refused.
- */
-export function validateRootPath(rawPath: string): string | null {
-  const abs = resolve(rawPath);
-
-  let real: string;
-  try {
-    real = realpathSync(abs);
-  } catch {
-    return `Path does not exist or is not accessible: ${abs}`;
-  }
-
-  // Reject any bare Windows drive root (C:\, D:\, etc.) — not just C:\
-  if (process.platform === 'win32' && /^[A-Za-z]:\\?$/.test(real)) {
-    return `Refusing to index system path: ${real}`;
-  }
-  if (DANGEROUS_PATHS.has(real)) {
-    return `Refusing to index system path: ${real}`;
-  }
-  if (real === homedir()) {
-    return `Refusing to index your home directory directly (${real}). Pass a specific project subdirectory instead.`;
-  }
-  return null;
-}

package/src/validators.ts

@@ -1,253 +0,0 @@
-/**
- * Hand-rolled validation for MCP tool inputs. No external deps — three tools,
- * each with a handful of fields, makes a library overkill.
- *
- * Every tool validator returns a tagged result:
- *   { ok: true,  value: <typed args> }
- *   { ok: false, error: <human-readable> }
- *
- * Rules (defence-in-depth — JSON schema is declared in the tool catalog
- * too; this is the second wall):
- *   - Reject extra unknown keys (defends against agent typos & tampering)
- *   - Type-check every field
- *   - Range-check numbers (limit is bounded, no NaN)
- *   - Length-cap strings (no 10MB symbol names)
- *   - Strict enums (no surprise direction values)
- */
-
-export type Result<T> = { ok: true; value: T } | { ok: false; error: string };
-
-function ok<T>(value: T): Result<T> {
-  return { ok: true, value };
-}
-function fail<T>(error: string): Result<T> {
-  return { ok: false, error };
-}
-
-function isPlainObject(x: unknown): x is Record<string, unknown> {
-  return typeof x === 'object' && x !== null && !Array.isArray(x);
-}
-
-const MAX_STRING_LEN = 2_000;
-
-function pickString(
-  obj: Record<string, unknown>,
-  key: string,
-  opts: { required?: boolean; max?: number } = {},
-): Result<string | undefined> {
-  const raw = obj[key];
-  if (raw === undefined) {
-    if (opts.required) return fail(`Missing required field: ${key}`);
-    return ok(undefined);
-  }
-  if (typeof raw !== 'string') return fail(`${key} must be a string`);
-  const max = opts.max ?? MAX_STRING_LEN;
-  if (raw.length > max) return fail(`${key} exceeds max length of ${max}`);
-  return ok(raw);
-}
-
-function pickNumber(
-  obj: Record<string, unknown>,
-  key: string,
-  opts: { min?: number; max?: number; integer?: boolean } = {},
-): Result<number | undefined> {
-  const raw = obj[key];
-  if (raw === undefined) return ok(undefined);
-  if (typeof raw !== 'number' || !Number.isFinite(raw)) {
-    return fail(`${key} must be a finite number`);
-  }
-  if (opts.integer && !Number.isInteger(raw)) {
-    return fail(`${key} must be an integer`);
-  }
-  if (opts.min !== undefined && raw < opts.min) {
-    return fail(`${key} must be >= ${opts.min}`);
-  }
-  if (opts.max !== undefined && raw > opts.max) {
-    return fail(`${key} must be <= ${opts.max}`);
-  }
-  return ok(raw);
-}
-
-function pickBoolean(obj: Record<string, unknown>, key: string): Result<boolean | undefined> {
-  const raw = obj[key];
-  if (raw === undefined) return ok(undefined);
-  if (typeof raw !== 'boolean') return fail(`${key} must be a boolean`);
-  return ok(raw);
-}
-
-function pickEnum<T extends string>(
-  obj: Record<string, unknown>,
-  key: string,
-  allowed: readonly T[],
-): Result<T | undefined> {
-  const raw = obj[key];
-  if (raw === undefined) return ok(undefined);
-  if (typeof raw !== 'string' || !(allowed as readonly string[]).includes(raw)) {
-    return fail(`${key} must be one of: ${allowed.join(', ')}`);
-  }
-  return ok(raw as T);
-}
-
-function rejectExtraKeys(obj: Record<string, unknown>, allowed: readonly string[]): Result<true> {
-  const extras = Object.keys(obj).filter((k) => !allowed.includes(k));
-  if (extras.length > 0) {
-    return fail(`Unknown field(s): ${extras.join(', ')}. Allowed: ${allowed.join(', ')}`);
-  }
-  return ok(true);
-}
-
-// ----------------------------------------------------------------------------
-// Per-tool validators
-// ----------------------------------------------------------------------------
-
-export interface GpIndexArgs {
-  path?: string;
-}
-const GP_INDEX_KEYS = ['path'] as const;
-
-export function validateGpIndex(input: unknown): Result<GpIndexArgs> {
-  if (!isPlainObject(input)) return fail('arguments must be an object');
-  const extras = rejectExtraKeys(input, GP_INDEX_KEYS);
-  if (!extras.ok) return fail(extras.error);
-  const path = pickString(input, 'path', { max: 1024 });
-  if (!path.ok) return fail(path.error);
-  return ok({ path: path.value });
-}
-
-export interface GpRecallArgs {
-  query: string;
-  limit?: number;
-  substring?: boolean;
-  path?: string;
-}
-const GP_RECALL_KEYS = ['query', 'limit', 'substring', 'path'] as const;
-
-export function validateGpRecall(input: unknown): Result<GpRecallArgs> {
-  if (!isPlainObject(input)) return fail('arguments must be an object');
-  const extras = rejectExtraKeys(input, GP_RECALL_KEYS);
-  if (!extras.ok) return fail(extras.error);
-
-  const query = pickString(input, 'query', { required: true, max: 200 });
-  if (!query.ok) return fail(query.error);
-  if (!query.value || query.value.trim() === '') {
-    return fail('query must be a non-empty string');
-  }
-
-  const limit = pickNumber(input, 'limit', { min: 1, max: 50, integer: true });
-  if (!limit.ok) return fail(limit.error);
-
-  const substring = pickBoolean(input, 'substring');
-  if (!substring.ok) return fail(substring.error);
-
-  const path = pickString(input, 'path', { max: 1024 });
-  if (!path.ok) return fail(path.error);
-
-  return ok({
-    query: query.value,
-    limit: limit.value,
-    substring: substring.value,
-    path: path.value,
-  });
-}
-
-export type CallersDirection = 'callers' | 'callees';
-
-export interface GpCallersArgs {
-  symbol: string;
-  direction?: CallersDirection;
-  limit?: number;
-  includeUnresolved?: boolean;
-  path?: string;
-}
-const GP_CALLERS_KEYS = ['symbol', 'direction', 'limit', 'includeUnresolved', 'path'] as const;
-
-export function validateGpCallers(input: unknown): Result<GpCallersArgs> {
-  if (!isPlainObject(input)) return fail('arguments must be an object');
-  const extras = rejectExtraKeys(input, GP_CALLERS_KEYS);
-  if (!extras.ok) return fail(extras.error);
-
-  const symbol = pickString(input, 'symbol', { required: true, max: 500 });
-  if (!symbol.ok) return fail(symbol.error);
-  if (!symbol.value || symbol.value.trim() === '') {
-    return fail('symbol must be a non-empty string');
-  }
-
-  const direction = pickEnum(input, 'direction', ['callers', 'callees'] as const);
-  if (!direction.ok) return fail(direction.error);
-
-  const limit = pickNumber(input, 'limit', { min: 1, max: 100, integer: true });
-  if (!limit.ok) return fail(limit.error);
-
-  const includeUnresolved = pickBoolean(input, 'includeUnresolved');
-  if (!includeUnresolved.ok) return fail(includeUnresolved.error);
-
-  const path = pickString(input, 'path', { max: 1024 });
-  if (!path.ok) return fail(path.error);
-
-  return ok({
-    symbol: symbol.value,
-    direction: direction.value,
-    limit: limit.value,
-    includeUnresolved: includeUnresolved.value,
-    path: path.value,
-  });
-}
-
-// Tool name -> validator dispatcher (for the MCP server)
-export type ToolName = 'gp_index' | 'gp_recall' | 'gp_callers' | 'gp_impact' | 'gp_stats';
-
-export interface GpStatsArgs {
-  path?: string;
-}
-export function validateGpStats(input: unknown): Result<GpStatsArgs> {
-  if (!isPlainObject(input)) return fail('arguments must be an object');
-  const extras = rejectExtraKeys(input, ['path']);
-  if (!extras.ok) return fail(extras.error);
-  const path = pickString(input, 'path', { max: 1024 });
-  if (!path.ok) return fail(path.error);
-  return ok({ path: path.value });
-}
-
-export interface GpImpactArgs {
-  symbol: string;
-  depth?: number;
-  path?: string;
-  since?: string;
-}
-const GP_IMPACT_KEYS = ['symbol', 'depth', 'path', 'since'] as const;
-
-export function validateGpImpact(input: unknown): Result<GpImpactArgs> {
-  if (!isPlainObject(input)) return fail('arguments must be an object');
-  const extras = rejectExtraKeys(input, GP_IMPACT_KEYS);
-  if (!extras.ok) return fail(extras.error);
-
-  const symbol = pickString(input, 'symbol', { required: true, max: 500 });
-  if (!symbol.ok) return fail(symbol.error);
-  if (!symbol.value || symbol.value.trim() === '') {
-    return fail('symbol must be a non-empty string');
-  }
-
-  // BFS depth: hard-cap at 5. Deeper traversals explode in big repos and
-  // rarely add value — depth-3 already covers ~99% of real refactors.
-  const depth = pickNumber(input, 'depth', { min: 1, max: 5, integer: true });
-  if (!depth.ok) return fail(depth.error);
-
-  const path = pickString(input, 'path', { max: 1024 });
-  if (!path.ok) return fail(path.error);
-
-  // `since` accepts a commit SHA (full or short), tag, or branch name.
-  // Capped at 200 chars — refs are normally under 100, this is a sanity
-  // bound, not a security one (isomorphic-git handles ref resolution).
-  const since = pickString(input, 'since', { max: 200 });
-  if (!since.ok) return fail(since.error);
-  if (since.value !== undefined && since.value.trim() === '') {
-    return fail('since must be a non-empty string when provided');
-  }
-
-  return ok({
-    symbol: symbol.value,
-    depth: depth.value,
-    path: path.value,
-    since: since.value,
-  });
-}