mcp-code-context 2.1.3 → 2.3.1

package/src/utils/backupManager.ts

@@ -1,66 +0,0 @@
-/**
- * backupManager.ts — File Backup & Restore Utility
- *
- * Provides opt-in backup functionality for surgical write operations.
- * Creates `.bak` files in the same directory as the source file.
- *
- * Usage:
- *   - Before modifying: createBackup(filePath) → returns backup path
- *   - On failure:       restoreBackup(filePath) → restores from .bak
- *   - On success:       cleanBackup(filePath)   → removes .bak
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-/**
- * Create a backup copy of a file before modifying it.
- * Keeps a rolling window of the last 5 backups per file in a hidden directory.
- */
-export function createBackup(filePath: string): string {
-  if (!fs.existsSync(filePath)) return "";
-  
-  const parsed = path.parse(filePath);
-  const backupDir = path.join(parsed.dir, ".mcp-backups");
-  
-  if (!fs.existsSync(backupDir)) {
-    fs.mkdirSync(backupDir, { recursive: true });
-  }
-
-  // Push existing backups down the stack (max 5)
-  for (let i = 4; i >= 1; i--) {
-    const oldB = path.join(backupDir, `${parsed.base}.${i}.backup`);
-    const newB = path.join(backupDir, `${parsed.base}.${i + 1}.backup`);
-    if (fs.existsSync(oldB)) {
-      if (i === 4 && fs.existsSync(newB)) {
-        fs.unlinkSync(newB); // Drop the 5th one to make room
-      }
-      fs.renameSync(oldB, newB);
-    }
-  }
-
-  const backupPath = path.join(backupDir, `${parsed.base}.1.backup`);
-  fs.copyFileSync(filePath, backupPath);
-  return backupPath;
-}
-
-/**
- * Restore a file from its `.bak` backup.
- */
-export function restoreBackup(filePath: string, steps = 1): boolean {
-  const parsed = path.parse(filePath);
-  const backupDir = path.join(parsed.dir, ".mcp-backups");
-  const targetBackup = path.join(backupDir, `${parsed.base}.${steps}.backup`);
-
-  if (!fs.existsSync(targetBackup)) return false;
-
-  fs.copyFileSync(targetBackup, filePath);
-  return true;
-}
-
-/**
- * Clean legacy backups.
- */
-export function cleanBackup(filePath: string): void {
-  // No-op. We keep the rolling 5 versions instead of deleting.
-}

package/src/utils/confirmationCache.ts

@@ -1,61 +0,0 @@
-import crypto from "node:crypto";
-
-export interface PendingOperation {
-  token: string;
-  operation: "write_file_surgical" | "insert_symbol" | "rename_symbol" | "remove_symbol";
-  filePath: string;
-  payload: any; // Contains specific args needed to re-execute or apply
-  expiresAt: number;
-}
-
-const CACHE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
-
-class ConfirmationCacheManager {
-  private cache = new Map<string, PendingOperation>();
-
-  public add(
-    operation: PendingOperation["operation"],
-    filePath: string,
-    payload: any
-  ): string {
-    const token = crypto.randomUUID();
-    
-    this.cache.set(token, {
-      token,
-      operation,
-      filePath,
-      payload,
-      expiresAt: Date.now() + CACHE_TIMEOUT_MS,
-    });
-
-    // Clean up expired items lazily
-    this.cleanup();
-
-    return token;
-  }
-
-  public get(token: string): PendingOperation | undefined {
-    this.cleanup();
-    return this.cache.get(token);
-  }
-
-  public consume(token: string): PendingOperation | undefined {
-    this.cleanup();
-    const op = this.cache.get(token);
-    if (op) {
-      this.cache.delete(token);
-    }
-    return op;
-  }
-
-  private cleanup() {
-    const now = Date.now();
-    for (const [key, value] of this.cache.entries()) {
-      if (now > value.expiresAt) {
-        this.cache.delete(key);
-      }
-    }
-  }
-}
-
-export const confirmationCache = new ConfirmationCacheManager();

package/src/utils/diffEngine.ts

@@ -1,223 +0,0 @@
-/**
- * diffEngine.ts — Unified Diff Generator
- *
- * Generates human-readable unified diffs (like `git diff`) for dry-run reports
- * and post-write summaries. Uses a simple Myers-style diff algorithm.
- * No external dependencies.
- */
-
-// ─── Types ──────────────────────────────────────────────────────────
-
-interface DiffHunk {
-  oldStart: number;
-  oldCount: number;
-  newStart: number;
-  newCount: number;
-  lines: string[];
-}
-
-// ─── Public API ─────────────────────────────────────────────────────
-
-/**
- * Generate a unified diff between two versions of a single file.
- * Returns a string formatted like `git diff --unified=3`.
- */
-export function generateDiff(
-  oldContent: string,
-  newContent: string,
-  filePath: string,
-  contextLines = 3,
-): string {
-  const oldLines = oldContent.split("\n");
-  const newLines = newContent.split("\n");
-
-  const hunks = computeHunks(oldLines, newLines, contextLines);
-
-  if (hunks.length === 0) {
-    return `--- ${filePath}\n+++ ${filePath}\n(no changes)\n`;
-  }
-
-  const header = [
-    `--- a/${normalizedPath(filePath)}`,
-    `+++ b/${normalizedPath(filePath)}`,
-  ];
-
-  const hunkTexts = hunks.map((hunk) => {
-    const hunkHeader = `@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`;
-    return [hunkHeader, ...hunk.lines].join("\n");
-  });
-
-  return [...header, ...hunkTexts].join("\n") + "\n";
-}
-
-/**
- * Generate a combined diff across multiple files.
- * Returns a single string with all file diffs separated by blank lines.
- */
-export function generateMultiFileDiff(
-  changes: Array<{
-    filePath: string;
-    oldContent: string;
-    newContent: string;
-  }>,
-): string {
-  const diffs: string[] = [];
-
-  for (const change of changes) {
-    const diff = generateDiff(
-      change.oldContent,
-      change.newContent,
-      change.filePath,
-    );
-    diffs.push(diff);
-  }
-
-  return diffs.join("\n");
-}
-
-// ─── Diff Algorithm ─────────────────────────────────────────────────
-
-/**
- * Compute the Longest Common Subsequence table for two arrays of strings.
- */
-function computeLCS(a: string[], b: string[]): number[][] {
-  const m = a.length;
-  const n = b.length;
-
-  // Use a 2D array for the LCS table
-  const dp: number[][] = Array.from({ length: m + 1 }, () =>
-    new Array(n + 1).fill(0),
-  );
-
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      if (a[i - 1] === b[j - 1]) {
-        dp[i][j] = dp[i - 1][j - 1] + 1;
-      } else {
-        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-      }
-    }
-  }
-
-  return dp;
-}
-
-/**
- * Backtrack through the LCS table to produce a list of diff operations.
- */
-function backtrackDiff(
-  dp: number[][],
-  a: string[],
-  b: string[],
-): Array<{ type: "keep" | "remove" | "add"; line: string }> {
-  const result: Array<{ type: "keep" | "remove" | "add"; line: string }> = [];
-  let i = a.length;
-  let j = b.length;
-
-  while (i > 0 || j > 0) {
-    if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
-      result.unshift({ type: "keep", line: a[i - 1] });
-      i--;
-      j--;
-    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-      result.unshift({ type: "add", line: b[j - 1] });
-      j--;
-    } else if (i > 0) {
-      result.unshift({ type: "remove", line: a[i - 1] });
-      i--;
-    }
-  }
-
-  return result;
-}
-
-/**
- * Group diff operations into hunks with surrounding context.
- */
-function computeHunks(
-  oldLines: string[],
-  newLines: string[],
-  contextLines: number,
-): DiffHunk[] {
-  const dp = computeLCS(oldLines, newLines);
-  const ops = backtrackDiff(dp, oldLines, newLines);
-
-  // Find ranges of changes (non-"keep" operations)
-  const changeIndices: number[] = [];
-  for (let i = 0; i < ops.length; i++) {
-    if (ops[i].type !== "keep") {
-      changeIndices.push(i);
-    }
-  }
-
-  if (changeIndices.length === 0) return [];
-
-  // Group nearby changes into hunks
-  const groups: Array<{ start: number; end: number }> = [];
-  let groupStart = changeIndices[0];
-  let groupEnd = changeIndices[0];
-
-  for (let k = 1; k < changeIndices.length; k++) {
-    if (changeIndices[k] - groupEnd <= contextLines * 2 + 1) {
-      // Merge into current group
-      groupEnd = changeIndices[k];
-    } else {
-      groups.push({ start: groupStart, end: groupEnd });
-      groupStart = changeIndices[k];
-      groupEnd = changeIndices[k];
-    }
-  }
-  groups.push({ start: groupStart, end: groupEnd });
-
-  // Build hunks with context
-  const hunks: DiffHunk[] = [];
-
-  for (const group of groups) {
-    const hunkStart = Math.max(0, group.start - contextLines);
-    const hunkEnd = Math.min(ops.length - 1, group.end + contextLines);
-
-    const lines: string[] = [];
-    let oldLineNum = 0;
-    let newLineNum = 0;
-
-    // Count lines before hunk start to get correct line numbers
-    for (let i = 0; i < hunkStart; i++) {
-      if (ops[i].type === "keep" || ops[i].type === "remove") oldLineNum++;
-      if (ops[i].type === "keep" || ops[i].type === "add") newLineNum++;
-    }
-
-    const oldStart = oldLineNum + 1;
-    const newStart = newLineNum + 1;
-    let oldCount = 0;
-    let newCount = 0;
-
-    for (let i = hunkStart; i <= hunkEnd; i++) {
-      const op = ops[i];
-      switch (op.type) {
-        case "keep":
-          lines.push(` ${op.line}`);
-          oldCount++;
-          newCount++;
-          break;
-        case "remove":
-          lines.push(`-${op.line}`);
-          oldCount++;
-          break;
-        case "add":
-          lines.push(`+${op.line}`);
-          newCount++;
-          break;
-      }
-    }
-
-    hunks.push({ oldStart, oldCount, newStart, newCount, lines });
-  }
-
-  return hunks;
-}
-
-// ─── Utilities ──────────────────────────────────────────────────────
-
-function normalizedPath(filePath: string): string {
-  return filePath.replace(/\\/g, "/");
-}

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/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 {};