project-graph-mcp 1.3.0 → 2.0.0

package/src/similar-functions.js

@@ -1,278 +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 
- * @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,301 +0,0 @@
-/**
- * Test Annotations Parser
- * Extracts @test/@expect JSDoc annotations for browser testing
- */
-
-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.1")
- * @property {string} type - Action type (click, key, drag, etc.)
- * @property {string} description - What to do
- * @property {boolean} completed - Whether test passed
- * @property {string} [failReason] - Why it failed (if failed)
- */
-
-/**
- * @typedef {Object} Feature
- * @property {string} name - Method name
- * @property {string} description - What the method does
- * @property {TestStep[]} tests - Test steps
- * @property {Array<{type: string, description: string}>} expects - Expected outcomes
- * @property {string} file - Source file
- * @property {number} line - Line number
- */
-
-// In-memory state for test progress
-const testState = new Map();
-
-/**
- * Parse @test/@expect annotations from a file
- * @param {string} content 
- * @param {string} filePath 
- * @returns {Feature[]}
- */
-export function parseAnnotations(content, filePath) {
-  const results = [];
-  const blockRegex = /\/\*\*([^]*?)\*\//g;
-
-  let match;
-  while ((match = blockRegex.exec(content)) !== null) {
-    const block = match[1];
-
-    // Check if block has @test or @expect
-    if (!block.includes('@test') && !block.includes('@expect')) continue;
-
-    // Find method name after the block
-    // Supports: methodName(  |  propName: (  |  propName: async (
-    const afterBlock = content.slice(match.index + match[0].length);
-    const methodMatch = afterBlock.match(
-      /^\s*(?:async\s+)?(\w+)\s*\(/ // class method: methodName(
-    ) || afterBlock.match(
-      /^\s*(\w+)\s*:\s*(?:async\s*)?\(/ // arrow in object: propName: (
-    ) || afterBlock.match(
-      /^\s*(\w+)\s*:\s*(?:async\s+)?\(/ // arrow in object: propName: async (
-    );
-    if (!methodMatch) continue;
-
-    const methodName = methodMatch[1];
-
-    // Extract description (first line)
-    const descMatch = block.match(/^\s*\*\s*([^@\n][^\n]*)/m);
-    const description = descMatch ? descMatch[1].trim() : methodName;
-
-    // Extract @test annotations with unique IDs
-    const tests = [];
-    const testRegex = /@test\s+(\w+):\s*(.+)/g;
-    let testMatch;
-    let testIndex = 0;
-    while ((testMatch = testRegex.exec(block)) !== null) {
-      tests.push({
-        id: `${methodName}.${testIndex++}`,
-        type: testMatch[1],
-        description: testMatch[2].trim(),
-        completed: false,
-        failReason: null,
-      });
-    }
-
-    // Extract @expect annotations
-    const expects = [];
-    const expectRegex = /@expect\s+(\w+):\s*(.+)/g;
-    let expectMatch;
-    while ((expectMatch = expectRegex.exec(block)) !== null) {
-      expects.push({
-        type: expectMatch[1],
-        description: expectMatch[2].trim(),
-      });
-    }
-
-    if (tests.length || expects.length) {
-      const lineNumber = content.slice(0, match.index).split('\n').length;
-
-      results.push({
-        name: methodName,
-        description,
-        tests,
-        expects,
-        file: filePath,
-        line: lineNumber,
-      });
-    }
-  }
-
-  return results;
-}
-
-/**
- * Find all JS files in directory
- * @param {string} dir 
- * @returns {string[]}
- */
-function findJSFiles(dir) {
-  const files = [];
-
-  try {
-    for (const entry of readdirSync(dir)) {
-      const fullPath = join(dir, entry);
-      const stat = statSync(fullPath);
-
-      if (stat.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules') {
-        files.push(...findJSFiles(fullPath));
-      } else if (entry.endsWith('.js') && !entry.endsWith('.css.js') && !entry.endsWith('.tpl.js')) {
-        files.push(fullPath);
-      }
-    }
-  } catch (e) {
-    // Directory not found
-  }
-
-  return files;
-}
-
-/**
- * Get all features from a directory
- * @param {string} dir 
- * @returns {Feature[]}
- */
-export function getAllFeatures(dir) {
-  const files = findJSFiles(dir);
-  const features = [];
-
-  for (const file of files) {
-    const content = readFileSync(file, 'utf-8');
-    const parsed = parseAnnotations(content, file);
-    features.push(...parsed);
-  }
-
-  return features;
-}
-
-/**
- * Get pending (uncompleted) tests
- * @param {string} dir 
- * @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) {
-      const state = testState.get(test.id);
-      if (!state || !state.completed) {
-        pending.push({
-          ...test,
-          feature: feature.name,
-          file: relative(resolvedDir, feature.file),
-        });
-      }
-    }
-  }
-
-  return pending;
-}
-
-/**
- * Mark a test as passed
- * @param {string} testId 
- */
-export function markTestPassed(testId) {
-  testState.set(testId, { completed: true, passed: true });
-  return { success: true, testId };
-}
-
-/**
- * Mark a test as failed
- * @param {string} testId 
- * @param {string} reason 
- */
-export function markTestFailed(testId, reason) {
-  testState.set(testId, { completed: true, passed: false, reason });
-  return { success: true, testId, reason };
-}
-
-/**
- * Get test summary
- * @param {string} dir 
- * @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++;
-      const state = testState.get(test.id);
-
-      if (!state || !state.completed) {
-        pending++;
-      } else if (state.passed) {
-        passed++;
-      } else {
-        failed++;
-        failures.push({
-          id: test.id,
-          reason: state.reason,
-        });
-      }
-    }
-  }
-
-  return {
-    total,
-    passed,
-    failed,
-    pending,
-    progress: total > 0 ? Math.round((passed + failed) / total * 100) : 0,
-    failures,
-  };
-}
-
-/**
- * Reset test state
- */
-export function resetTestState() {
-  testState.clear();
-  return { success: true };
-}
-
-/**
- * Generate markdown checklist
- * @param {Feature[]} features 
- * @returns {string}
- */
-export function generateMarkdown(features) {
-  const lines = [
-    '# Browser Test Checklist',
-    '',
-    `> Auto-generated from JSDoc @test/@expect annotations`,
-    `> Generated: ${new Date().toISOString().split('T')[0]}`,
-    '',
-  ];
-
-  // Group by file
-  const byFile = {};
-  for (const feature of features) {
-    const key = feature.file;
-    if (!byFile[key]) byFile[key] = [];
-    byFile[key].push(feature);
-  }
-
-  for (const [file, fileFeatures] of Object.entries(byFile)) {
-    lines.push(`## ${basename(file, '.js')}`);
-    lines.push('');
-
-    for (const feature of fileFeatures) {
-      lines.push(`### ${feature.name}()`);
-      lines.push(`${feature.description}`);
-      lines.push('');
-
-      if (feature.tests.length) {
-        lines.push('**Steps:**');
-        for (const test of feature.tests) {
-          const state = testState.get(test.id);
-          const check = state?.passed ? '[x]' : '[ ]';
-          lines.push(`- ${check} \`${test.type}\`: ${test.description}`);
-        }
-        lines.push('');
-      }
-
-      if (feature.expects.length) {
-        lines.push('**Expected:**');
-        for (const expect of feature.expects) {
-          lines.push(`- ✅ \`${expect.type}\`: ${expect.description}`);
-        }
-        lines.push('');
-      }
-    }
-  }
-
-  return lines.join('\n');
-}