project-graph-mcp 1.5.0 → 2.1.0

package/src/lang-sql.js

@@ -1,309 +0,0 @@
-/**
- * SQL Language Support for Project Graph
- *
- * Parses .sql files (schema dumps) and extracts SQL queries from code strings.
- * Provides table/column extraction via regex (zero-dependency, ~80% accuracy).
- */
-
-/**
- * @typedef {Object} TableInfo
- * @property {string} name - Table name
- * @property {{name: string, type: string}[]} columns - Column definitions
- * @property {string} file - Source file
- * @property {number} line - Line number
- */
-
-/**
- * @typedef {Object} SQLExtraction
- * @property {string[]} reads - Tables read (SELECT/FROM/JOIN)
- * @property {string[]} writes - Tables written (INSERT/UPDATE/DELETE)
- */
-
-/**
- * SQL keywords that should NOT be treated as table names.
- * Used to filter false positives from regex extraction.
- */
-const SQL_KEYWORDS = new Set([
-  'select', 'from', 'where', 'and', 'or', 'not', 'in', 'on',
-  'as', 'join', 'left', 'right', 'inner', 'outer', 'cross', 'full',
-  'group', 'order', 'by', 'having', 'limit', 'offset', 'union',
-  'all', 'distinct', 'case', 'when', 'then', 'else', 'end',
-  'null', 'true', 'false', 'is', 'between', 'like', 'ilike',
-  'exists', 'any', 'some', 'set', 'values', 'into', 'table',
-  'create', 'alter', 'drop', 'index', 'primary', 'key', 'foreign',
-  'references', 'constraint', 'default', 'check', 'unique',
-  'if', 'begin', 'commit', 'rollback', 'transaction',
-  'returning', 'conflict', 'nothing', 'do', 'update',
-  'cascade', 'restrict', 'lateral', 'each', 'row',
-  'with', 'recursive', 'only',
-  // PostgreSQL data types (prevent false positives)
-  'integer', 'int', 'bigint', 'smallint', 'serial', 'bigserial',
-  'text', 'varchar', 'char', 'character', 'boolean', 'bool',
-  'timestamp', 'timestamptz', 'date', 'time', 'timetz', 'interval',
-  'numeric', 'decimal', 'real', 'float', 'double',
-  'json', 'jsonb', 'uuid', 'bytea', 'inet', 'cidr', 'macaddr',
-  'array', 'point', 'line', 'box', 'circle', 'polygon', 'path',
-  // Common false positives
-  'count', 'sum', 'avg', 'min', 'max', 'coalesce', 'cast',
-  'extract', 'now', 'current_timestamp', 'current_date',
-  'generate_series', 'unnest', 'string_agg', 'array_agg',
-  'row_number', 'rank', 'dense_rank', 'over', 'partition',
-  'asc', 'desc', 'nulls', 'first', 'last', 'filter',
-  // PostgreSQL system/meta identifiers
-  'columns', 'rows', 'tables', 'schema', 'schemas',
-  'information_schema', 'pg_catalog', 'pg_tables', 'pg_class',
-]);
-
-/**
- * Check if a string looks like a SQL query.
- * Requires SQL keyword anchor at the start to minimize false positives.
- * @param {string} str
- * @returns {boolean}
- */
-export function isSQLString(str) {
-  if (!str || typeof str !== 'string') return false;
-  return /^\s*(SELECT|INSERT|UPDATE|DELETE|WITH|CREATE\s+TABLE)\b/i.test(str);
-}
-
-/**
- * Check if identifier is a valid table name (not a SQL keyword or too short).
- * @param {string} name
- * @returns {boolean}
- */
-function isValidTableName(name) {
-  if (!name || name.length < 2) return false;
-  if (SQL_KEYWORDS.has(name.toLowerCase())) return false;
-  // Must look like a valid identifier
-  if (!/^[a-zA-Z_]\w*$/.test(name)) return false;
-  // Reject ALL-UPPERCASE or PascalCase (real PG tables are snake_case/lowercase)
-  if (/^[A-Z][A-Z_]*$/.test(name)) return false;   // SKIP, API, etc.
-  if (/^[A-Z][a-z]/.test(name)) return false;       // Job, Organization, etc.
-  // Reject PostgreSQL built-in functions/types
-  if (/^(pg_|jsonb_|array_|string_|regexp_)/.test(name)) return false;
-  return true;
-}
-
-/**
- * Extract table names from a SQL string.
- * Returns lists of tables being read and written.
- * @param {string} sql
- * @returns {SQLExtraction}
- */
-export function extractSQLFromString(sql) {
-  if (!sql || typeof sql !== 'string') {
-    return { reads: [], writes: [] };
-  }
-
-  const reads = new Set();
-  const writes = new Set();
-
-  // Normalize: collapse whitespace, strip comments
-  const normalized = sql
-    .replace(/--[^\n]*/g, '')           // single-line SQL comments
-    .replace(/\/\*[\s\S]*?\*\//g, '')   // multi-line SQL comments
-    .replace(/\s+/g, ' ')
-    .trim();
-
-  // READ patterns
-  // FROM table [alias] — skip function calls: FROM func(...)
-  const fromRegex = /\bFROM\s+([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)?)/gi;
-  let match;
-  while ((match = fromRegex.exec(normalized)) !== null) {
-    // Skip if followed by ( — it's a function call, not a table
-    const afterMatch = normalized.slice(match.index + match[0].length).trimStart();
-    if (afterMatch.startsWith('(')) continue;
-    const name = match[1].split('.').pop(); // handle schema.table
-    if (isValidTableName(name)) reads.add(name);
-  }
-
-  // JOIN table [alias] — same check for safety
-  const joinRegex = /\bJOIN\s+([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)?)/gi;
-  while ((match = joinRegex.exec(normalized)) !== null) {
-    const afterMatch = normalized.slice(match.index + match[0].length).trimStart();
-    if (afterMatch.startsWith('(')) continue;
-    const name = match[1].split('.').pop();
-    if (isValidTableName(name)) reads.add(name);
-  }
-
-  // WRITE patterns
-  // INSERT INTO table
-  const insertRegex = /\bINSERT\s+INTO\s+([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)?)/gi;
-  while ((match = insertRegex.exec(normalized)) !== null) {
-    const name = match[1].split('.').pop();
-    if (isValidTableName(name)) writes.add(name);
-  }
-
-  // UPDATE table
-  const updateRegex = /\bUPDATE\s+([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)?)/gi;
-  while ((match = updateRegex.exec(normalized)) !== null) {
-    const name = match[1].split('.').pop();
-    if (isValidTableName(name)) writes.add(name);
-  }
-
-  // DELETE FROM table
-  const deleteRegex = /\bDELETE\s+FROM\s+([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)?)/gi;
-  while ((match = deleteRegex.exec(normalized)) !== null) {
-    const name = match[1].split('.').pop();
-    if (isValidTableName(name)) writes.add(name);
-  }
-
-  // Per peer review: remove DELETE primary target from reads to avoid double-counting.
-  // Only the primary mutation target is removed — subquery reads are preserved.
-  for (const w of writes) {
-    if (/\bDELETE\s+FROM\s+/i.test(normalized)) {
-      const deleteTargetMatch = normalized.match(/\bDELETE\s+FROM\s+([a-zA-Z_]\w*)/i);
-      if (deleteTargetMatch) {
-        const primaryTarget = deleteTargetMatch[1].split('.').pop();
-        if (w === primaryTarget) reads.delete(primaryTarget);
-      }
-    }
-  }
-
-  return {
-    reads: [...reads],
-    writes: [...writes],
-  };
-}
-
-/**
- * Parse a .sql file (schema dump / migration).
- * Extracts CREATE TABLE statements with column definitions.
- * @param {string} code - SQL file content
- * @param {string} filename - File path
- * @returns {Object} ParseResult-compatible + tables[]
- */
-export function parseSQL(code = '', filename = '') {
-  const result = {
-    file: filename,
-    classes: [],
-    functions: [],
-    imports: [],
-    exports: [],
-    tables: [],
-  };
-
-  if (!code) return result;
-
-  // Match CREATE TABLE statements
-  // Handles: CREATE TABLE [IF NOT EXISTS] [schema.]name (columns...)
-  const createTableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:[a-zA-Z_]\w*\.)?([a-zA-Z_]\w*)\s*\(([\s\S]*?)\);/gi;
-  let match;
-
-  while ((match = createTableRegex.exec(code)) !== null) {
-    const tableName = match[1];
-    const columnsBlock = match[2];
-    const line = code.substring(0, match.index).split('\n').length;
-
-    const columns = parseColumns(columnsBlock);
-
-    result.tables.push({
-      name: tableName,
-      columns,
-      file: filename,
-      line,
-    });
-  }
-
-  return result;
-}
-
-/**
- * Parse column definitions from CREATE TABLE body.
- * @param {string} block - The content between parentheses
- * @returns {{name: string, type: string}[]}
- */
-function parseColumns(block) {
-  const columns = [];
-  // Split by commas, but respect parentheses (for types like NUMERIC(10,2))
-  const parts = splitByTopLevelComma(block);
-
-  for (const part of parts) {
-    const trimmed = part.trim();
-    // Skip constraints (PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK, CONSTRAINT)
-    if (/^\s*(PRIMARY|FOREIGN|UNIQUE|CHECK|CONSTRAINT|EXCLUDE)\b/i.test(trimmed)) {
-      continue;
-    }
-
-    // Match: column_name TYPE [constraints...]
-    const colMatch = trimmed.match(/^([a-zA-Z_]\w*)\s+([A-Za-z]\w*(?:\s*\([^)]*\))?(?:\s*\[\])?)/);
-    if (colMatch) {
-      const name = colMatch[1];
-      const type = colMatch[2].trim();
-      // Skip if "name" is a SQL keyword (misparse)
-      if (!SQL_KEYWORDS.has(name.toLowerCase())) {
-        columns.push({ name, type });
-      }
-    }
-  }
-
-  return columns;
-}
-
-/**
- * Split string by commas, respecting parentheses depth.
- * @param {string} str
- * @returns {string[]}
- */
-function splitByTopLevelComma(str) {
-  const parts = [];
-  let current = '';
-  let depth = 0;
-
-  for (let i = 0; i < str.length; i++) {
-    const ch = str[i];
-    if (ch === '(') depth++;
-    else if (ch === ')') depth--;
-    else if (ch === ',' && depth === 0) {
-      parts.push(current);
-      current = '';
-      continue;
-    }
-    current += ch;
-  }
-  if (current.trim()) parts.push(current);
-
-  return parts;
-}
-
-/**
- * Extract SQL queries from raw source code (Python/Go pre-pass).
- * Scans string literals and finds SQL patterns before stripStringsAndComments
- * destroys the string contents.
- *
- * Returns aggregated reads/writes for the entire file.
- * @param {string} code - Raw source code
- * @returns {SQLExtraction}
- */
-export function extractSQLFromCode(code) {
-  const allReads = new Set();
-  const allWrites = new Set();
-
-  if (!code) return { reads: [], writes: [] };
-
-  // Find all string literals that look like SQL
-  // Match: "...", '...', `...`, """...""", '''...'''
-  const stringPatterns = [
-    /"""([\s\S]*?)"""/g,     // Python triple double-quote
-    /'''([\s\S]*?)'''/g,     // Python triple single-quote
-    /`([\s\S]*?)`/g,         // Go/JS backtick
-    /"((?:[^"\\]|\\.)*)"/g,  // Double-quoted
-    /'((?:[^'\\]|\\.)*)'/g,  // Single-quoted
-  ];
-
-  for (const pattern of stringPatterns) {
-    let match;
-    while ((match = pattern.exec(code)) !== null) {
-      const content = match[1];
-      if (isSQLString(content)) {
-        const extraction = extractSQLFromString(content);
-        extraction.reads.forEach(t => allReads.add(t));
-        extraction.writes.forEach(t => allWrites.add(t));
-      }
-    }
-  }
-
-  return {
-    reads: [...allReads],
-    writes: [...allWrites],
-  };
-}

package/src/lang-typescript.js

@@ -1,190 +0,0 @@
-import { stripStringsAndComments } from './lang-utils.js';
-
-/**
- * TypeScript/TSX regex-based parser.
- * Extracts structural information (classes, functions, imports, exports, calls)
- * directly from TypeScript code without relying on Acorn.
- *
- * Strategy: Instead of stripping TS syntax to feed Acorn (which causes
- * catastrophic backtracking in regex), parse structural elements directly
- * — same approach as lang-python.js and lang-go.js.
- *
- * @param {string} code - TypeScript source code
- * @param {string} filename - File path for the result
- * @returns {ParseResult}
- */
-export function parseTypeScript(code, filename) {
-  const result = {
-    file: filename,
-    classes: [],
-    functions: [],
-    imports: [],
-    exports: [],
-  };
-
-  // Strip strings, template literals, and comments to avoid false matches
-  const cleaned = stripStringsAndComments(code);
-  const lines = cleaned.split('\n');
-
-  let currentClass = null;
-  let currentFunc = null;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const lineNum = i + 1;
-
-    // --- Imports ---
-    // import { A, B } from 'module'
-    const importFromMatch = line.match(/^\s*import\s+(?:type\s+)?(?:\{([^}]+)\}|(\w+))\s+from\s/);
-    if (importFromMatch) {
-      if (importFromMatch[1]) {
-        importFromMatch[1].split(',').forEach(s => {
-          const name = s.trim().replace(/\s+as\s+\w+/, '').replace(/^type\s+/, '');
-          if (name) result.imports.push(name);
-        });
-      } else if (importFromMatch[2]) {
-        result.imports.push(importFromMatch[2]);
-      }
-      continue;
-    }
-    // import * as name from 'module'
-    const importStarMatch = line.match(/^\s*import\s+\*\s+as\s+(\w+)\s+from\s/);
-    if (importStarMatch) {
-      result.imports.push(importStarMatch[1]);
-      continue;
-    }
-
-    // --- Exports ---
-    const exportMatch = line.match(/^\s*export\s+(?:default\s+)?(?:class|function|const|let|var|type|interface|enum|abstract)\s+(\w+)/);
-    if (exportMatch) {
-      result.exports.push(exportMatch[1]);
-    }
-    // export { A, B }
-    const exportBraceMatch = line.match(/^\s*export\s+\{([^}]+)\}/);
-    if (exportBraceMatch) {
-      exportBraceMatch[1].split(',').forEach(s => {
-        const name = s.trim().replace(/\s+as\s+\w+/, '');
-        if (name) result.exports.push(name);
-      });
-    }
-
-    // Skip type-only declarations (no runtime code)
-    if (/^\s*(type|interface)\s+\w+/.test(line)) {
-      continue;
-    }
-
-    // --- Classes ---
-    const classMatch = line.match(/^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/);
-    if (classMatch) {
-      currentClass = {
-        name: classMatch[1],
-        extends: classMatch[2] || null,
-        methods: [],
-        properties: [],
-        calls: [],
-        file: filename,
-        line: lineNum,
-      };
-      result.classes.push(currentClass);
-      currentFunc = null;
-      continue;
-    }
-
-    // Detect end of class or function (closing brace at col 0)
-    if (/^}/.test(line)) {
-      currentClass = null;
-      currentFunc = null;
-      continue;
-    }
-
-    // --- Methods (inside class) ---
-    if (currentClass) {
-      // public/private/protected/static/async methodName(
-      const methodMatch = line.match(/^\s+(?:(?:public|private|protected|static|readonly|abstract|override|async)\s+)*(\w+)\s*(?:<[^>]*>)?\s*\(/);
-      if (methodMatch && methodMatch[1] !== 'if' && methodMatch[1] !== 'for' &&
-          methodMatch[1] !== 'while' && methodMatch[1] !== 'switch' &&
-          methodMatch[1] !== 'catch' && methodMatch[1] !== 'return' &&
-          methodMatch[1] !== 'new' && methodMatch[1] !== 'constructor' &&
-          methodMatch[1] !== 'super') {
-        currentClass.methods.push(methodMatch[1]);
-      }
-      // constructor
-      if (/^\s+constructor\s*\(/.test(line)) {
-        currentClass.methods.push('constructor');
-      }
-      // Property: name: Type or name = value
-      const propMatch = line.match(/^\s+(?:(?:public|private|protected|static|readonly|declare|override|abstract)\s+)*(\w+)\s*[?!]?\s*[:=]/);
-      if (propMatch && !methodMatch && propMatch[1] !== 'if' && propMatch[1] !== 'const' &&
-          propMatch[1] !== 'let' && propMatch[1] !== 'var' && propMatch[1] !== 'return') {
-        currentClass.properties.push(propMatch[1]);
-      }
-    }
-
-    // --- Functions (top-level) ---
-    if (!currentClass) {
-      // function name(, async function name(, export function, export default function
-      const fnMatch = line.match(/^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/);
-      if (fnMatch) {
-        currentFunc = {
-          name: fnMatch[1],
-          exported: /^\s*export\s+/.test(line),
-          calls: [],
-          params: extractParams(line),
-          file: filename,
-          line: lineNum,
-        };
-        result.functions.push(currentFunc);
-        continue;
-      }
-      // Arrow functions: const name = (...) => or export const name = (
-      const arrowMatch = line.match(/^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*(?::\s*\w+(?:<[^>]*>)?)?\s*=>/);
-      if (arrowMatch) {
-        currentFunc = {
-          name: arrowMatch[1],
-          exported: /^\s*export\s+/.test(line),
-          calls: [],
-          params: extractParams(line),
-          file: filename,
-          line: lineNum,
-        };
-        result.functions.push(currentFunc);
-        continue;
-      }
-    }
-
-    // --- Calls ---
-    const callRegex = /\b([a-zA-Z_$]\w*)\s*(?:<[^>]*>)?\s*\(/g;
-    let callMatch;
-    while ((callMatch = callRegex.exec(line)) !== null) {
-      const name = callMatch[1];
-      // Skip keywords and common built-ins
-      if (['if', 'for', 'while', 'switch', 'catch', 'return', 'new', 'throw',
-           'typeof', 'delete', 'void', 'import', 'export', 'class', 'function',
-           'const', 'let', 'var', 'async', 'await', 'super', 'this',
-           'interface', 'type', 'enum', 'declare', 'abstract'].includes(name)) {
-        continue;
-      }
-      if (currentClass) {
-        currentClass.calls.push(name);
-      } else if (currentFunc) {
-        currentFunc.calls.push(name);
-      }
-    }
-  }
-
-  return result;
-}
-
-/**
- * Extract parameter names from a function signature line.
- * @param {string} line
- * @returns {string[]}
- */
-function extractParams(line) {
-  const match = line.match(/\(([^)]*)\)/);
-  if (!match) return [];
-  return match[1]
-    .split(',')
-    .map(p => p.trim().replace(/[?!]?\s*:.*$/, '').replace(/\s*=.*$/, '').trim())
-    .filter(p => p && !p.startsWith('...'));
-}

package/src/lang-utils.js

@@ -1,124 +0,0 @@
-/**
- * Strip strings, template literals, and comments from source code.
- * Preserves line structure (newlines are kept) and character positions.
- * @param {string} code
- * @param {Object} [options]
- * @param {boolean} [options.singleQuote=true] - Handle single-quoted strings
- * @param {boolean} [options.backtick=true] - Handle backtick strings/templates
- * @param {boolean} [options.hashComment=false] - Handle # comments (Python)
- * @param {boolean} [options.tripleQuote=false] - Handle ''' and """ (Python)
- * @param {boolean} [options.templateInterpolation=true] - Handle ${} in backticks
- * @returns {string}
- */
-export function stripStringsAndComments(code, options = {}) {
-  const {
-    singleQuote = true,
-    backtick = true,
-    hashComment = false,
-    tripleQuote = false,
-    templateInterpolation = true
-  } = options;
-
-  let result = '';
-  let i = 0;
-
-  while (i < code.length) {
-    // Hash comment
-    if (hashComment && code[i] === '#') {
-      while (i < code.length && code[i] !== '\n') {
-        result += ' ';
-        i++;
-      }
-      continue;
-    }
-
-    // Triple quotes
-    if (tripleQuote && (
-      (code[i] === "'" && code[i+1] === "'" && code[i+2] === "'") ||
-      (code[i] === '"' && code[i+1] === '"' && code[i+2] === '"')
-    )) {
-      const quote = code[i];
-      result += '   ';
-      i += 3;
-      while (i < code.length) {
-        if (code[i] === '\\') {
-          result += '  ';
-          i += 2;
-          continue;
-        }
-        if (code[i] === quote && code[i+1] === quote && code[i+2] === quote) {
-          result += '   ';
-          i += 3;
-          break;
-        }
-        result += code[i] === '\n' ? '\n' : ' ';
-        i++;
-      }
-      continue;
-    }
-
-    // Single-line comment //
-    if (!hashComment && code[i] === '/' && code[i + 1] === '/') {
-      while (i < code.length && code[i] !== '\n') {
-        result += ' ';
-        i++;
-      }
-      continue;
-    }
-
-    // Multi-line comment /* ... */
-    if (!hashComment && code[i] === '/' && code[i + 1] === '*') {
-      i += 2;
-      result += '  ';
-      while (i < code.length && !(code[i] === '*' && code[i + 1] === '/')) {
-        result += code[i] === '\n' ? '\n' : ' ';
-        i++;
-      }
-      if (i < code.length) { result += '  '; i += 2; }
-      continue;
-    }
-
-    // String literals
-    if (code[i] === '"' || (singleQuote && code[i] === "'") || (backtick && code[i] === '`')) {
-      const quote = code[i];
-      result += ' ';
-      i++;
-      while (i < code.length) {
-        if (code[i] === '\\') {
-          result += '  ';
-          i += 2;
-          continue;
-        }
-        if (code[i] === quote) {
-          result += ' ';
-          i++;
-          break;
-        }
-        // Template literal: ${...} — keep the expression
-        if (templateInterpolation && quote === '`' && code[i] === '$' && code[i + 1] === '{') {
-          result += '${';
-          i += 2;
-          let depth = 1;
-          while (i < code.length && depth > 0) {
-            if (code[i] === '{') depth++;
-            if (code[i] === '}') depth--;
-            if (depth > 0) {
-              result += code[i] === '\n' ? '\n' : code[i];
-            } else {
-              result += '}';
-            }
-            i++;
-          }
-          continue;
-        }
-        result += code[i] === '\n' ? '\n' : ' ';
-        i++;
-      }
-      continue;
-    }
-    result += code[i];
-    i++;
-  }
-
-  return result;
-}