mcp-code-context 2.2.0 → 2.4.0

package/src/utils/fuzzyMatch.ts

@@ -1,86 +0,0 @@
-export interface SymbolInfo {
-  name: string;
-  type: string;
-  className?: string;
-}
-
-export function levenshteinDistance(a: string, b: string): number {
-  const matrix = [];
-  let i, j;
-
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-
-  for (i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-  for (j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-
-  for (i = 1; i <= b.length; i++) {
-    for (j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1,
-          Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1)
-        );
-      }
-    }
-  }
-
-  return matrix[b.length][a.length];
-}
-
-export function findClosestSymbols(target: string, symbols: SymbolInfo[], limit = 5): SymbolInfo[] {
-  return symbols
-    .map((sym) => ({
-      ...sym,
-      distance: levenshteinDistance(target.toLowerCase(), sym.name.toLowerCase()),
-    }))
-    .sort((a, b) => a.distance - b.distance)
-    .slice(0, limit);
-}
-
-// A simple regex-based extractor to get available symbols when the AST parsing fails
-export function extractFallbackSymbols(content: string): SymbolInfo[] {
-  const symbols: SymbolInfo[] = [];
-  const lines = content.split('\\n');
-  
-  let currentClass: string | undefined = undefined;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    
-    // Check for class definitions (multi-language approx)
-    const classMatch = line.match(/^\s*(?:export\s+|abstract\s+|final\s+)?class\s+([_a-zA-Z0-9]+)/);
-    if (classMatch) {
-      currentClass = classMatch[1];
-      symbols.push({ name: currentClass, type: 'class' });
-      continue;
-    }
-
-    // Check for function / method definitions
-    // JS/TS: function foo() | foo() { | async foo()
-    // Python: def foo()
-    // PHP: function foo()
-    // Dart: type foo()
-    const funcMatch = line.match(/^\s*(?:export\s+|async\s+|public\s+|private\s+|protected\s+|static\s+|def\s+|function\s+)*([_a-zA-Z0-9]+)\s*\(/);
-    if (funcMatch && !['if', 'else', 'for', 'while', 'switch', 'catch'].includes(funcMatch[1])) {
-      symbols.push({
-        name: funcMatch[1],
-        type: currentClass ? 'method' : 'function',
-        className: currentClass,
-      });
-    }
-
-    // Basic assumption: closing brace at start of line might end a class
-    if (line === '}') {
-      currentClass = undefined;
-    }
-  }
-
-  return symbols;
-}

package/src/utils/ignoreManager.ts

@@ -1,144 +0,0 @@
-/**
- * IgnoreManager — Reads .gitignore / .repomixignore and walks directories
- * filtering out ignored paths. Always excludes common heavy directories.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createRequire } from "node:module";
-import type { Ignore } from "ignore";
-
-// CJS interop: 'ignore' uses module.exports which doesn't resolve
-// as a callable default export under Node16 module resolution.
-const require = createRequire(import.meta.url);
-const ignore: (opts?: Record<string, unknown>) => Ignore = require("ignore");
-
-/** Directories and patterns that are ALWAYS excluded regardless of .gitignore */
-const ALWAYS_IGNORE: string[] = [
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "vendor",
-  ".next",
-  ".nuxt",
-  ".output",
-  "__pycache__",
-  ".pytest_cache",
-  "coverage",
-  ".nyc_output",
-  ".turbo",
-  ".cache",
-  ".parcel-cache",
-  ".venv",
-  "venv",
-  "env",
-  ".env.local",
-  ".tsbuildinfo",
-  "*.lock",
-  "package-lock.json",
-  "yarn.lock",
-  "pnpm-lock.yaml",
-  "bun.lockb",
-  "*.min.js",
-  "*.min.css",
-  "*.map",
-  "*.chunk.js",
-  "*.bundle.js",
-];
-
-/** Max file size to read (512 KB). Files larger than this are skipped. */
-const MAX_FILE_SIZE_BYTES = 512 * 1024;
-
-export class IgnoreManager {
-  private ig: Ignore;
-  private rootDir: string;
-
-  constructor(rootDir: string) {
-    this.rootDir = path.resolve(rootDir);
-    this.ig = ignore();
-
-    // Load hardcoded ignores first
-    this.ig.add(ALWAYS_IGNORE);
-
-    // Load .gitignore
-    this.loadIgnoreFile(path.join(this.rootDir, ".gitignore"));
-
-    // Load .repomixignore (Repomix-style overrides)
-    this.loadIgnoreFile(path.join(this.rootDir, ".repomixignore"));
-  }
-
-  /**
-   * Reads an ignore-pattern file and adds its rules to the filter.
-   * Silently skips if the file doesn't exist or is unreadable.
-   */
-  private loadIgnoreFile(filePath: string): void {
-    try {
-      if (!fs.existsSync(filePath)) return;
-
-      const content = fs.readFileSync(filePath, "utf-8");
-      const patterns = content
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0 && !line.startsWith("#"));
-
-      if (patterns.length > 0) {
-        this.ig.add(patterns);
-      }
-    } catch {
-      // File unreadable — skip silently
-    }
-  }
-
-  /** Check if a relative path should be ignored. */
-  public isIgnored(relativePath: string): boolean {
-    if (!relativePath) return false;
-    return this.ig.ignores(relativePath);
-  }
-
-  /**
-   * Recursively walk a directory, returning absolute paths to all
-   * non-ignored files.
-   */
-  public walkDirectory(dir?: string): string[] {
-    const baseDir = dir ? path.resolve(dir) : this.rootDir;
-    const files: string[] = [];
-    this.walk(baseDir, files);
-    return files;
-  }
-
-  private walk(currentDir: string, collected: string[]): void {
-    let entries: fs.Dirent[];
-    try {
-      entries = fs.readdirSync(currentDir, { withFileTypes: true });
-    } catch {
-      return; // Permission denied, broken symlink, etc.
-    }
-
-    for (const entry of entries) {
-      const fullPath = path.join(currentDir, entry.name);
-      const relativePath = path
-        .relative(this.rootDir, fullPath)
-        .replace(/\\/g, "/");
-
-      // Check ignore rules
-      if (this.isIgnored(relativePath)) continue;
-
-      if (entry.isDirectory()) {
-        // Also test with trailing slash for directory-level patterns
-        if (this.isIgnored(relativePath + "/")) continue;
-        this.walk(fullPath, collected);
-      } else if (entry.isFile()) {
-        // Skip files that are too large
-        try {
-          const stat = fs.statSync(fullPath);
-          if (stat.size > MAX_FILE_SIZE_BYTES) continue;
-        } catch {
-          continue;
-        }
-        collected.push(fullPath);
-      }
-      // Symlinks and other entries are silently skipped
-    }
-  }
-}

package/src/utils/projectRoot.ts

@@ -1,44 +0,0 @@
-/**
- * projectRoot.ts — Project Root Discovery Utility
- * 
- * Finds the root directory of a project by looking for common markers.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-const ROOT_MARKERS = [
-  "package.json",
-  ".git",
-  "pyproject.toml",
-  "setup.py",
-  "Cargo.toml",
-  "go.mod",
-  "pom.xml",
-  "build.gradle",
-  "CMakeLists.txt",
-  ".gitignore",
-  "Gemfile",
-  "composer.json",
-  "pubspec.yaml",
-];
-
-/**
- * Find the project root by walking up from a file path.
- * Returns undefined if no root marker is found.
- */
-export function findProjectRoot(filePath: string): string | undefined {
-  let current = path.dirname(path.resolve(filePath));
-  const root = path.parse(current).root;
-
-  while (current !== root) {
-    for (const marker of ROOT_MARKERS) {
-      if (fs.existsSync(path.join(current, marker))) {
-        return current;
-      }
-    }
-    current = path.dirname(current);
-  }
-
-  return undefined;
-}

package/tests/test-backup-system.ts

@@ -1,174 +0,0 @@
-/**
- * Tests for Centralized Backup System
- * - Backup creation in project root
- * - Folder structure preservation
- * - clean_backups functionality
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { createBackup, cleanAllBackups } from '../src/utils/backupManager.js';
-import { findProjectRoot } from '../src/utils/projectRoot.js';
-
-const TEST_DIR = path.join(process.cwd(), 'tests', 'fixtures', 'backup-test-project');
-const TEST_FILE = path.join(TEST_DIR, 'src', 'components', 'Button.tsx');
-
-function setupTestProject() {
-  // Create test project structure
-  if (fs.existsSync(TEST_DIR)) {
-    fs.rmSync(TEST_DIR, { recursive: true, force: true });
-  }
-  
-  fs.mkdirSync(path.join(TEST_DIR, 'src', 'components'), { recursive: true });
-  fs.writeFileSync(TEST_FILE, 'export const Button = () => <button>Click</button>;');
-  
-  // Create package.json to mark as project root
-  fs.writeFileSync(
-    path.join(TEST_DIR, 'package.json'),
-    JSON.stringify({ name: 'backup-test-project' })
-  );
-}
-
-function cleanupTestProject() {
-  if (fs.existsSync(TEST_DIR)) {
-    fs.rmSync(TEST_DIR, { recursive: true, force: true });
-  }
-}
-
-function runTests() {
-  console.log('\n🧪 Testing Centralized Backup System...\n');
-  
-  let passed = 0;
-  let failed = 0;
-  
-  // Setup
-  setupTestProject();
-  
-  try {
-    // Test 1: Find project root
-    console.log('Test 1: Find project root');
-    const projectRoot = findProjectRoot(TEST_FILE);
-    if (projectRoot === TEST_DIR) {
-      console.log('✅ PASS: Project root found correctly');
-      passed++;
-    } else {
-      console.log(`❌ FAIL: Expected ${TEST_DIR}, got ${projectRoot}`);
-      failed++;
-    }
-    
-    // Test 2: Create backup in centralized location
-    console.log('\nTest 2: Create backup in centralized location');
-    const backupPath = createBackup(TEST_FILE);
-    
-    const expectedBackupDir = path.join(TEST_DIR, '.mcp-backups', 'src', 'components');
-    const backupExists = fs.existsSync(backupPath);
-    const inCorrectLocation = backupPath.startsWith(expectedBackupDir);
-    
-    if (backupExists && inCorrectLocation) {
-      console.log('✅ PASS: Backup created in centralized location');
-      console.log(`   Location: ${backupPath}`);
-      passed++;
-    } else {
-      console.log('❌ FAIL: Backup not in correct location');
-      console.log(`   Expected dir: ${expectedBackupDir}`);
-      console.log(`   Actual path: ${backupPath}`);
-      failed++;
-    }
-    
-    // Test 3: Backup preserves folder structure
-    console.log('\nTest 3: Backup preserves folder structure');
-    const relativePath = path.relative(TEST_DIR, TEST_FILE);
-    const expectedStructure = path.join('.mcp-backups', relativePath);
-    const actualStructure = path.relative(TEST_DIR, backupPath.replace(/\.\d+\.backup$/, ''));
-    
-    if (actualStructure.startsWith(expectedStructure)) {
-      console.log('✅ PASS: Folder structure preserved');
-      console.log(`   Structure: ${expectedStructure}`);
-      passed++;
-    } else {
-      console.log('❌ FAIL: Folder structure not preserved');
-      console.log(`   Expected: ${expectedStructure}`);
-      console.log(`   Actual: ${actualStructure}`);
-      failed++;
-    }
-    
-    // Test 4: Multiple backups in same location
-    console.log('\nTest 4: Multiple backups (rolling system)');
-    const backup2 = createBackup(TEST_FILE);
-    const backup3 = createBackup(TEST_FILE);
-    
-    const allBackups = fs.readdirSync(expectedBackupDir)
-      .filter(f => f.startsWith('Button.tsx.') && f.endsWith('.backup'));
-    
-    if (allBackups.length === 3) {
-      console.log('✅ PASS: Multiple backups created');
-      console.log(`   Backups: ${allBackups.join(', ')}`);
-      passed++;
-    } else {
-      console.log(`❌ FAIL: Expected 3 backups, found ${allBackups.length}`);
-      failed++;
-    }
-    
-    // Test 5: clean_backups removes all backups
-    console.log('\nTest 5: clean_backups removes all backups');
-    const result = cleanAllBackups(TEST_DIR);
-    const backupDirExists = fs.existsSync(path.join(TEST_DIR, '.mcp-backups'));
-    
-    if (result && !backupDirExists) {
-      console.log('✅ PASS: All backups cleaned');
-      console.log(`   Backup directory removed successfully`);
-      passed++;
-    } else {
-      console.log('❌ FAIL: Backups not cleaned properly');
-      console.log(`   Result: ${result}, Dir exists: ${backupDirExists}`);
-      failed++;
-    }
-    
-    // Test 6: clean_backups on non-existent directory
-    console.log('\nTest 6: clean_backups on non-existent directory');
-    const result2 = cleanAllBackups(TEST_DIR);
-    
-    if (!result2) {
-      console.log('✅ PASS: Returns false when backup directory not found');
-      passed++;
-    } else {
-      console.log('❌ FAIL: Should return false when directory not found');
-      failed++;
-    }
-    
-    // Test 7: Backup in nested project structure
-    console.log('\nTest 7: Backup in deeply nested file');
-    const deepFile = path.join(TEST_DIR, 'src', 'features', 'auth', 'components', 'LoginForm.tsx');
-    fs.mkdirSync(path.dirname(deepFile), { recursive: true });
-    fs.writeFileSync(deepFile, 'export const LoginForm = () => <form />;');
-    
-    const deepBackup = createBackup(deepFile);
-    const expectedDeepDir = path.join(TEST_DIR, '.mcp-backups', 'src', 'features', 'auth', 'components');
-    
-    if (deepBackup.startsWith(expectedDeepDir)) {
-      console.log('✅ PASS: Deep nesting preserved');
-      console.log(`   Path: ${path.relative(TEST_DIR, deepBackup)}`);
-      passed++;
-    } else {
-      console.log('❌ FAIL: Deep nesting not preserved');
-      failed++;
-    }
-    
-  } catch (error) {
-    console.log(`❌ FAIL: Unexpected error: ${error}`);
-    failed++;
-  } finally {
-    // Cleanup
-    cleanupTestProject();
-  }
-  
-  console.log('\n══════════════════════════════════════════════════');
-  console.log(`📊 Results: ${passed} passed, ${failed} failed (${passed + failed} total)`);
-  console.log('══════════════════════════════════════════════════\n');
-  
-  if (failed > 0) {
-    process.exit(1);
-  }
-}
-
-runTests();

package/tests/test-confirmation-flow.ts

@@ -1,49 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { handleWriteFileSurgical, handleRollbackFile } from '../src/index.js';
-
-async function testWorkflow() {
-  const testFile = path.resolve('test-artifact.ts');
-  const initialContent = 'export class Old { build() { return 1; } }';
-  fs.writeFileSync(testFile, initialContent, 'utf-8');
-
-  console.log('--- Step 1: Preview (Dry-Run) ---');
-  const previewArgs = {
-    filePath: testFile,
-    symbolName: 'build',
-    newContent: '  build() { return "new value"; }',
-    className: 'Old'
-  };
-  
-  const p1 = await handleWriteFileSurgical(previewArgs);
-  const p1Text = p1.content[0].text;
-  console.log('Preview Result:', p1Text.split('\n')[0]);
-  
-  const tokenMatch = p1Text.match(/confirmationToken: "([^"]+)"/);
-  if (!tokenMatch) throw new Error('No token found');
-  const token = tokenMatch[1];
-  console.log('Token found:', token);
-
-  console.log('\n--- Step 2: Confirm ---');
-  const confirmArgs = {
-    ...previewArgs,
-    confirmationToken: token,
-    confirm: true
-  };
-  const p2 = await handleWriteFileSurgical(confirmArgs);
-  console.log('Confirm Result:', p2.content[0].text.split('\n')[0]);
-  console.log('File Content:', fs.readFileSync(testFile, 'utf-8'));
-
-  console.log('\n--- Step 3: Rollback ---');
-  await handleRollbackFile({ filePath: testFile, steps: 1 });
-  console.log('After Rollback:', fs.readFileSync(testFile, 'utf-8'));
-
-  // Clean up
-  fs.unlinkSync(testFile);
-  const backupDir = path.join(path.dirname(testFile), '.mcp-backups');
-  if (fs.existsSync(backupDir)) {
-    fs.rmSync(backupDir, { recursive: true, force: true });
-  }
-}
-
-testWorkflow().catch(console.error);

package/tests/test-dart.d.ts

@@ -1 +0,0 @@
-export {};