project-graph-mcp 1.5.0 → 2.1.0

package/src/mode-config.js

@@ -1,127 +0,0 @@
-/**
- * Compact Code Mode Configuration
- *
- * Manages project-level mode selection for the compact code architecture.
- * Reads/writes `.context/config.json` to configure how agents interact with code.
- *
- * Modes:
- *   1 = Native Compact: code stored minified, agent edits directly
- *   2 = Full Storage:   code stored formatted, agent reads compressed view, edits via edit_compressed
- *   3 = Future (IDE):   compact storage with IDE virtual display (reserved)
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-
-const CONFIG_FILE = '.context/config.json';
-
-/** Default configuration */
-const DEFAULTS = {
-  mode: 2,
-  beautify: true,
-  autoValidate: false,
-  stripJSDoc: false,
-};
-
-/**
- * Read project mode configuration from .context/config.json
- * Returns defaults if file doesn't exist.
- *
- * @param {string} projectDir - Project root directory
- * @returns {{ mode: number, beautify: boolean, autoValidate: boolean, stripJSDoc: boolean }}
- */
-export function getConfig(projectDir) {
-  const configPath = join(projectDir, CONFIG_FILE);
-
-  if (!existsSync(configPath)) {
-    return { ...DEFAULTS };
-  }
-
-  try {
-    const raw = readFileSync(configPath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    return { ...DEFAULTS, ...parsed };
-  } catch {
-    return { ...DEFAULTS };
-  }
-}
-
-/**
- * Write project mode configuration to .context/config.json
- *
- * @param {string} projectDir - Project root directory
- * @param {Object} config - Configuration to save (merged with existing)
- * @returns {{ saved: boolean, path: string, config: Object }}
- */
-export function setConfig(projectDir, config) {
-  const configPath = join(projectDir, CONFIG_FILE);
-  const dir = dirname(configPath);
-
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-
-  // Merge with existing
-  const existing = getConfig(projectDir);
-  const merged = { ...existing, ...config };
-
-  // Validate mode
-  if (![1, 2, 3].includes(merged.mode)) {
-    throw new Error(`Invalid mode: ${merged.mode}. Valid: 1 (compact), 2 (full), 3 (IDE)`);
-  }
-
-  writeFileSync(configPath, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
-
-  return {
-    saved: true,
-    path: configPath,
-    config: merged,
-  };
-}
-
-/**
- * Get human-readable description of current mode
- * @param {number} mode
- * @returns {string}
- */
-export function getModeDescription(mode) {
-  switch (mode) {
-    case 1: return 'Native Compact — code stored minified, agent edits directly';
-    case 2: return 'Full Storage — code stored formatted, agent uses get_compressed_file + edit_compressed';
-    case 3: return 'IDE Virtual — compact storage with IDE virtual display (future)';
-    default: return `Unknown mode: ${mode}`;
-  }
-}
-
-/**
- * Get recommended workflow for current mode
- * @param {number} mode
- * @returns {{ read: string, edit: string, docs: string, validate: string }}
- */
-export function getModeWorkflow(mode) {
-  switch (mode) {
-    case 1:
-      return {
-        read: 'Read .js files directly (already compact)',
-        edit: 'Edit .js files directly',
-        docs: 'Read .ctx files for types and descriptions',
-        validate: 'Run validate-ctx to check .ctx ↔ AST consistency',
-      };
-    case 2:
-      return {
-        read: 'Use get_compressed_file for token-efficient reading',
-        edit: 'Use edit_compressed(path, symbol, code) for AST-safe editing',
-        docs: 'Read .ctx files for types and descriptions',
-        validate: 'Run validate-ctx to check .ctx ↔ AST consistency',
-      };
-    case 3:
-      return {
-        read: 'IDE renders full view from compact storage',
-        edit: 'IDE handles bidirectional mapping',
-        docs: 'Managed by IDE plugin',
-        validate: 'Automatic via IDE integration',
-      };
-    default:
-      return { read: 'N/A', edit: 'N/A', docs: 'N/A', validate: 'N/A' };
-  }
-}

package/src/outdated-patterns.js

@@ -1,296 +0,0 @@
-/**
- * Outdated Patterns Detector
- * Finds legacy code patterns and redundant npm dependencies
- */
-
-import { readFileSync, readdirSync, statSync, existsSync } 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';
-
-/**
- * Redundant npm packages that are now built into Node.js 18+
- */
-const REDUNDANT_DEPS = {
-  'node-fetch': { replacement: 'fetch()', since: 'Node 18' },
-  'cross-fetch': { replacement: 'fetch()', since: 'Node 18' },
-  'isomorphic-fetch': { replacement: 'fetch()', since: 'Node 18' },
-  'uuid': { replacement: 'crypto.randomUUID()', since: 'Node 19' },
-  'deep-clone': { replacement: 'structuredClone()', since: 'Node 17' },
-  'lodash.clonedeep': { replacement: 'structuredClone()', since: 'Node 17' },
-  'abort-controller': { replacement: 'AbortController (global)', since: 'Node 15' },
-  'form-data': { replacement: 'FormData (global)', since: 'Node 18' },
-  'web-streams-polyfill': { replacement: 'ReadableStream (global)', since: 'Node 18' },
-  'url-parse': { replacement: 'URL (global)', since: 'Node 10' },
-  'querystring': { replacement: 'URLSearchParams', since: 'Node 10' },
-  'rimraf': { replacement: 'fs.rm({ recursive: true })', since: 'Node 14' },
-  'mkdirp': { replacement: 'fs.mkdir({ recursive: true })', since: 'Node 10' },
-  'recursive-readdir': { replacement: 'fs.readdir({ recursive: true })', since: 'Node 20' },
-  'glob': { replacement: 'fs.glob()', since: 'Node 22' },
-};
-
-/**
- * Legacy code patterns to detect
- */
-const CODE_PATTERNS = [
-  {
-    name: 'var-usage',
-    description: 'Use const/let instead of var',
-    check: (node) => node.type === 'VariableDeclaration' && node.kind === 'var',
-    severity: 'warning',
-    replacement: 'const/let',
-  },
-  {
-    name: 'require-usage',
-    description: 'Use ESM import instead of require()',
-    check: (node) => node.type === 'CallExpression' &&
-      node.callee.type === 'Identifier' && node.callee.name === 'require',
-    severity: 'info',
-    replacement: 'import ... from',
-  },
-  {
-    name: 'module-exports',
-    description: 'Use ESM export instead of module.exports',
-    check: (node) => node.type === 'AssignmentExpression' &&
-      node.left.type === 'MemberExpression' &&
-      node.left.object.type === 'Identifier' && node.left.object.name === 'module' &&
-      node.left.property.type === 'Identifier' && node.left.property.name === 'exports',
-    severity: 'info',
-    replacement: 'export default/export',
-  },
-  {
-    name: 'buffer-constructor',
-    description: 'new Buffer() is deprecated',
-    check: (node) => node.type === 'NewExpression' &&
-      node.callee.type === 'Identifier' && node.callee.name === 'Buffer',
-    severity: 'error',
-    replacement: 'Buffer.from() / Buffer.alloc()',
-  },
-  {
-    name: 'arguments-usage',
-    description: 'Use rest parameters instead of arguments',
-    check: (node) => node.type === 'Identifier' && node.name === 'arguments',
-    severity: 'warning',
-    replacement: '...args',
-  },
-  {
-    name: 'promisify-usage',
-    description: 'Use fs/promises instead of util.promisify',
-    check: (node) => node.type === 'CallExpression' &&
-      node.callee.type === 'MemberExpression' &&
-      node.callee.object.type === 'Identifier' && node.callee.object.name === 'util' &&
-      node.callee.property.type === 'Identifier' && node.callee.property.name === 'promisify',
-    severity: 'info',
-    replacement: 'fs/promises module',
-  },
-  {
-    name: 'sync-in-async',
-    description: 'Avoid sync methods in async context (readFileSync, etc.)',
-    check: (node, context) => {
-      if (node.type !== 'CallExpression') return false;
-      const callee = node.callee;
-      if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier') {
-        const name = callee.property.name;
-        return name.endsWith('Sync') && context.inAsync;
-      }
-      return false;
-    },
-    severity: 'warning',
-    replacement: 'async fs/promises methods',
-  },
-];
-
-/**
- * @typedef {Object} PatternMatch
- * @property {string} pattern
- * @property {string} description
- * @property {string} file
- * @property {number} line
- * @property {string} severity
- * @property {string} replacement
- */
-
-/**
- * @typedef {Object} RedundantDep
- * @property {string} name
- * @property {string} replacement
- * @property {string} since
- */
-
-/**
- * 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;
-}
-
-/**
- * Analyze file for outdated patterns
- * @param {string} filePath 
- * @param {string} rootDir - Root directory for relative path calculation
- * @returns {PatternMatch[]}
- */
-function analyzeFilePatterns(filePath, rootDir) {
-  const code = readFileSync(filePath, 'utf-8');
-  const relPath = relative(rootDir, filePath);
-  const matches = [];
-
-  let ast;
-  try {
-    ast = parse(code, { ecmaVersion: 'latest', sourceType: 'module', locations: true });
-  } catch (e) {
-    return matches;
-  }
-
-  // Track async context
-  const context = { inAsync: false };
-
-  walk.simple(ast, {
-    FunctionDeclaration(node) {
-      context.inAsync = node.async;
-    },
-    ArrowFunctionExpression(node) {
-      context.inAsync = node.async;
-    },
-  });
-
-  // Reset and check patterns
-  context.inAsync = false;
-
-  walk.ancestor(ast, {
-    '*'(node, ancestors) {
-      // Update async context
-      for (const anc of ancestors) {
-        if ((anc.type === 'FunctionDeclaration' || anc.type === 'ArrowFunctionExpression' ||
-          anc.type === 'FunctionExpression') && anc.async) {
-          context.inAsync = true;
-          break;
-        }
-      }
-
-      for (const pattern of CODE_PATTERNS) {
-        if (pattern.check(node, context)) {
-          matches.push({
-            pattern: pattern.name,
-            description: pattern.description,
-            file: relPath,
-            line: node.loc?.start?.line || 0,
-            severity: pattern.severity,
-            replacement: pattern.replacement,
-          });
-        }
-      }
-    },
-  });
-
-  return matches;
-}
-
-/**
- * Analyze package.json for redundant dependencies
- * @param {string} dir 
- * @returns {RedundantDep[]}
- */
-function analyzePackageJson(dir) {
-  const pkgPath = join(dir, 'package.json');
-  const redundant = [];
-
-  if (!existsSync(pkgPath)) return redundant;
-
-  try {
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-    const allDeps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies,
-    };
-
-    for (const depName of Object.keys(allDeps)) {
-      if (REDUNDANT_DEPS[depName]) {
-        redundant.push({
-          name: depName,
-          ...REDUNDANT_DEPS[depName],
-        });
-      }
-    }
-  } catch (e) { }
-
-  return redundant;
-}
-
-/**
- * Get outdated patterns analysis
- * @param {string} dir 
- * @param {Object} [options]
- * @param {boolean} [options.codeOnly=false] - Only check code patterns
- * @param {boolean} [options.depsOnly=false] - Only check dependencies
- * @returns {Promise<{codePatterns: PatternMatch[], redundantDeps: RedundantDep[], stats: Object}>}
- */
-export async function getOutdatedPatterns(dir, options = {}) {
-  const codeOnly = options.codeOnly || false;
-  const depsOnly = options.depsOnly || false;
-  const resolvedDir = resolve(dir);
-
-  let codePatterns = [];
-  let redundantDeps = [];
-
-  if (!depsOnly) {
-    const files = findJSFiles(dir);
-    for (const file of files) {
-      codePatterns.push(...analyzeFilePatterns(file, resolvedDir));
-    }
-    // Sort by severity
-    const severityOrder = { error: 0, warning: 1, info: 2 };
-    codePatterns.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
-  }
-
-  if (!codeOnly) {
-    redundantDeps = analyzePackageJson(dir);
-  }
-
-  const stats = {
-    totalPatterns: codePatterns.length,
-    byPattern: {},
-    bySeverity: {
-      error: codePatterns.filter(p => p.severity === 'error').length,
-      warning: codePatterns.filter(p => p.severity === 'warning').length,
-      info: codePatterns.filter(p => p.severity === 'info').length,
-    },
-    redundantDeps: redundantDeps.length,
-  };
-
-  // Group by pattern name
-  for (const p of codePatterns) {
-    stats.byPattern[p.pattern] = (stats.byPattern[p.pattern] || 0) + 1;
-  }
-
-  return {
-    codePatterns: codePatterns.slice(0, 50),
-    redundantDeps,
-    stats,
-  };
-}