project-graph-mcp 1.3.0 → 2.0.0

package/src/cli-handlers.js

@@ -1,140 +0,0 @@
-/**
- * CLI Command Handlers Registry
- * Extracted from cli.js to reduce cyclomatic complexity
- */
-
-import { getSkeleton, getFocusZone, expand, deps, usages } from './tools.js';
-import { getPendingTests, getTestSummary } from './test-annotations.js';
-import { getFilters } from './filters.js';
-import { getInstructions } from './instructions.js';
-import { getUndocumentedSummary } from './undocumented.js';
-import { getDeadCode } from './dead-code.js';
-import { generateJSDoc } from './jsdoc-generator.js';
-import { getSimilarFunctions } from './similar-functions.js';
-import { getComplexity } from './complexity.js';
-import { getLargeFiles } from './large-files.js';
-import { getOutdatedPatterns } from './outdated-patterns.js';
-import { getFullAnalysis } from './full-analysis.js';
-import { resolvePath } from './workspace.js';
-
-/**
- * Parse named argument from args array
- * @param {string[]} args 
- * @param {string} name 
- * @returns {string|undefined}
- */
-function getArg(args, name) {
-  const arg = args.find(a => a.startsWith(`--${name}=`));
-  return arg ? arg.split('=')[1] : undefined;
-}
-
-/**
- * Get path argument (first non-flag arg), resolved against workspace root
- * @param {string[]} args 
- * @returns {string}
- */
-function getPath(args) {
-  const raw = args.find(a => !a.startsWith('--')) || '.';
-  return resolvePath(raw);
-}
-
-/**
- * CLI command handlers registry
- * Each handler returns a result or throws an error
- */
-export const CLI_HANDLERS = {
-  skeleton: {
-    requiresArg: true,
-    argError: 'Path required: skeleton <path>',
-    handler: async (args) => getSkeleton(resolvePath(args[0])),
-  },
-
-  expand: {
-    requiresArg: true,
-    argError: 'Symbol required: expand <symbol>',
-    handler: async (args) => expand(args[0]),
-  },
-
-  deps: {
-    requiresArg: true,
-    argError: 'Symbol required: deps <symbol>',
-    handler: async (args) => deps(args[0]),
-  },
-
-  usages: {
-    requiresArg: true,
-    argError: 'Symbol required: usages <symbol>',
-    handler: async (args) => usages(args[0]),
-  },
-
-  pending: {
-    handler: async (args) => getPendingTests(getPath(args)),
-  },
-
-  summary: {
-    handler: async (args) => getTestSummary(getPath(args)),
-  },
-
-  filters: {
-    handler: async () => getFilters(),
-  },
-
-  instructions: {
-    rawOutput: true,
-    handler: async () => getInstructions(),
-  },
-
-  undocumented: {
-    handler: async (args) => {
-      const level = getArg(args, 'level') || 'tests';
-      return getUndocumentedSummary(getPath(args), level);
-    },
-  },
-
-  deadcode: {
-    handler: async (args) => getDeadCode(getPath(args)),
-  },
-
-  jsdoc: {
-    requiresArg: true,
-    argError: 'Usage: jsdoc <file>',
-    handler: async (args) => generateJSDoc(resolvePath(args[0])),
-  },
-
-  similar: {
-    handler: async (args) => {
-      const threshold = parseInt(getArg(args, 'threshold')) || 60;
-      return getSimilarFunctions(getPath(args), { threshold });
-    },
-  },
-
-  complexity: {
-    handler: async (args) => {
-      const minComplexity = parseInt(getArg(args, 'min')) || 1;
-      const onlyProblematic = args.includes('--problematic');
-      return getComplexity(getPath(args), { minComplexity, onlyProblematic });
-    },
-  },
-
-  largefiles: {
-    handler: async (args) => {
-      const onlyProblematic = args.includes('--problematic');
-      return getLargeFiles(getPath(args), { onlyProblematic });
-    },
-  },
-
-  outdated: {
-    handler: async (args) => {
-      const codeOnly = args.includes('--code');
-      const depsOnly = args.includes('--deps');
-      return getOutdatedPatterns(getPath(args), { codeOnly, depsOnly });
-    },
-  },
-
-  analyze: {
-    handler: async (args) => {
-      const includeItems = args.includes('--items');
-      return getFullAnalysis(getPath(args), { includeItems });
-    },
-  },
-};

package/src/cli.js

@@ -1,83 +0,0 @@
-/**
- * CLI Entry Point for Project Graph MCP
- */
-
-import { CLI_HANDLERS } from './cli-handlers.js';
-
-/**
- * Print CLI help
- */
-export function printHelp() {
-  console.log(`
-project-graph-mcp - MCP server for AI agents
-
-Usage:
-  npx project-graph-mcp                  Start MCP stdio server
-  npx project-graph-mcp <command> [args] Run CLI command
-
-Commands:
-  skeleton <path>        Get compact project overview
-  expand <symbol>        Expand minified symbol (e.g., SN, SN.togglePin)
-  deps <symbol>          Get dependency tree
-  usages <symbol>        Find all usages
-  pending <path>         List pending @test/@expect tests
-  summary <path>         Get test progress summary
-  undocumented <path>    Find missing JSDoc (--level=tests|params|all)
-  deadcode <path>        Find unused functions/classes
-  jsdoc <file>           Generate JSDoc for file
-  similar <path>         Find similar functions (--threshold=60)
-  complexity <path>      Analyze cyclomatic complexity (--min=1)
-  largefiles <path>      Find files needing split (--problematic)
-  outdated <path>        Find legacy patterns & redundant deps
-  analyze <path>         Run ALL checks with Health Score
-  filters                Show current filter configuration
-  instructions           Show agent guidelines (JSDoc, Arch)
-  help                   Show this help
-
-Examples:
-  npx project-graph-mcp skeleton src/components
-  npx project-graph-mcp expand SN
-  npx project-graph-mcp pending src/
-`);
-}
-
-/**
- * Run CLI command
- * @param {string} command 
- * @param {string[]} args 
- */
-export async function runCLI(command, args) {
-  // Handle help commands
-  if (!command || command === 'help' || command === '--help' || command === '-h') {
-    printHelp();
-    return;
-  }
-
-  // Look up handler
-  const def = CLI_HANDLERS[command];
-  if (!def) {
-    console.error(`Unknown command: ${command}`);
-    console.error('Run with "help" for usage information');
-    process.exit(1);
-  }
-
-  // Validate required arg
-  if (def.requiresArg && !args[0]) {
-    console.error(def.argError || `Argument required for: ${command}`);
-    process.exit(1);
-  }
-
-  try {
-    const result = await def.handler(args);
-
-    // Handle raw output (like instructions)
-    if (def.rawOutput) {
-      console.log(result);
-    } else {
-      console.log(JSON.stringify(result, null, 2));
-    }
-  } catch (error) {
-    console.error('Error:', error.message);
-    process.exit(1);
-  }
-}

package/src/complexity.js

@@ -1,223 +0,0 @@
-/**
- * Cyclomatic Complexity Analyzer
- * Measures function complexity based on decision points
- */
-
-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} ComplexityItem
- * @property {string} name
- * @property {string} type - 'function' | 'method'
- * @property {string} file
- * @property {number} line
- * @property {number} complexity - Cyclomatic complexity score
- * @property {string} rating - 'low' | 'moderate' | 'high' | 'critical'
- */
-
-/**
- * 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;
-}
-
-/**
- * Calculate complexity of a function body
- * @param {Object} body 
- * @returns {number}
- */
-function calculateComplexity(body) {
-  let complexity = 1; // Base complexity
-
-  walk.simple(body, {
-    // Branching
-    IfStatement() { complexity++; },
-    ConditionalExpression() { complexity++; }, // ternary
-
-    // Loops
-    ForStatement() { complexity++; },
-    ForOfStatement() { complexity++; },
-    ForInStatement() { complexity++; },
-    WhileStatement() { complexity++; },
-    DoWhileStatement() { complexity++; },
-
-    // Switch cases
-    SwitchCase(node) {
-      if (node.test) complexity++; // Skip default case
-    },
-
-    // Logical operators
-    LogicalExpression(node) {
-      if (node.operator === '&&' || node.operator === '||') {
-        complexity++;
-      }
-    },
-
-    // Nullish coalescing
-    BinaryExpression(node) {
-      if (node.operator === '??') {
-        complexity++;
-      }
-    },
-
-    // Error handling
-    CatchClause() { complexity++; },
-  });
-
-  return complexity;
-}
-
-/**
- * Get rating from complexity score
- * @param {number} complexity 
- * @returns {string}
- */
-function getRating(complexity) {
-  if (complexity <= 5) return 'low';
-  if (complexity <= 10) return 'moderate';
-  if (complexity <= 20) return 'high';
-  return 'critical';
-}
-
-/**
- * Analyze complexity of file
- * @param {string} filePath 
- * @returns {ComplexityItem[]}
- */
-function analyzeFile(filePath, rootDir) {
-  const code = readFileSync(filePath, 'utf-8');
-  const relPath = relative(rootDir, filePath);
-  const items = [];
-
-  let ast;
-  try {
-    ast = parse(code, { ecmaVersion: 'latest', sourceType: 'module', locations: true });
-  } catch (e) {
-    return items;
-  }
-
-  walk.simple(ast, {
-    FunctionDeclaration(node) {
-      if (!node.id) return;
-      const complexity = calculateComplexity(node.body);
-      items.push({
-        name: node.id.name,
-        type: 'function',
-        file: relPath,
-        line: node.loc.start.line,
-        complexity,
-        rating: getRating(complexity),
-      });
-    },
-
-    ArrowFunctionExpression(node) {
-      // Skip small arrow functions
-      if (node.body.type !== 'BlockStatement') return;
-      const complexity = calculateComplexity(node.body);
-      if (complexity > 5) {
-        // Only report complex arrow functions
-        items.push({
-          name: '(arrow)',
-          type: 'function',
-          file: relPath,
-          line: node.loc.start.line,
-          complexity,
-          rating: getRating(complexity),
-        });
-      }
-    },
-
-    MethodDefinition(node) {
-      if (node.kind !== 'method') return;
-      const name = node.key.name || node.key.value;
-      const complexity = calculateComplexity(node.value.body);
-      items.push({
-        name,
-        type: 'method',
-        file: relPath,
-        line: node.loc.start.line,
-        complexity,
-        rating: getRating(complexity),
-      });
-    },
-  });
-
-  return items;
-}
-
-/**
- * Get complexity analysis for directory
- * @param {string} dir 
- * @param {Object} [options]
- * @param {number} [options.minComplexity=1] - Minimum complexity to include
- * @param {boolean} [options.onlyProblematic=false] - Only show high/critical
- * @returns {Promise<{total: number, stats: Object, items: ComplexityItem[]}>}
- */
-export async function getComplexity(dir, options = {}) {
-  const minComplexity = options.minComplexity || 1;
-  const onlyProblematic = options.onlyProblematic || false;
-  const resolvedDir = resolve(dir);
-
-  const files = findJSFiles(dir);
-  let allItems = [];
-
-  for (const file of files) {
-    allItems.push(...analyzeFile(file, resolvedDir));
-  }
-
-  // Filter
-  allItems = allItems.filter(item => {
-    if (item.complexity < minComplexity) return false;
-    if (onlyProblematic && (item.rating === 'low' || item.rating === 'moderate')) return false;
-    return true;
-  });
-
-  // Sort by complexity descending
-  allItems.sort((a, b) => b.complexity - a.complexity);
-
-  // Calculate stats
-  const stats = {
-    low: allItems.filter(i => i.rating === 'low').length,
-    moderate: allItems.filter(i => i.rating === 'moderate').length,
-    high: allItems.filter(i => i.rating === 'high').length,
-    critical: allItems.filter(i => i.rating === 'critical').length,
-    average: allItems.length > 0
-      ? Math.round(allItems.reduce((s, i) => s + i.complexity, 0) / allItems.length * 10) / 10
-      : 0,
-  };
-
-  return {
-    total: allItems.length,
-    stats,
-    items: allItems.slice(0, 30),
-  };
-}