project-graph-mcp 1.5.0 → 2.1.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,
-    })),
-  };
-}