project-graph-mcp 1.5.0 → 2.0.0

package/src/compact.js

@@ -1,207 +0,0 @@
-/**
- * Compact/Beautify — Project-wide code compression and expansion
- * 
- * Converts JS files between compact (minified, no comments) and 
- * beautified (formatted, readable) forms. Both preserve all names
- * (mangle: false) — only whitespace and comments are affected.
- * 
- * Types and documentation live in .ctx files, not in source code.
- */
-
-import { readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
-import { join, extname, relative } from 'path';
-import { minify } from '../vendor/terser.mjs';
-
-const SUPPORTED = new Set(['.js', '.mjs']);
-const SKIP_DIRS = new Set(['node_modules', '.git', 'vendor', '.context', 'dev-docs', '.agent', '.agents']);
-
-/**
- * Walk directory for JS files
- * @param {string} dir
- * @param {string} rootDir
- * @returns {string[]} Absolute paths
- */
-function walkJSFiles(dir, rootDir = dir) {
-  const results = [];
-  try {
-    for (const entry of readdirSync(dir)) {
-      if (entry.startsWith('.') && entry !== '.') continue;
-      const full = join(dir, entry);
-      const stat = statSync(full);
-      if (stat.isDirectory()) {
-        if (!SKIP_DIRS.has(entry)) {
-          results.push(...walkJSFiles(full, rootDir));
-        }
-      } else if (SUPPORTED.has(extname(entry).toLowerCase())) {
-        results.push(full);
-      }
-    }
-  } catch { /* skip unreadable */ }
-  return results;
-}
-
-/**
- * Compact a single file — minify with preserved names
- * @param {string} filePath
- * @returns {Promise<{original: number, compacted: number}>}
- */
-async function compactFile(filePath) {
-  const source = readFileSync(filePath, 'utf-8');
-  const original = source.length;
-
-  if (!source.trim()) return { original: 0, compacted: 0 };
-
-  const result = await minify(source, {
-    compress: {
-      dead_code: true,
-      drop_console: false,
-      passes: 2,
-    },
-    mangle: false,
-    module: true,
-    output: {
-      beautify: false,
-      comments: false,
-      semicolons: true,
-    },
-  });
-
-  if (result.error) throw result.error;
-  
-  writeFileSync(filePath, result.code, 'utf-8');
-  return { original, compacted: result.code.length };
-}
-
-/**
- * Beautify a single file — format with readable output
- * @param {string} filePath
- * @returns {Promise<{original: number, beautified: number}>}
- */
-async function beautifyFile(filePath) {
-  const source = readFileSync(filePath, 'utf-8');
-  const original = source.length;
-
-  if (!source.trim()) return { original: 0, beautified: 0 };
-
-  const result = await minify(source, {
-    compress: false,
-    mangle: false,
-    module: true,
-    output: {
-      beautify: true,
-      comments: false,
-      indent_level: 2,
-      semicolons: true,
-    },
-  });
-
-  if (result.error) throw result.error;
-
-  writeFileSync(filePath, result.code + '\n', 'utf-8');
-  return { original, beautified: result.code.length };
-}
-
-/**
- * Compact all JS files in a directory
- * @param {string} dir - Directory to compact
- * @param {Object} [options]
- * @param {boolean} [options.dryRun=false] - Preview without writing
- * @returns {Promise<{files: number, originalBytes: number, compactedBytes: number, savings: string}>}
- */
-export async function compactProject(dir, options = {}) {
-  const { dryRun = false } = options;
-  const files = walkJSFiles(dir);
-  let totalOriginal = 0;
-  let totalCompacted = 0;
-  const processed = [];
-  const errors = [];
-
-  for (const filePath of files) {
-    const rel = relative(dir, filePath);
-    try {
-      const source = readFileSync(filePath, 'utf-8');
-      totalOriginal += source.length;
-
-      if (!dryRun) {
-        const { compacted } = await compactFile(filePath);
-        totalCompacted += compacted;
-      } else {
-        const result = await minify(source, {
-          compress: { dead_code: true, drop_console: false, passes: 2 },
-          mangle: false,
-          module: true,
-          output: { beautify: false, comments: false },
-        });
-        totalCompacted += result.code?.length || source.length;
-      }
-
-      processed.push(rel);
-    } catch (e) {
-      errors.push({ file: rel, error: e.message });
-    }
-  }
-
-  const savings = totalOriginal > 0
-    ? Math.round((1 - totalCompacted / totalOriginal) * 100)
-    : 0;
-
-  return {
-    files: processed.length,
-    fileList: processed,
-    originalBytes: totalOriginal,
-    compactedBytes: totalCompacted,
-    savings: `${savings}%`,
-    errors: errors.length > 0 ? errors : undefined,
-    dryRun,
-  };
-}
-
-/**
- * Beautify all JS files in a directory
- * @param {string} dir - Directory to beautify
- * @param {Object} [options]
- * @param {boolean} [options.dryRun=false] - Preview without writing
- * @returns {Promise<{files: number, originalBytes: number, beautifiedBytes: number}>}
- */
-export async function expandProject(dir, options = {}) {
-  const { dryRun = false } = options;
-  const files = walkJSFiles(dir);
-  let totalOriginal = 0;
-  let totalBeautified = 0;
-  const processed = [];
-  const errors = [];
-
-  for (const filePath of files) {
-    const rel = relative(dir, filePath);
-    try {
-      const source = readFileSync(filePath, 'utf-8');
-      totalOriginal += source.length;
-
-      if (!dryRun) {
-        const { beautified } = await beautifyFile(filePath);
-        totalBeautified += beautified;
-      } else {
-        const result = await minify(source, {
-          compress: false,
-          mangle: false,
-          module: true,
-          output: { beautify: true, comments: false, indent_level: 2 },
-        });
-        totalBeautified += result.code?.length || source.length;
-      }
-
-      processed.push(rel);
-    } catch (e) {
-      errors.push({ file: rel, error: e.message });
-    }
-  }
-
-  return {
-    files: processed.length,
-    fileList: processed,
-    originalBytes: totalOriginal,
-    beautifiedBytes: totalBeautified,
-    errors: errors.length > 0 ? errors : undefined,
-    dryRun,
-  };
-}

package/src/complexity.js

@@ -1,237 +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 a single file (per-file export for cache integration)
- * @param {string} code - File source code
- * @param {string} relPath - Relative path for reporting
- * @returns {ComplexityItem[]}
- */
-export function analyzeComplexityFile(code, relPath) {
-  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) {
-      if (node.body.type !== 'BlockStatement') return;
-      const complexity = calculateComplexity(node.body);
-      if (complexity > 5) {
-        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;
-}
-
-/**
- * Analyze complexity of file (internal, reads from disk)
- * @param {string} filePath 
- * @param {string} rootDir
- * @returns {ComplexityItem[]}
- */
-function analyzeFile(filePath, rootDir) {
-  let code;
-  try {
-    code = readFileSync(filePath, 'utf-8');
-  } catch (e) {
-    return []; // File deleted between findJSFiles and read
-  }
-  const relPath = relative(rootDir, filePath);
-  return analyzeComplexityFile(code, relPath);
-}
-
-/**
- * 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),
-  };
-}