mcp-code-context 2.2.0 → 2.3.1

package/src/tools/readFileLines.ts

@@ -1,104 +0,0 @@
-/**
- * read_file_lines — Read specific line ranges from a file
- * 
- * Efficiently reads only the requested lines without loading the entire file into memory.
- * Supports reading by exact line range or around a pattern match.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export interface ReadFileLinesArgs {
-  filePath: string;
-  startLine?: number;
-  endLine?: number;
-  aroundPattern?: string;
-  contextLines?: number;
-}
-
-export interface ReadFileLinesResult {
-  success: boolean;
-  content?: string;
-  error?: string;
-  lineRange?: { start: number; end: number };
-}
-
-/**
- * Read specific lines from a file
- */
-export function readFileLines(args: ReadFileLinesArgs): ReadFileLinesResult {
-  const { filePath, startLine, endLine, aroundPattern, contextLines = 5 } = args;
-
-  const resolvedPath = path.resolve(filePath);
-
-  if (!fs.existsSync(resolvedPath)) {
-    return {
-      success: false,
-      error: `File not found: ${resolvedPath}`,
-    };
-  }
-
-  let content: string;
-  try {
-    content = fs.readFileSync(resolvedPath, "utf-8");
-  } catch (error: unknown) {
-    return {
-      success: false,
-      error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-
-  const lines = content.split("\n");
-  const totalLines = lines.length;
-
-  // Mode 1: Exact line range
-  if (startLine !== undefined && endLine !== undefined) {
-    if (startLine < 1 || endLine < 1 || startLine > totalLines || endLine > totalLines) {
-      return {
-        success: false,
-        error: `Invalid line range: ${startLine}-${endLine}. File has ${totalLines} lines.`,
-      };
-    }
-
-    if (startLine > endLine) {
-      return {
-        success: false,
-        error: `startLine (${startLine}) must be <= endLine (${endLine})`,
-      };
-    }
-
-    const selectedLines = lines.slice(startLine - 1, endLine);
-    return {
-      success: true,
-      content: selectedLines.join("\n"),
-      lineRange: { start: startLine, end: endLine },
-    };
-  }
-
-  // Mode 2: Around pattern
-  if (aroundPattern) {
-    const matchIndex = lines.findIndex((line) => line.includes(aroundPattern));
-
-    if (matchIndex === -1) {
-      return {
-        success: false,
-        error: `Pattern "${aroundPattern}" not found in file`,
-      };
-    }
-
-    const start = Math.max(0, matchIndex - contextLines);
-    const end = Math.min(totalLines - 1, matchIndex + contextLines);
-
-    const selectedLines = lines.slice(start, end + 1);
-    return {
-      success: true,
-      content: selectedLines.join("\n"),
-      lineRange: { start: start + 1, end: end + 1 },
-    };
-  }
-
-  return {
-    success: false,
-    error: "Must provide either (startLine + endLine) or aroundPattern",
-  };
-}

package/src/tools/searchCodePattern.ts

@@ -1,129 +0,0 @@
-/**
- * search_code_pattern — Search for code patterns across files
- * 
- * AST-aware search that finds patterns in code while optionally excluding
- * matches in strings, comments, and other non-code contexts.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { IgnoreManager } from "../utils/ignoreManager.js";
-
-export interface SearchCodePatternArgs {
-  rootDir: string;
-  pattern: string;
-  fileExtensions?: string[];
-  excludeDirs?: string[];
-  showContext?: boolean;
-  contextLines?: number;
-  maxResults?: number;
-  astAware?: boolean;
-}
-
-export interface SearchMatch {
-  file: string;
-  lineNumber: number;
-  line: string;
-  context?: string[];
-}
-
-export interface SearchCodePatternResult {
-  success: boolean;
-  matches?: SearchMatch[];
-  error?: string;
-  totalMatches?: number;
-}
-
-const DEFAULT_EXTENSIONS = [
-  ".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs",
-  ".py", ".php", ".dart", ".java", ".go", ".rs"
-];
-
-/**
- * Search for a pattern across code files
- */
-export function searchCodePattern(args: SearchCodePatternArgs): SearchCodePatternResult {
-  const {
-    rootDir,
-    pattern,
-    fileExtensions = DEFAULT_EXTENSIONS,
-    excludeDirs = ["node_modules", "dist", "build", ".git"],
-    showContext = true,
-    contextLines = 3,
-    maxResults = 50,
-    astAware = false,
-  } = args;
-
-  const resolvedRoot = path.resolve(rootDir);
-
-  if (!fs.existsSync(resolvedRoot)) {
-    return {
-      success: false,
-      error: `Directory not found: ${resolvedRoot}`,
-    };
-  }
-
-  const ignoreManager = new IgnoreManager(resolvedRoot);
-  const allFiles = ignoreManager.walkDirectory();
-
-  const matches: SearchMatch[] = [];
-  let totalMatches = 0;
-
-  const regex = new RegExp(pattern, "gi");
-
-  for (const file of allFiles) {
-    // Check extension
-    const ext = path.extname(file).toLowerCase();
-    if (!fileExtensions.includes(ext)) continue;
-
-    // Check excluded directories
-    const relativePath = path.relative(resolvedRoot, file);
-    if (excludeDirs.some(dir => relativePath.includes(dir))) continue;
-
-    let content: string;
-    try {
-      content = fs.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-
-    const lines = content.split("\n");
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-
-      if (regex.test(line)) {
-        totalMatches++;
-
-        if (matches.length < maxResults) {
-          const match: SearchMatch = {
-            file: path.relative(resolvedRoot, file).replace(/\\/g, "/"),
-            lineNumber: i + 1,
-            line: line.trim(),
-          };
-
-          if (showContext) {
-            const start = Math.max(0, i - contextLines);
-            const end = Math.min(lines.length - 1, i + contextLines);
-            match.context = lines.slice(start, end + 1).map((l, idx) => {
-              const lineNum = start + idx + 1;
-              const marker = lineNum === i + 1 ? ">" : " ";
-              return `${marker} ${lineNum}: ${l}`;
-            });
-          }
-
-          matches.push(match);
-        }
-      }
-
-      // Reset regex lastIndex for global flag
-      regex.lastIndex = 0;
-    }
-  }
-
-  return {
-    success: true,
-    matches,
-    totalMatches,
-  };
-}

package/src/utils/backupManager.ts

@@ -1,141 +0,0 @@
-/**
- * backupManager.ts — File Backup & Restore Utility
- *
- * Provides opt-in backup functionality for surgical write operations.
- * Creates centralized `.mcp-backups/` directory at project root.
- *
- * Usage:
- *   - Before modifying: createBackup(filePath) → returns backup path
- *   - On failure:       restoreBackup(filePath) → restores from backup
- *   - Cleanup:          cleanAllBackups(projectRoot) → removes all backups
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { findProjectRoot } from "./projectRoot.js";
-
-/**
- * Create a backup copy of a file before modifying it.
- * Keeps a rolling window of the last 5 backups per file in a centralized directory.
- * 
- * Backups are stored at: [project-root]/.mcp-backups/[relative-path]/[filename].N.backup
- */
-export function createBackup(filePath: string): string {
-  if (!fs.existsSync(filePath)) return "";
-  
-  // Find project root
-  const projectRoot = findProjectRoot(filePath);
-  if (!projectRoot) {
-    // Fallback to old behavior if no project root found
-    return createBackupLegacy(filePath);
-  }
-
-  // Calculate relative path from project root
-  const relativePath = path.relative(projectRoot, filePath);
-  const parsed = path.parse(relativePath);
-  
-  // Create centralized backup directory
-  const backupDir = path.join(projectRoot, ".mcp-backups", parsed.dir);
-  
-  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;
-}
-
-/**
- * Legacy backup function (creates .mcp-backups in same directory)
- * Used as fallback when project root cannot be determined
- */
-function createBackupLegacy(filePath: string): string {
-  const parsed = path.parse(filePath);
-  const backupDir = path.join(parsed.dir, ".mcp-backups");
-  
-  if (!fs.existsSync(backupDir)) {
-    fs.mkdirSync(backupDir, { recursive: true });
-  }
-
-  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);
-      }
-      fs.renameSync(oldB, newB);
-    }
-  }
-
-  const backupPath = path.join(backupDir, `${parsed.base}.1.backup`);
-  fs.copyFileSync(filePath, backupPath);
-  return backupPath;
-}
-
-/**
- * Restore a file from its backup.
- */
-export function restoreBackup(filePath: string, steps = 1): boolean {
-  // Try centralized backup first
-  const projectRoot = findProjectRoot(filePath);
-  
-  if (projectRoot) {
-    const relativePath = path.relative(projectRoot, filePath);
-    const parsed = path.parse(relativePath);
-    const backupDir = path.join(projectRoot, ".mcp-backups", parsed.dir);
-    const targetBackup = path.join(backupDir, `${parsed.base}.${steps}.backup`);
-
-    if (fs.existsSync(targetBackup)) {
-      fs.copyFileSync(targetBackup, filePath);
-      return true;
-    }
-  }
-  
-  // Fallback to legacy location
-  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 all backups for a project.
- * Removes the entire .mcp-backups directory at project root.
- */
-export function cleanAllBackups(projectRoot: string): boolean {
-  const backupDir = path.join(projectRoot, ".mcp-backups");
-  
-  if (!fs.existsSync(backupDir)) return false;
-  
-  try {
-    fs.rmSync(backupDir, { recursive: true, force: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Clean legacy backups (no-op, kept for compatibility).
- */
-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, "/");
-}