project-graph-mcp 1.3.0 → 2.0.0

package/src/filters.js

@@ -1,227 +0,0 @@
-/**
- * Filter Configuration for Project Graph
- * Manages excludes, includes, and gitignore parsing
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join, relative } from 'path';
-
-/**
- * Default directories to exclude
- */
-const DEFAULT_EXCLUDES = [
-  'node_modules',
-  'dist',
-  'build',
-  'coverage',
-  '.next',
-  '.nuxt',
-  '.output',
-  '__pycache__',
-  '.cache',
-  '.turbo',
-  'out',
-];
-
-/**
- * Default file patterns to exclude
- */
-const DEFAULT_EXCLUDE_PATTERNS = [
-  '*.test.js',
-  '*.spec.js',
-  '*.min.js',
-  '*.bundle.js',
-  '*.d.ts',
-  '.project-graph-cache.json',
-];
-
-// Current filter configuration (mutable via MCP)
-let config = {
-  excludeDirs: [...DEFAULT_EXCLUDES],
-  excludePatterns: [...DEFAULT_EXCLUDE_PATTERNS],
-  includeHidden: false,
-  useGitignore: true,
-  gitignorePatterns: [],
-};
-
-/**
- * Get current filter configuration
- * @returns {Object}
- */
-export function getFilters() {
-  return { ...config };
-}
-
-/**
- * Update filter configuration
- * @param {Object} updates
- * @returns {Object}
- */
-export function setFilters(updates) {
-  if (updates.excludeDirs !== undefined) {
-    config.excludeDirs = updates.excludeDirs;
-  }
-  if (updates.excludePatterns !== undefined) {
-    config.excludePatterns = updates.excludePatterns;
-  }
-  if (updates.includeHidden !== undefined) {
-    config.includeHidden = updates.includeHidden;
-  }
-  if (updates.useGitignore !== undefined) {
-    config.useGitignore = updates.useGitignore;
-  }
-  return getFilters();
-}
-
-/**
- * Add directories to exclude list
- * @param {string[]} dirs
- * @returns {Object}
- */
-export function addExcludes(dirs) {
-  config.excludeDirs = [...new Set([...config.excludeDirs, ...dirs])];
-  return getFilters();
-}
-
-/**
- * Remove directories from exclude list
- * @param {string[]} dirs
- * @returns {Object}
- */
-export function removeExcludes(dirs) {
-  config.excludeDirs = config.excludeDirs.filter(d => !dirs.includes(d));
-  return getFilters();
-}
-
-/**
- * Reset filters to defaults
- * @returns {Object}
- */
-export function resetFilters() {
-  config = {
-    excludeDirs: [...DEFAULT_EXCLUDES],
-    excludePatterns: [...DEFAULT_EXCLUDE_PATTERNS],
-    includeHidden: false,
-    useGitignore: true,
-    gitignorePatterns: [],
-  };
-  return getFilters();
-}
-
-/**
- * Parse .gitignore file
- * @param {string} rootDir
- * @returns {string[]}
- */
-export function parseGitignore(rootDir) {
-  const gitignorePath = join(rootDir, '.gitignore');
-
-  if (!existsSync(gitignorePath)) {
-    return [];
-  }
-
-  try {
-    const content = readFileSync(gitignorePath, 'utf-8');
-    const patterns = content
-      .split('\n')
-      .map(line => line.trim())
-      .filter(line => line && !line.startsWith('#'))
-      .map(line => line.replace(/\/$/, '')); // Remove trailing slashes
-
-    config.gitignorePatterns = patterns;
-    return patterns;
-  } catch (e) {
-    return [];
-  }
-}
-
-/**
- * Check if a directory should be excluded
- * @param {string} dirName - Directory name (not path)
- * @param {string} relativePath - Relative path from root
- * @returns {boolean}
- */
-export function shouldExcludeDir(dirName, relativePath = '') {
-  // Check hidden directories
-  if (!config.includeHidden && dirName.startsWith('.')) {
-    return true;
-  }
-
-  // Check default excludes
-  if (config.excludeDirs.includes(dirName)) {
-    return true;
-  }
-
-  // Check gitignore patterns
-  if (config.useGitignore) {
-    for (const pattern of config.gitignorePatterns) {
-      if (matchGitignorePattern(pattern, dirName, relativePath)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-/**
- * Check if a file should be excluded
- * @param {string} fileName
- * @param {string} relativePath
- * @returns {boolean}
- */
-export function shouldExcludeFile(fileName, relativePath = '') {
-  // Check exclude patterns
-  for (const pattern of config.excludePatterns) {
-    if (matchWildcard(pattern, fileName)) {
-      return true;
-    }
-  }
-
-  // Check gitignore patterns
-  if (config.useGitignore) {
-    for (const pattern of config.gitignorePatterns) {
-      if (matchGitignorePattern(pattern, fileName, relativePath)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-/**
- * Match simple wildcard pattern (*.js, *.test.js)
- * @param {string} pattern
- * @param {string} str
- * @returns {boolean}
- */
-function matchWildcard(pattern, str) {
-  const regex = pattern
-    .replace(/\./g, '\\.')
-    .replace(/\*/g, '.*');
-  return new RegExp(`^${regex}$`).test(str);
-}
-
-/**
- * Match gitignore pattern
- * @param {string} pattern
- * @param {string} name
- * @param {string} relativePath
- * @returns {boolean}
- */
-function matchGitignorePattern(pattern, name, relativePath) {
-  // Simple matching: exact name or wildcard
-  if (pattern === name) return true;
-
-  // Pattern with wildcard
-  if (pattern.includes('*')) {
-    return matchWildcard(pattern, name);
-  }
-
-  // Pattern in path
-  const fullPath = relativePath ? `${relativePath}/${name}` : name;
-  if (fullPath.includes(pattern)) return true;
-
-  return false;
-}

package/src/framework-references.js

@@ -1,177 +0,0 @@
-/**
- * Framework Reference System
- * Loads framework-specific AI references from GitHub (with caching) or local files
- */
-
-import { readFileSync, readdirSync, existsSync, writeFileSync } from 'fs';
-import { join, basename, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { detectProjectRuleSets } from './custom-rules.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const REFERENCES_DIR = join(__dirname, '..', 'references');
-
-/**
- * Remote sources for framework references
- * Maps reference name to raw GitHub URL
- */
-const REMOTE_SOURCES = {
-  'symbiote-3x': 'https://raw.githubusercontent.com/symbiotejs/symbiote.js/main/AI_REFERENCE.md',
-};
-
-/** @type {Map<string, {content: string, fetchedAt: number}>} */
-const cache = new Map();
-
-/** Cache TTL: 1 hour */
-const CACHE_TTL = 60 * 60 * 1000;
-
-/**
- * Fetch reference from GitHub with caching
- * Falls back to local file if fetch fails
- * @param {string} name - Reference name
- * @returns {Promise<{content: string, source: string}>}
- */
-async function fetchReference(name) {
-  const url = REMOTE_SOURCES[name];
-  const localPath = join(REFERENCES_DIR, `${name}.md`);
-
-  // Check in-memory cache
-  const cached = cache.get(name);
-  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL) {
-    return { content: cached.content, source: 'cache' };
-  }
-
-  // Try fetching from GitHub
-  if (url) {
-    try {
-      const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
-      if (response.ok) {
-        const content = await response.text();
-        cache.set(name, { content, fetchedAt: Date.now() });
-
-        // Update local file as backup
-        try {
-          writeFileSync(localPath, content, 'utf-8');
-        } catch (e) {
-          // Write failure is non-critical
-        }
-
-        return { content, source: `github (${url})` };
-      }
-    } catch (e) {
-      // Fetch failed — fall back to local
-    }
-  }
-
-  // Fall back to local file
-  if (existsSync(localPath)) {
-    const content = readFileSync(localPath, 'utf-8');
-    cache.set(name, { content, fetchedAt: Date.now() });
-    return { content, source: 'local' };
-  }
-
-  return { content: '', source: 'not_found' };
-}
-
-/**
- * Map ruleset names to reference names
- */
-const RULESET_TO_REFERENCE = {
-  'symbiote-3x': 'symbiote-3x',
-  'symbiote-2x': 'symbiote-3x',
-};
-
-/**
- * List available framework references (local + remote)
- * @returns {string[]}
- */
-function listAvailable() {
-  const names = new Set(Object.keys(REMOTE_SOURCES));
-
-  if (existsSync(REFERENCES_DIR)) {
-    for (const f of readdirSync(REFERENCES_DIR)) {
-      if (f.endsWith('.md')) {
-        names.add(basename(f, '.md'));
-      }
-    }
-  }
-
-  return [...names];
-}
-
-/**
- * Get framework reference content
- * @param {Object} options
- * @param {string} [options.framework] - Explicit framework name
- * @param {string} [options.path] - Project path for auto-detection
- * @returns {Promise<Object>}
- */
-export async function getFrameworkReference(options = {}) {
-  const available = listAvailable();
-
-  // Explicit framework requested
-  if (options.framework) {
-    if (!available.includes(options.framework)) {
-      return {
-        error: `Framework reference '${options.framework}' not found`,
-        available,
-      };
-    }
-
-    const { content, source } = await fetchReference(options.framework);
-    if (!content) {
-      return { error: `Failed to load reference '${options.framework}'`, available };
-    }
-
-    return {
-      framework: options.framework,
-      source,
-      lines: content.split('\n').length,
-      content,
-    };
-  }
-
-  // Auto-detect from project path
-  if (options.path) {
-    const { detected, reasons } = detectProjectRuleSets(options.path);
-
-    const matchedRefs = [];
-    for (const ruleset of detected) {
-      const refName = RULESET_TO_REFERENCE[ruleset];
-      if (refName && available.includes(refName) && !matchedRefs.includes(refName)) {
-        matchedRefs.push(refName);
-      }
-    }
-
-    if (matchedRefs.length === 0) {
-      return {
-        error: 'No framework references found for this project',
-        detected,
-        reasons,
-        available,
-      };
-    }
-
-    const results = await Promise.all(matchedRefs.map(fetchReference));
-    const contents = results.map(r => r.content).filter(Boolean);
-    const sources = results.map(r => r.source);
-
-    return {
-      frameworks: matchedRefs,
-      sources,
-      detected: { rulesets: detected, reasons },
-      lines: contents.reduce((sum, c) => sum + c.split('\n').length, 0),
-      content: contents.join('\n\n---\n\n'),
-    };
-  }
-
-  // No framework specified — list available
-  return {
-    error: 'Specify framework name or path for auto-detection',
-    available: available.map(name => ({
-      name,
-      remote: !!REMOTE_SOURCES[name],
-      url: REMOTE_SOURCES[name] ?? null,
-    })),
-  };
-}

package/src/full-analysis.js

@@ -1,174 +0,0 @@
-/**
- * Full Analysis - Comprehensive Code Health Report
- * Runs all analysis tools and generates a health score
- */
-
-import { getDeadCode } from './dead-code.js';
-import { getUndocumentedSummary } from './undocumented.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 { getTableUsage } from './db-analysis.js';
-
-/**
- * @typedef {Object} AnalysisResult
- * @property {Object} deadCode
- * @property {Object} undocumented
- * @property {Object} similar
- * @property {Object} complexity
- * @property {Object} largeFiles
- * @property {Object} outdated
- * @property {Object} overall
- */
-
-/**
- * Calculate health score from analysis results
- * @param {Object} results 
- * @returns {{score: number, rating: string, topIssues: string[]}}
- */
-function calculateHealthScore(results) {
-  let score = 100;
-  const topIssues = [];
-
-  // Dead code penalty: -2 per item (max -20)
-  const deadPenalty = Math.min(results.deadCode.total * 2, 20);
-  score -= deadPenalty;
-  if (results.deadCode.total > 0) {
-    topIssues.push(`${results.deadCode.total} unused functions/classes`);
-  }
-
-  // Undocumented penalty: -0.5 per item (max -15)
-  const undocPenalty = Math.min(results.undocumented.total * 0.5, 15);
-  score -= undocPenalty;
-  if (results.undocumented.total > 10) {
-    topIssues.push(`${results.undocumented.total} undocumented items`);
-  }
-
-  // Similar functions penalty: -3 per pair (max -15)
-  const similarPenalty = Math.min(results.similar.total * 3, 15);
-  score -= similarPenalty;
-  if (results.similar.total > 0) {
-    topIssues.push(`${results.similar.total} similar function pairs`);
-  }
-
-  // Complexity penalty: -5 per critical, -2 per high (max -20)
-  const criticalCount = results.complexity.stats?.critical || 0;
-  const highCount = results.complexity.stats?.high || 0;
-  const complexityPenalty = Math.min(criticalCount * 5 + highCount * 2, 20);
-  score -= complexityPenalty;
-  if (criticalCount > 0) {
-    topIssues.push(`${criticalCount} critical complexity functions`);
-  }
-
-  // Large files penalty: -4 per critical, -1 per warning (max -10)
-  const largeCritical = results.largeFiles.stats?.critical || 0;
-  const largeWarning = results.largeFiles.stats?.warning || 0;
-  const largePenalty = Math.min(largeCritical * 4 + largeWarning * 1, 10);
-  score -= largePenalty;
-  if (largeCritical > 0) {
-    topIssues.push(`${largeCritical} files need splitting`);
-  }
-
-  // Outdated patterns penalty: -3 per error, -1 per warning (max -10)
-  const errorPatterns = results.outdated.stats?.bySeverity?.error || 0;
-  const warningPatterns = results.outdated.stats?.bySeverity?.warning || 0;
-  const outdatedPenalty = Math.min(errorPatterns * 3 + warningPatterns * 1, 10);
-  score -= outdatedPenalty;
-  if (results.outdated.redundantDeps.length > 0) {
-    topIssues.push(`${results.outdated.redundantDeps.length} redundant npm dependencies`);
-  }
-
-  // Clamp score
-  score = Math.max(0, Math.min(100, Math.round(score)));
-
-  // Determine rating
-  let rating;
-  if (score >= 90) rating = 'excellent';
-  else if (score >= 70) rating = 'good';
-  else if (score >= 50) rating = 'warning';
-  else rating = 'critical';
-
-  return { score, rating, topIssues: topIssues.slice(0, 5) };
-}
-
-/**
- * Run full analysis on directory
- * @param {string} dir 
- * @param {Object} [options]
- * @param {boolean} [options.includeItems=false] - Include individual items
- * @returns {Promise<AnalysisResult>}
- */
-export async function getFullAnalysis(dir, options = {}) {
-  const includeItems = options.includeItems || false;
-
-  // Run all analyses in parallel
-  const [deadCode, undocumented, similar, complexity, largeFiles, outdated, dbUsage] = await Promise.all([
-    getDeadCode(dir),
-    getUndocumentedSummary(dir, 'tests'),
-    getSimilarFunctions(dir, { threshold: 70 }),
-    getComplexity(dir, { minComplexity: 5 }),
-    getLargeFiles(dir),
-    getOutdatedPatterns(dir),
-    getTableUsage(dir).catch(() => ({ tables: [], totalTables: 0, totalQueries: 0 })),
-  ]);
-
-  // Calculate overall health
-  const overall = calculateHealthScore({
-    deadCode,
-    undocumented,
-    similar,
-    complexity,
-    largeFiles,
-    outdated,
-  });
-
-  // Build result
-  const result = {
-    deadCode: {
-      total: deadCode.total,
-      byType: deadCode.byType,
-      ...(includeItems && { items: deadCode.items.slice(0, 10) }),
-    },
-    undocumented: {
-      total: undocumented.total,
-      byType: undocumented.byType,
-      ...(includeItems && { items: undocumented.items.slice(0, 10) }),
-    },
-    similar: {
-      total: similar.total,
-      ...(includeItems && { pairs: similar.pairs.slice(0, 5) }),
-    },
-    complexity: {
-      total: complexity.total,
-      stats: complexity.stats,
-      ...(includeItems && { items: complexity.items.slice(0, 10) }),
-    },
-    largeFiles: {
-      total: largeFiles.total,
-      stats: largeFiles.stats,
-      ...(includeItems && { items: largeFiles.items.slice(0, 10) }),
-    },
-    outdated: {
-      totalPatterns: outdated.stats.totalPatterns,
-      redundantDeps: outdated.redundantDeps,
-      ...(includeItems && { codePatterns: outdated.codePatterns.slice(0, 10) }),
-    },
-    overall,
-  };
-
-  // Add DB metrics if any SQL interactions found (non-scoring)
-  if (dbUsage.totalTables > 0) {
-    result.database = {
-      tablesUsed: dbUsage.totalTables,
-      totalQueries: dbUsage.totalQueries,
-      tables: dbUsage.tables.map(t => ({
-        name: t.table,
-        readers: t.totalReaders,
-        writers: t.totalWriters,
-      })),
-    };
-  }
-
-  return result;
-}