project-graph-mcp 1.5.0 → 2.1.0

package/src/similar-functions.js

@@ -1,279 +0,0 @@
-/**
- * Similar Functions Detector
- * Finds functionally similar functions across the codebase
- */
-
-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} FunctionSignature
- * @property {string} name
- * @property {string} file
- * @property {number} line
- * @property {number} paramCount
- * @property {string[]} paramNames
- * @property {boolean} async
- * @property {string} bodyHash - Structural hash of function body
- * @property {string[]} calls - Functions called inside
- */
-
-/**
- * @typedef {Object} SimilarPair
- * @property {FunctionSignature} a
- * @property {FunctionSignature} b
- * @property {number} similarity - 0-100
- * @property {string[]} reasons
- */
-
-/**
- * Find all JS files
- * @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) { }
-
-  return files;
-}
-
-/**
- * Extract function signatures from a file
- * @param {string} filePath 
- * @param {string} rootDir - Root directory for relative path calculation
- * @returns {FunctionSignature[]}
- */
-function extractSignatures(filePath, rootDir) {
-  const code = readFileSync(filePath, 'utf-8');
-  const relPath = relative(rootDir, filePath);
-  const signatures = [];
-
-  let ast;
-  try {
-    ast = parse(code, { ecmaVersion: 'latest', sourceType: 'module', locations: true });
-  } catch (e) {
-    return signatures;
-  }
-
-  walk.simple(ast, {
-    FunctionDeclaration(node) {
-      if (!node.id) return;
-      signatures.push(buildSignature(node, node.id.name, relPath));
-    },
-
-    MethodDefinition(node) {
-      if (node.kind !== 'method') return;
-      const name = node.key.name || node.key.value;
-      if (name.startsWith('_')) return;
-      signatures.push(buildSignature(node.value, name, relPath));
-    },
-  });
-
-  return signatures;
-}
-
-/**
- * Build signature from function node
- * @param {Object} node 
- * @param {string} name 
- * @param {string} file 
- * @returns {FunctionSignature}
- */
-function buildSignature(node, name, file) {
-  const paramNames = node.params.map(p => extractParamName(p));
-  const calls = [];
-
-  // Extract function calls
-  walk.simple(node.body, {
-    CallExpression(callNode) {
-      if (callNode.callee.type === 'Identifier') {
-        calls.push(callNode.callee.name);
-      } else if (callNode.callee.type === 'MemberExpression' && callNode.callee.property.type === 'Identifier') {
-        calls.push(callNode.callee.property.name);
-      }
-    },
-  });
-
-  // Create structural hash
-  const bodyHash = hashBodyStructure(node.body);
-
-  return {
-    name,
-    file,
-    line: node.loc?.start?.line || 0,
-    paramCount: node.params.length,
-    paramNames,
-    async: node.async || false,
-    bodyHash,
-    calls: [...new Set(calls)],
-  };
-}
-
-/**
- * Extract param name
- * @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;
-  return 'param';
-}
-
-/**
- * Create structural hash of function body
- * @param {Object} body 
- * @returns {string}
- */
-function hashBodyStructure(body) {
-  const structure = [];
-
-  walk.simple(body, {
-    IfStatement() { structure.push('IF'); },
-    ForStatement() { structure.push('FOR'); },
-    ForOfStatement() { structure.push('FOROF'); },
-    ForInStatement() { structure.push('FORIN'); },
-    WhileStatement() { structure.push('WHILE'); },
-    SwitchStatement() { structure.push('SWITCH'); },
-    TryStatement() { structure.push('TRY'); },
-    ReturnStatement() { structure.push('RET'); },
-    ThrowStatement() { structure.push('THROW'); },
-    AwaitExpression() { structure.push('AWAIT'); },
-  });
-
-  return structure.join('|');
-}
-
-/**
- * Calculate similarity between two functions
- * @param {FunctionSignature} a 
- * @param {FunctionSignature} b 
- * @returns {{similarity: number, reasons: string[]}}
- */
-function calculateSimilarity(a, b) {
-  const reasons = [];
-  let score = 0;
-  let maxScore = 0;
-
-  // Same param count (important)
-  maxScore += 30;
-  if (a.paramCount === b.paramCount) {
-    score += 30;
-    reasons.push('Same param count');
-  }
-
-  // Similar param names
-  maxScore += 20;
-  const commonParams = a.paramNames.filter(p => b.paramNames.includes(p));
-  if (commonParams.length > 0 && a.paramNames.length > 0) {
-    const paramSim = commonParams.length / Math.max(a.paramNames.length, b.paramNames.length);
-    score += Math.round(paramSim * 20);
-    if (paramSim >= 0.5) reasons.push(`Similar params: ${commonParams.join(', ')}`);
-  }
-
-  // Same async status
-  maxScore += 10;
-  if (a.async === b.async) {
-    score += 10;
-  }
-
-  // Similar body structure
-  maxScore += 25;
-  if (a.bodyHash === b.bodyHash && a.bodyHash.length > 0) {
-    score += 25;
-    reasons.push('Identical structure');
-  } else if (a.bodyHash.length > 0 && b.bodyHash.length > 0) {
-    const aTokens = a.bodyHash.split('|');
-    const bTokens = b.bodyHash.split('|');
-    const commonTokens = aTokens.filter(t => bTokens.includes(t));
-    if (commonTokens.length > 0) {
-      const structSim = commonTokens.length / Math.max(aTokens.length, bTokens.length);
-      score += Math.round(structSim * 25);
-      if (structSim >= 0.5) reasons.push('Similar control flow');
-    }
-  }
-
-  // Common function calls
-  maxScore += 15;
-  const commonCalls = a.calls.filter(c => b.calls.includes(c));
-  if (commonCalls.length > 0 && a.calls.length > 0 && b.calls.length > 0) {
-    const callSim = commonCalls.length / Math.max(a.calls.length, b.calls.length);
-    score += Math.round(callSim * 15);
-    if (commonCalls.length >= 2) reasons.push(`Common calls: ${commonCalls.slice(0, 3).join(', ')}`);
-  }
-
-  const similarity = Math.round((score / maxScore) * 100);
-  return { similarity, reasons };
-}
-
-/**
- * Get similar functions in directory
- * @param {string} dir 
- * @param {Object} [options]
- * @param {number} [options.threshold=60] - Minimum similarity percentage
- * @returns {Promise<{total: number, pairs: SimilarPair[]}>}
- */
-export async function getSimilarFunctions(dir, options = {}) {
-  const threshold = options.threshold || 60;
-  const resolvedDir = resolve(dir);
-  const files = findJSFiles(dir);
-  const allSignatures = [];
-
-  // Collect all signatures
-  for (const file of files) {
-    allSignatures.push(...extractSignatures(file, resolvedDir));
-  }
-
-  // Compare all pairs
-  const pairs = [];
-  for (let i = 0; i < allSignatures.length; i++) {
-    for (let j = i + 1; j < allSignatures.length; j++) {
-      const a = allSignatures[i];
-      const b = allSignatures[j];
-
-      // Skip same file same name (likely intentional overload)
-      if (a.file === b.file && a.name === b.name) continue;
-
-      // Skip very small functions
-      if (a.bodyHash.length < 3 && b.bodyHash.length < 3) continue;
-
-      const { similarity, reasons } = calculateSimilarity(a, b);
-
-      if (similarity >= threshold && reasons.length > 0) {
-        pairs.push({ a, b, similarity, reasons });
-      }
-    }
-  }
-
-  // Sort by similarity descending
-  pairs.sort((x, y) => y.similarity - x.similarity);
-
-  return {
-    total: pairs.length,
-    pairs: pairs.slice(0, 20),
-  };
-}

package/src/test-annotations.js

@@ -1,323 +0,0 @@
-/**
- * Test Checklists — .ctx.md based
- * Reads/writes test checklists from ## Tests sections in .ctx.md files
- */
-
-import { readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
-import { join, basename, relative, resolve } from 'path';
-
-/**
- * @typedef {Object} TestStep
- * @property {string} id - Unique ID (e.g., "togglePin.0")
- * @property {string} action - What to do
- * @property {string} [expected] - Expected result (after →)
- * @property {string} status - 'pending' | 'passed' | 'failed'
- * @property {string} [failReason] - Why it failed
- */
-
-/**
- * @typedef {Object} Feature
- * @property {string} name - Function/method name
- * @property {TestStep[]} tests - Test steps
- * @property {string} file - Source .ctx.md file path
- */
-
-/**
- * Find all .ctx.md files in .context/ directory
- * @param {string} dir - Context directory path
- * @returns {string[]}
- */
-function findCtxMdFiles(dir) {
-  const files = [];
-  try {
-    for (const entry of readdirSync(dir)) {
-      const fullPath = join(dir, entry);
-      const stat = statSync(fullPath);
-      if (stat.isDirectory() && !entry.startsWith('.')) {
-        files.push(...findCtxMdFiles(fullPath));
-      } else if (entry.endsWith('.ctx.md')) {
-        files.push(fullPath);
-      }
-    }
-  } catch (e) {
-    // Directory not found
-  }
-  return files;
-}
-
-/**
- * Parse ## Tests section from a .ctx.md file
- * @param {string} content - File content
- * @param {string} filePath - Path to .ctx.md file
- * @returns {Feature[]}
- */
-export function parseAnnotations(content, filePath) {
-  const lines = content.split('\n');
-  const features = [];
-
-  // Find ## Tests section
-  let inTests = false;
-  let currentTests = [];
-
-  for (const line of lines) {
-    // Detect section headers
-    if (line.startsWith('## ')) {
-      if (inTests && currentTests.length) {
-        // End of Tests section — flush
-        features.push(...groupByName(currentTests, filePath));
-        currentTests = [];
-      }
-      inTests = line.startsWith('## Tests');
-      continue;
-    }
-
-    if (!inTests) continue;
-
-    // Parse checklist lines: - [ ] name: action → expected
-    // States: [ ] = pending, [x] = passed, [!] = failed
-    const match = line.match(/^- \[([ x!])\] (\w+):\s*(.+)$/);
-    if (!match) continue;
-
-    const [, state, name, rest] = match;
-    const parts = rest.split('→').map(s => s.trim());
-    const action = parts[0];
-    const expected = parts[1] || null;
-
-    // Extract fail reason from: (FAILED: reason)
-    let failReason = null;
-    let status = 'pending';
-    if (state === 'x') status = 'passed';
-    if (state === '!') {
-      status = 'failed';
-      const failMatch = action.match(/\(FAILED:\s*(.+)\)$/);
-      if (failMatch) failReason = failMatch[1].trim();
-    }
-
-    currentTests.push({ name, action, expected, status, failReason });
-  }
-
-  // Flush remaining
-  if (inTests && currentTests.length) {
-    features.push(...groupByName(currentTests, filePath));
-  }
-
-  return features;
-}
-
-/**
- * Group test steps by function name into Feature objects
- * @param {Array} tests - Raw test entries
- * @param {string} filePath - Source file
- * @returns {Feature[]}
- */
-function groupByName(tests, filePath) {
-  const map = {};
-  let indexMap = {};
-
-  for (const t of tests) {
-    if (!map[t.name]) {
-      map[t.name] = [];
-      indexMap[t.name] = 0;
-    }
-    map[t.name].push({
-      id: `${t.name}.${indexMap[t.name]++}`,
-      action: t.action,
-      expected: t.expected,
-      status: t.status,
-      failReason: t.failReason,
-    });
-  }
-
-  return Object.entries(map).map(([name, tests]) => ({
-    name,
-    tests,
-    file: filePath,
-  }));
-}
-
-/**
- * Get all features from a project directory
- * @param {string} dir - Project root
- * @returns {Feature[]}
- */
-export function getAllFeatures(dir) {
-  const contextDir = join(resolve(dir), '.context');
-  const files = findCtxMdFiles(contextDir);
-  const features = [];
-
-  for (const file of files) {
-    try {
-      const content = readFileSync(file, 'utf-8');
-      const parsed = parseAnnotations(content, file);
-      features.push(...parsed);
-    } catch (e) {
-      // Skip unreadable files
-    }
-  }
-
-  return features;
-}
-
-/**
- * Get pending (uncompleted) tests
- * @param {string} dir - Project root
- * @returns {TestStep[]}
- */
-export function getPendingTests(dir) {
-  const resolvedDir = resolve(dir);
-  const features = getAllFeatures(dir);
-  const pending = [];
-
-  for (const feature of features) {
-    for (const test of feature.tests) {
-      if (test.status === 'pending') {
-        pending.push({
-          ...test,
-          feature: feature.name,
-          file: relative(resolvedDir, feature.file),
-        });
-      }
-    }
-  }
-
-  return pending;
-}
-
-/**
- * Mark a test as passed — writes directly to .ctx.md file
- * @param {string} testId - e.g. "togglePin.0"
- * @returns {{success: boolean, testId: string}}
- */
-export function markTestPassed(testId) {
-  const name = testId.split('.')[0];
-  return updateTestState(name, testId, 'x');
-}
-
-/**
- * Mark a test as failed — writes directly to .ctx.md file
- * @param {string} testId - e.g. "togglePin.0"
- * @param {string} reason - Why it failed
- * @returns {{success: boolean, testId: string, reason: string}}
- */
-export function markTestFailed(testId, reason) {
-  const name = testId.split('.')[0];
-  return updateTestState(name, testId, '!', reason);
-}
-
-/**
- * Update test state in .ctx.md files
- * @param {string} name - Function name
- * @param {string} testId - Full test ID
- * @param {string} newState - 'x' | '!' | ' '
- * @param {string} [reason] - Failure reason
- * @returns {{success: boolean, testId: string, reason?: string}}
- */
-function updateTestState(name, testId, newState, reason) {
-  // Need to find which .ctx.md file contains this test
-  // Walk all .ctx.md files in .context/
-  const cwd = process.cwd();
-  const contextDir = join(cwd, '.context');
-  const files = findCtxMdFiles(contextDir);
-  const testIndex = parseInt(testId.split('.')[1], 10);
-
-  for (const file of files) {
-    try {
-      const content = readFileSync(file, 'utf-8');
-      const lines = content.split('\n');
-      let inTests = false;
-      let nameIndex = 0;
-
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i].startsWith('## ')) {
-          inTests = lines[i].startsWith('## Tests');
-          continue;
-        }
-        if (!inTests) continue;
-
-        const match = lines[i].match(/^- \[([ x!])\] (\w+):\s*(.+)$/);
-        if (!match) continue;
-        if (match[2] !== name) continue;
-
-        if (nameIndex === testIndex) {
-          // Found the line — update it
-          const desc = match[3].replace(/\s*\(FAILED:.*\)$/, '');
-          const suffix = reason ? ` (FAILED: ${reason})` : '';
-          lines[i] = `- [${newState}] ${name}: ${desc}${suffix}`;
-          writeFileSync(file, lines.join('\n'), 'utf-8');
-          return { success: true, testId, ...(reason ? { reason } : {}) };
-        }
-        nameIndex++;
-      }
-    } catch (e) {
-      // Skip
-    }
-  }
-
-  return { success: false, testId, error: 'Test not found' };
-}
-
-/**
- * Get test summary across all .ctx.md files
- * @param {string} dir - Project root
- * @returns {Object}
- */
-export function getTestSummary(dir) {
-  const features = getAllFeatures(dir);
-
-  let total = 0;
-  let passed = 0;
-  let failed = 0;
-  let pending = 0;
-  const failures = [];
-
-  for (const feature of features) {
-    for (const test of feature.tests) {
-      total++;
-      if (test.status === 'passed') {
-        passed++;
-      } else if (test.status === 'failed') {
-        failed++;
-        failures.push({ id: test.id, reason: test.failReason });
-      } else {
-        pending++;
-      }
-    }
-  }
-
-  return {
-    total,
-    passed,
-    failed,
-    pending,
-    progress: total > 0 ? Math.round((passed + failed) / total * 100) : 0,
-    failures,
-  };
-}
-
-/**
- * Reset all test states — changes [x] and [!] back to [ ] in all .ctx.md files
- * @returns {{success: boolean}}
- */
-export function resetTestState() {
-  const cwd = process.cwd();
-  const contextDir = join(cwd, '.context');
-  const files = findCtxMdFiles(contextDir);
-
-  for (const file of files) {
-    try {
-      let content = readFileSync(file, 'utf-8');
-      // Replace [x] and [!] with [ ] in test lines, remove FAILED reasons
-      const updated = content.replace(
-        /^(- )\[([x!])\] (\w+:\s*.+?)(?:\s*\(FAILED:.*\))?$/gm,
-        '$1[ ] $3'
-      );
-      if (updated !== content) {
-        writeFileSync(file, updated, 'utf-8');
-      }
-    } catch (e) {
-      // Skip
-    }
-  }
-
-  return { success: true };
-}