project-graph-mcp 1.2.4 → 1.5.0

package/src/jsdoc-checker.js

@@ -0,0 +1,351 @@
+/**
+ * JSDoc Consistency Checker (AST-based)
+ * Validates JSDoc annotations against actual function signatures
+ * 
+ * Checks:
+ * - Param count mismatch (JSDoc vs AST)
+ * - Param name mismatch
+ * - Missing @returns on functions with return statements
+ * - Type hint inconsistency (default value vs JSDoc type)
+ */
+
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, relative, resolve } from 'path';
+import { parse } from '../vendor/acorn.mjs';
+import * as walk from '../vendor/walk.mjs';
+import { shouldExcludeDir, shouldExcludeFile, parseGitignore } from './filters.js';
+
+/**
+ * @typedef {Object} JSDocIssue
+ * @property {string} file
+ * @property {number} line
+ * @property {string} name - Function or method name
+ * @property {'error'|'warning'} severity
+ * @property {string} message
+ */
+
+/**
+ * Find all JS files in directory
+ * @param {string} dir
+ * @param {string} rootDir
+ * @returns {string[]}
+ */
+function findJSFiles(dir, rootDir = dir) {
+  if (dir === rootDir) parseGitignore(rootDir);
+  const files = [];
+  try {
+    for (const entry of readdirSync(dir)) {
+      const fullPath = join(dir, entry);
+      const relativePath = relative(rootDir, fullPath);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        if (!shouldExcludeDir(entry, relativePath)) {
+          files.push(...findJSFiles(fullPath, rootDir));
+        }
+      } else if (entry.endsWith('.js') && !entry.endsWith('.css.js') && !entry.endsWith('.tpl.js')) {
+        if (!shouldExcludeFile(entry, relativePath)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (e) { /* dir not found */ }
+  return files;
+}
+
+/**
+ * Extract JSDoc comments with positions
+ * @param {string} code
+ * @returns {Array<{text: string, endLine: number, params: Array<{name: string, type: string}>, hasReturns: boolean}>}
+ */
+function extractJSDocComments(code) {
+  const comments = [];
+  const regex = /\/\*\*[\s\S]*?\*\//g;
+  let match;
+
+  while ((match = regex.exec(code)) !== null) {
+    const text = match[0];
+    const endLine = code.slice(0, match.index + text.length).split('\n').length;
+
+    // Parse @param tags — handle nested braces in types like {Array<{text: string}>}
+    const params = [];
+    const paramStartRegex = /@param\s+\{/g;
+    let paramStart;
+    while ((paramStart = paramStartRegex.exec(text)) !== null) {
+      // Find matching closing brace (balanced)
+      let depth = 1;
+      let i = paramStart.index + paramStart[0].length;
+      while (i < text.length && depth > 0) {
+        if (text[i] === '{') depth++;
+        else if (text[i] === '}') depth--;
+        i++;
+      }
+      if (depth !== 0) continue;
+      const type = text.slice(paramStart.index + paramStart[0].length, i - 1);
+      // Extract param name after the closing brace
+      const afterType = text.slice(i);
+      const nameMatch = afterType.match(/^\s+(\[?\w+(?:\.\w+)*\]?)/);
+      if (!nameMatch) continue;
+      let name = nameMatch[1];
+      // Strip [] from optional params: [opts] → opts
+      if (name.startsWith('[')) name = name.slice(1);
+      if (name.endsWith(']')) name = name.slice(0, -1);
+      // Strip dotted paths: options.includeTests → skip (nested property)
+      if (name.includes('.')) continue;
+      params.push({ name, type });
+    }
+
+    const hasReturns = /@returns?\s/.test(text);
+
+    comments.push({ text, endLine, params, hasReturns });
+  }
+
+  return comments;
+}
+
+/**
+ * Find JSDoc comment before a target line
+ * @param {Array} comments
+ * @param {number} targetLine
+ * @returns {Object|null}
+ */
+function findJSDocBefore(comments, targetLine) {
+  for (const comment of comments) {
+    const gap = targetLine - comment.endLine;
+    if (gap >= 0 && gap <= 2) return comment;
+  }
+  return null;
+}
+
+/**
+ * Extract parameter name from AST node
+ * @param {Object} param
+ * @returns {string}
+ */
+function extractParamName(param) {
+  if (param.type === 'Identifier') return param.name;
+  if (param.type === 'AssignmentPattern' && param.left.type === 'Identifier') return param.left.name;
+  if (param.type === 'RestElement' && param.argument.type === 'Identifier') return param.argument.name;
+  if (param.type === 'ObjectPattern') return 'options';
+  if (param.type === 'ArrayPattern') return 'args';
+  return 'param';
+}
+
+/**
+ * Infer expected type from AST default value
+ * @param {Object} param
+ * @returns {string|null}
+ */
+function inferTypeFromDefault(param) {
+  if (param.type !== 'AssignmentPattern') return null;
+  const def = param.right;
+  if (def.type === 'Literal') {
+    if (typeof def.value === 'string') return 'string';
+    if (typeof def.value === 'number') return 'number';
+    if (typeof def.value === 'boolean') return 'boolean';
+  }
+  if (def.type === 'ArrayExpression') return 'Array';
+  if (def.type === 'ObjectExpression') return 'Object';
+  return null;
+}
+
+/**
+ * Check if function body has return statements with values
+ * @param {Object} node - Function AST node
+ * @returns {boolean}
+ */
+function hasReturnValue(node) {
+  let found = false;
+  try {
+    walk.simple(node.body, {
+      ReturnStatement(ret) {
+        if (ret.argument) found = true;
+      },
+      // Don't recurse into nested functions
+      FunctionDeclaration() { },
+      FunctionExpression() { },
+      ArrowFunctionExpression() { },
+    });
+  } catch (e) { /* walk error */ }
+  return found;
+}
+
+/**
+ * Validate a function's JSDoc against its AST
+ * @param {Object} jsdoc - Parsed JSDoc
+ * @param {Object[]} astParams - AST param nodes
+ * @param {Object} funcNode - AST function node
+ * @param {string} name - Function name
+ * @param {string} file - File path
+ * @param {number} line - Line number
+ * @returns {JSDocIssue[]}
+ */
+function validateFunction(jsdoc, astParams, funcNode, name, file, line) {
+  const issues = [];
+
+  if (!jsdoc) return issues; // No JSDoc = handled by undocumented checker
+
+  const docParams = jsdoc.params;
+
+  // 1. Param count mismatch
+  if (docParams.length !== astParams.length) {
+    issues.push({
+      file, line, name,
+      severity: 'error',
+      message: `Param count mismatch: JSDoc has ${docParams.length}, function has ${astParams.length}`,
+    });
+  }
+
+  // 2. Param name mismatch
+  const minLen = Math.min(docParams.length, astParams.length);
+  for (let i = 0; i < minLen; i++) {
+    const docName = docParams[i].name;
+    const astName = extractParamName(astParams[i]);
+
+    if (docName !== astName && astName !== 'options' && astName !== 'args' && astName !== 'param') {
+      issues.push({
+        file, line, name,
+        severity: 'error',
+        message: `Param name mismatch at position ${i}: JSDoc says "${docName}", code has "${astName}"`,
+      });
+    }
+  }
+
+  // 3. Missing @returns on non-void functions
+  if (!jsdoc.hasReturns && hasReturnValue(funcNode)) {
+    issues.push({
+      file, line, name,
+      severity: 'warning',
+      message: 'Function returns a value but JSDoc has no @returns',
+    });
+  }
+
+  // 4. Type hint inconsistency
+  for (let i = 0; i < minLen; i++) {
+    const docType = docParams[i].type;
+    const inferredType = inferTypeFromDefault(astParams[i]);
+
+    if (inferredType && docType && docType !== '*') {
+      let compatible = docType.includes(inferredType);
+      // Union types like 'a'|'b' are valid strings
+      if (!compatible && inferredType === 'string' && docType.includes("'") && docType.includes('|')) {
+        compatible = true;
+      }
+      // Type[] shorthand is a valid Array
+      if (!compatible && inferredType === 'Array' && docType.includes('[]')) {
+        compatible = true;
+      }
+      if (!compatible) {
+        issues.push({
+          file, line, name,
+          severity: 'warning',
+          message: `Type mismatch for "${docParams[i].name}": JSDoc says {${docType}}, default value suggests {${inferredType}}`,
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Check JSDoc consistency for a single file (per-file export for cache integration)
+ * @param {string} code
+ * @param {string} filePath
+ * @returns {JSDocIssue[]}
+ */
+export function checkJSDocFile(code, filePath) {
+  const issues = [];
+
+  let ast;
+  try {
+    ast = parse(code, { ecmaVersion: 'latest', sourceType: 'module', locations: true });
+  } catch (e) {
+    return issues;
+  }
+
+  const comments = extractJSDocComments(code);
+
+  walk.simple(ast, {
+    FunctionDeclaration(node) {
+      if (!node.id) return;
+      const jsdoc = findJSDocBefore(comments, node.loc.start.line);
+      if (jsdoc) {
+        issues.push(...validateFunction(jsdoc, node.params, node, node.id.name, filePath, node.loc.start.line));
+      }
+    },
+
+    // Exported arrow/const functions
+    VariableDeclaration(node) {
+      for (const decl of node.declarations) {
+        if (!decl.init) continue;
+        const func = decl.init.type === 'ArrowFunctionExpression' || decl.init.type === 'FunctionExpression'
+          ? decl.init : null;
+        if (!func || !decl.id?.name) continue;
+
+        const jsdoc = findJSDocBefore(comments, node.loc.start.line);
+        if (jsdoc) {
+          issues.push(...validateFunction(jsdoc, func.params, func, decl.id.name, filePath, node.loc.start.line));
+        }
+      }
+    },
+
+    ClassDeclaration(node) {
+      const className = node.id?.name || 'Anonymous';
+      for (const element of node.body.body) {
+        if (element.type !== 'MethodDefinition') continue;
+        const methodName = element.key.name || element.key.value;
+        if (!methodName || methodName === 'constructor') continue;
+        if (element.kind !== 'method') continue;
+
+        const funcNode = element.value;
+        const jsdoc = findJSDocBefore(comments, element.loc.start.line);
+        if (jsdoc) {
+          issues.push(...validateFunction(jsdoc, funcNode.params, funcNode, `${className}.${methodName}`, filePath, element.loc.start.line));
+        }
+      }
+    },
+  });
+
+  return issues;
+}
+
+/**
+ * Check JSDoc consistency across a directory
+ * @param {string} dir
+ * @returns {{ issues: JSDocIssue[], summary: { total: number, errors: number, warnings: number, byFile: Object } }}
+ */
+export function checkJSDocConsistency(dir) {
+  const resolvedDir = resolve(dir);
+  const files = findJSFiles(dir);
+  const allIssues = [];
+
+  for (const file of files) {
+    let content;
+    try {
+      content = readFileSync(file, 'utf-8');
+    } catch (e) {
+      continue; // File deleted between findJSFiles and read
+    }
+    const relPath = relative(resolvedDir, file);
+    const issues = checkJSDocFile(content, relPath);
+    allIssues.push(...issues);
+  }
+
+  const errors = allIssues.filter(i => i.severity === 'error').length;
+  const warnings = allIssues.filter(i => i.severity === 'warning').length;
+
+  const byFile = {};
+  for (const issue of allIssues) {
+    byFile[issue.file] = (byFile[issue.file] || 0) + 1;
+  }
+
+  return {
+    issues: allIssues,
+    summary: {
+      total: allIssues.length,
+      errors,
+      warnings,
+      byFile,
+    },
+  };
+}

package/src/jsdoc-generator.js

@@ -22,11 +22,9 @@ import { getWorkspaceRoot } from './workspace.js';
  * Generate JSDoc for a single file
  * @param {string} filePath - Absolute path to file
  * @param {Object} [options]
- * @param {boolean} [options.includeTests=true] - Include @test/@expect placeholders
  * @returns {JSDocTemplate[]}
  */
 export function generateJSDoc(filePath, options = {}) {
-  const includeTests = options.includeTests !== false;
   const results = [];
 
   const code = readFileSync(filePath, 'utf-8');
@@ -72,7 +70,6 @@ export function generateJSDoc(filePath, options = {}) {
         name: node.id.name,
         params: node.params,
         async: node.async,
-        includeTests,
       });
 
       results.push({
@@ -102,7 +99,6 @@ export function generateJSDoc(filePath, options = {}) {
             name: methodName,
             params: funcNode.params,
             async: funcNode.async,
-            includeTests,
           });
 
           results.push({
@@ -126,7 +122,6 @@ export function generateJSDoc(filePath, options = {}) {
  * @param {string} info.name
  * @param {Array} info.params
  * @param {boolean} info.async
- * @param {boolean} info.includeTests
  * @returns {string}
  */
 function buildJSDoc(info) {
@@ -145,12 +140,6 @@ function buildJSDoc(info) {
   // Return type
   lines.push(` * @returns {${info.async ? 'Promise<*>' : '*'}}`);
 
-  // Test annotations (Agentic Verification)
-  if (info.includeTests) {
-    lines.push(` * @test TODO: describe test scenario`);
-    lines.push(` * @expect TODO: expected result`);
-  }
-
   lines.push(' */');
   return lines.join('\n');
 }

package/src/lang-sql.js

@@ -0,0 +1,309 @@
+/**
+ * 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],
+  };
+}