nex-code 0.3.4 → 0.3.7

package/cli/file-history.js

@@ -1,94 +0,0 @@
-/**
- * cli/file-history.js — In-session undo/redo for file changes
- */
-
-const fs = require('fs');
-
-const MAX_HISTORY = 50;
-
-const undoStack = [];
-const redoStack = [];
-
-/**
- * Record a file change for undo/redo support.
- * @param {string} tool - Tool that made the change (write_file, edit_file, patch_file)
- * @param {string} filePath - Absolute path to the file
- * @param {string|null} oldContent - Previous content (null if file was newly created)
- * @param {string} newContent - New content after the change
- */
-function recordChange(tool, filePath, oldContent, newContent) {
-  undoStack.push({
-    tool,
-    filePath,
-    oldContent,
-    newContent,
-    timestamp: Date.now(),
-  });
-  // Trim to max history
-  while (undoStack.length > MAX_HISTORY) undoStack.shift();
-  // New edit clears redo stack
-  redoStack.length = 0;
-}
-
-/**
- * Undo the last file change.
- * @returns {{ tool: string, filePath: string, diff: string }|null} Info about what was undone, or null if nothing to undo
- */
-function undo() {
-  if (undoStack.length === 0) return null;
-  const entry = undoStack.pop();
-
-  if (entry.oldContent === null) {
-    // File was newly created — delete it
-    try { fs.unlinkSync(entry.filePath); } catch { /* ignore */ }
-  } else {
-    fs.writeFileSync(entry.filePath, entry.oldContent, 'utf-8');
-  }
-
-  redoStack.push(entry);
-  return {
-    tool: entry.tool,
-    filePath: entry.filePath,
-    wasCreated: entry.oldContent === null,
-  };
-}
-
-/**
- * Redo the last undone change.
- * @returns {{ tool: string, filePath: string }|null} Info about what was redone, or null if nothing to redo
- */
-function redo() {
-  if (redoStack.length === 0) return null;
-  const entry = redoStack.pop();
-
-  fs.writeFileSync(entry.filePath, entry.newContent, 'utf-8');
-  undoStack.push(entry);
-
-  return {
-    tool: entry.tool,
-    filePath: entry.filePath,
-  };
-}
-
-/**
- * Get change history.
- * @param {number} [limit=10] - Max entries to return
- * @returns {Array<{ tool: string, filePath: string, timestamp: number }>}
- */
-function getHistory(limit = 10) {
-  return undoStack.slice(-limit).reverse().map((e) => ({
-    tool: e.tool,
-    filePath: e.filePath,
-    timestamp: e.timestamp,
-  }));
-}
-
-function getUndoCount() { return undoStack.length; }
-function getRedoCount() { return redoStack.length; }
-
-function clearHistory() {
-  undoStack.length = 0;
-  redoStack.length = 0;
-}
-
-module.exports = { recordChange, undo, redo, getHistory, getUndoCount, getRedoCount, clearHistory };

package/cli/format.js

@@ -1,211 +0,0 @@
-/**
- * cli/format.js — Terminal Formatting Functions
- * Tool summaries, result formatting, and color utilities
- */
-
-const C = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  white: '\x1b[37m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  gray: '\x1b[90m',
-  bgRed: '\x1b[41m',
-  bgGreen: '\x1b[42m',
-  brightCyan: '\x1b[96m',
-  brightMagenta: '\x1b[95m',
-  brightBlue: '\x1b[94m',
-};
-
-function formatToolCall(name, args) {
-  let preview;
-  switch (name) {
-    case 'write_file':
-      preview = `path=${args.path} (${(args.content || '').length} chars)`;
-      break;
-    case 'edit_file':
-      preview = `path=${args.path}`;
-      break;
-    case 'bash':
-      preview = args.command?.substring(0, 100) || '';
-      break;
-    default:
-      preview = JSON.stringify(args).substring(0, 120);
-  }
-  return `${C.yellow}  ▸ ${name}${C.reset} ${C.dim}${preview}${C.reset}`;
-}
-
-function formatResult(text, maxLines = 8) {
-  const lines = text.split('\n');
-  const shown = lines.slice(0, maxLines);
-  const more = lines.length - maxLines;
-  let out = shown.map((l) => `${C.green}    ${l}${C.reset}`).join('\n');
-  if (more > 0) out += `\n${C.gray}    ...+${more} more lines${C.reset}`;
-  return out;
-}
-
-/**
- * Returns spinner text for a tool execution, or null if the tool
- * should not show a spinner (interactive or has its own spinner).
- */
-function getToolSpinnerText(name, args) {
-  switch (name) {
-    // Tools with their own spinner or interactive UI — skip
-    case 'bash':
-    case 'ask_user':
-    case 'write_file':
-    case 'edit_file':
-    case 'patch_file':
-    case 'task_list':
-    case 'spawn_agents':
-      return null;
-
-    case 'read_file':
-      return `Reading: ${args.path || 'file'}`;
-    case 'list_directory':
-      return `Listing: ${args.path || '.'}`;
-    case 'search_files':
-      return `Searching: ${args.pattern || '...'}`;
-    case 'glob':
-      return `Glob: ${args.pattern || '...'}`;
-    case 'grep':
-      return `Grep: ${args.pattern || '...'}`;
-    case 'web_fetch':
-      return `Fetching: ${(args.url || '').substring(0, 60)}`;
-    case 'web_search':
-      return `Searching web: ${(args.query || '').substring(0, 50)}`;
-    case 'git_status':
-      return 'Git status...';
-    case 'git_diff':
-      return `Git diff${args.file ? `: ${args.file}` : ''}...`;
-    case 'git_log':
-      return `Git log${args.file ? `: ${args.file}` : ''}...`;
-    default:
-      return `Running: ${name}`;
-  }
-}
-
-/**
- * Compact 1-line summary for a tool execution result.
- * Used by the agent loop in quiet mode.
- */
-function formatToolSummary(name, args, result, isError) {
-  const r = String(result || '');
-  const icon = isError ? `${C.red}✗${C.reset}` : `${C.green}✓${C.reset}`;
-
-  if (isError) {
-    const errMsg = r.split('\n')[0].replace(/^ERROR:\s*/i, '').substring(0, 60);
-    return `  ${icon} ${C.dim}${name}${C.reset} ${C.red}→ ${errMsg}${C.reset}`;
-  }
-
-  let detail;
-  switch (name) {
-    case 'read_file': {
-      const resultLines = r.split('\n').filter(Boolean);
-      const count = resultLines.length;
-      // Detect partial reads: last line number tells us total file size
-      const lastLine = resultLines[resultLines.length - 1];
-      const lastLineNum = lastLine ? parseInt(lastLine.match(/^(\d+):/)?.[1] || '0') : 0;
-      const isPartial = args.line_start || args.line_end;
-      if (isPartial && lastLineNum > count) {
-        detail = `${args.path || 'file'} (lines ${args.line_start || 1}-${lastLineNum})`;
-      } else {
-        detail = `${args.path || 'file'} (${count} lines)`;
-      }
-      break;
-    }
-    case 'write_file': {
-      const chars = (args.content || '').length;
-      detail = `${args.path || 'file'} (${chars} chars)`;
-      break;
-    }
-    case 'edit_file':
-      detail = `${args.path || 'file'} → edited`;
-      break;
-    case 'patch_file': {
-      const n = (args.patches || []).length;
-      detail = `${args.path || 'file'} (${n} patches)`;
-      break;
-    }
-    case 'bash': {
-      const cmd = (args.command || '').substring(0, 40);
-      const suffix = (args.command || '').length > 40 ? '...' : '';
-      // Only match EXIT at the very start of the output (our error format)
-      const exitMatch = r.match(/^EXIT (\d+)/);
-      if (exitMatch) {
-        detail = `${cmd}${suffix} → exit ${exitMatch[1]}`;
-      } else {
-        detail = `${cmd}${suffix} → ok`;
-      }
-      break;
-    }
-    case 'grep':
-    case 'search_files': {
-      if (r.includes('(no matches)') || r === 'no matches') {
-        detail = `${args.pattern || '...'} → no matches`;
-      } else {
-        const lines = r.split('\n').filter(Boolean).length;
-        detail = `${args.pattern || '...'} → ${lines} matches`;
-      }
-      break;
-    }
-    case 'glob': {
-      if (r === '(no matches)') {
-        detail = `${args.pattern || '...'} → no matches`;
-      } else {
-        const files = r.split('\n').filter(Boolean).length;
-        detail = `${args.pattern || '...'} → ${files} files`;
-      }
-      break;
-    }
-    case 'list_directory': {
-      const entries = r === '(empty)' ? 0 : r.split('\n').filter(Boolean).length;
-      detail = `${args.path || '.'} → ${entries} entries`;
-      break;
-    }
-    case 'git_status': {
-      const branchMatch = r.match(/Branch:\s*(\S+)/);
-      const changeLines = r.split('\n').filter(l => /^\s*[MADRCU?!]/.test(l)).length;
-      detail = branchMatch ? `${branchMatch[1]}, ${changeLines} changes` : 'done';
-      break;
-    }
-    case 'git_diff':
-    case 'git_log':
-      detail = 'done';
-      break;
-    case 'web_fetch':
-      detail = `${(args.url || '').substring(0, 50)} → fetched`;
-      break;
-    case 'web_search': {
-      const blocks = r.split('\n\n').filter(Boolean).length;
-      detail = `${(args.query || '').substring(0, 40)} → ${blocks} results`;
-      break;
-    }
-    case 'task_list':
-      detail = `${args.action || 'list'} → done`;
-      break;
-    case 'spawn_agents': {
-      const n = (args.agents || []).length;
-      // Count successful vs failed agents from result
-      const doneCount = (r.match(/✓ Agent/g) || []).length;
-      const failCount = (r.match(/✗ Agent/g) || []).length;
-      if (failCount > 0) {
-        detail = `${n} agents → ${doneCount}✓ ${failCount}✗`;
-      } else {
-        detail = `${n} agents → done`;
-      }
-      break;
-    }
-    default:
-      detail = 'done';
-  }
-
-  return `  ${icon} ${C.dim}${name} ${detail}${C.reset}`;
-}
-
-module.exports = { C, formatToolCall, formatResult, getToolSpinnerText, formatToolSummary };

package/cli/fuzzy-match.js

@@ -1,270 +0,0 @@
-/**
- * cli/fuzzy-match.js — Fuzzy Text Matching for Edit Operations
- * Handles whitespace normalization and approximate string matching
- * to recover from common LLM edit failures.
- */
-
-const { levenshtein } = require('./tool-validator');
-
-// Constants for fuzzy matching
-const MAX_CANDIDATES = 200;
-const SIMILARITY_THRESHOLD = 0.3;  // Reject if distance > 30% of target length
-const TAB_SPACES = 2;
-
-/**
- * Normalize whitespace for comparison:
- * - Tabs → 2 spaces
- * - Trim trailing whitespace per line
- * - Collapse multiple inline spaces to one (except leading indentation)
- * - Normalize line endings to \n
- */
-function normalizeWhitespace(text) {
-  return text
-    .replace(/\r\n/g, '\n')
-    .replace(/\r/g, '\n')
-    .replace(/\t/g, ' '.repeat(TAB_SPACES))
-    .split('\n')
-    .map(line => {
-      const trimmed = line.replace(/\s+$/, '');
-      const match = trimmed.match(/^(\s*)(.*)/);
-      if (!match) return trimmed;
-      const [, indent, rest] = match;
-      return indent + rest.replace(/ {2,}/g, ' ');
-    })
-    .join('\n');
-}
-
-/**
- * Try to find `needle` in `haystack` with whitespace normalization.
- * Returns the ACTUAL text from haystack (not the normalized version),
- * or null if not found.
- *
- * Strategy:
- * 1. Exact match (fast path — caller should check this first)
- * 2. Normalize both and find the match, then map back to original positions
- */
-function fuzzyFindText(haystack, needle) {
-  // Fast path: exact match
-  if (haystack.includes(needle)) return needle;
-
-  const normHaystack = normalizeWhitespace(haystack);
-  const normNeedle = normalizeWhitespace(needle);
-
-  if (!normHaystack.includes(normNeedle)) return null;
-
-  // Map normalized position back to original text using line-based matching
-  const haystackLines = haystack.split('\n');
-  const normHaystackLines = normHaystack.split('\n');
-  const normNeedleLines = normNeedle.split('\n');
-
-  // Find which normalized line the match starts on
-  const needleFirstLine = normNeedleLines[0];
-  const needleLastLine = normNeedleLines[normNeedleLines.length - 1];
-
-  for (let i = 0; i <= normHaystackLines.length - normNeedleLines.length; i++) {
-    // Check if this position matches in normalized form
-    let matches = true;
-    for (let j = 0; j < normNeedleLines.length; j++) {
-      if (normHaystackLines[i + j] !== normNeedleLines[j]) {
-        matches = false;
-        break;
-      }
-    }
-    if (matches) {
-      // Return the original lines from haystack
-      return haystackLines.slice(i, i + normNeedleLines.length).join('\n');
-    }
-  }
-
-  // Fallback: single-line needle within a line
-  if (normNeedleLines.length === 1) {
-    for (let i = 0; i < normHaystackLines.length; i++) {
-      const idx = normHaystackLines[i].indexOf(normNeedle);
-      if (idx !== -1) {
-        // Map character position back — this is approximate for single-line matches
-        // Return the full original line's content at the approximate position
-        return haystackLines[i];
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * Sliding-window Levenshtein search to find the most similar substring.
- * Used for error messages when fuzzyFindText also fails.
- *
- * @param {string} content - The file content to search in
- * @param {string} target - The text we're looking for
- * @returns {{ text: string, distance: number, line: number } | null}
- */
-function findMostSimilar(content, target) {
-  if (!content || !target) return null;
-
-  const contentLines = content.split('\n');
-  const targetLines = target.split('\n');
-  const targetLineCount = targetLines.length;
-
-  if (contentLines.length === 0 || targetLineCount === 0) return null;
-
-  // For single-line targets, search line by line
-  if (targetLineCount === 1) {
-    return findBestSingleLineMatch(contentLines, target);
-  }
-
-  // Multi-line: sliding window search
-  return findBestMultiLineMatch(contentLines, target, targetLineCount);
-}
-
-/**
- * Calculate sampling step size for large files
- * @param {number} totalItems - Total items to search
- * @returns {number} Step size (at least 1)
- */
-function calculateStep(totalItems) {
-  return Math.max(1, Math.floor(totalItems / MAX_CANDIDATES));
-}
-
-/**
- * Check if distance is within acceptable threshold
- * @param {number} distance - Levenshtein distance
- * @param {number} targetLength - Length of target string
- * @returns {boolean}
- */
-function isWithinThreshold(distance, targetLength) {
-  return distance <= Math.ceil(targetLength * SIMILARITY_THRESHOLD);
-}
-
-/**
- * Find best matching single line
- * @param {string[]} contentLines - File content split by lines
- * @param {string} target - Target text to find
- * @returns {{text: string, distance: number, line: number}|null}
- */
-function findBestSingleLineMatch(contentLines, target) {
-  const targetTrimmed = target.trim();
-  const step = calculateStep(contentLines.length);
-  
-  let best = null;
-  let bestDist = Infinity;
-
-  // Coarse search with sampling
-  for (let i = 0; i < contentLines.length; i += step) {
-    const line = contentLines[i];
-    if (!line.trim()) continue;
-    
-    const dist = levenshtein(line.trim(), targetTrimmed);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = { text: line, distance: dist, line: i + 1 };
-    }
-  }
-
-  // Refine around best match
-  if (best && step > 1) {
-    const refined = refineSingleLineSearch(contentLines, targetTrimmed, best, step);
-    best = refined || best;
-    bestDist = best.distance;
-  }
-
-  return isWithinThreshold(bestDist, target.length) ? best : null;
-}
-
-/**
- * Refine search by checking neighbors of best match
- * @param {string[]} contentLines - File content lines
- * @param {string} targetTrimmed - Trimmed target
- * @param {Object} best - Current best match
- * @param {number} step - Sampling step
- * @returns {Object|null} Refined match or null
- */
-function refineSingleLineSearch(contentLines, targetTrimmed, best, step) {
-  const center = best.line - 1;
-  const lo = Math.max(0, center - step);
-  const hi = Math.min(contentLines.length - 1, center + step);
-  
-  let bestDist = best.distance;
-  let result = null;
-
-  for (let i = lo; i <= hi; i++) {
-    const line = contentLines[i];
-    if (!line.trim()) continue;
-    
-    const dist = levenshtein(line.trim(), targetTrimmed);
-    if (dist < bestDist) {
-      bestDist = dist;
-      result = { text: line, distance: dist, line: i + 1 };
-    }
-  }
-
-  return result;
-}
-
-/**
- * Find best matching multi-line window
- * @param {string[]} contentLines - File content split by lines
- * @param {string} target - Target text to find
- * @param {number} windowSize - Number of lines in window
- * @returns {{text: string, distance: number, line: number}|null}
- */
-function findBestMultiLineMatch(contentLines, target, windowSize) {
-  const maxWindows = contentLines.length - windowSize + 1;
-  if (maxWindows <= 0) return null;
-
-  const step = calculateStep(maxWindows);
-  
-  let best = null;
-  let bestDist = Infinity;
-
-  // Coarse search with sampling
-  for (let i = 0; i < maxWindows; i += step) {
-    const window = contentLines.slice(i, i + windowSize).join('\n');
-    const dist = levenshtein(window, target);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = { text: window, distance: dist, line: i + 1 };
-    }
-  }
-
-  // Refine around best match
-  if (best && step > 1) {
-    const refined = refineMultiLineSearch(contentLines, target, best, step, windowSize, maxWindows);
-    best = refined || best;
-    bestDist = best.distance;
-  }
-
-  return isWithinThreshold(bestDist, target.length) ? best : null;
-}
-
-/**
- * Refine multi-line search around best match
- * @param {string[]} contentLines - File content lines
- * @param {string} target - Target text
- * @param {Object} best - Current best match
- * @param {number} step - Sampling step
- * @param {number} windowSize - Window size in lines
- * @param {number} maxWindows - Maximum window positions
- * @returns {Object|null} Refined match or null
- */
-function refineMultiLineSearch(contentLines, target, best, step, windowSize, maxWindows) {
-  const center = best.line - 1;
-  const lo = Math.max(0, center - step);
-  const hi = Math.min(maxWindows - 1, center + step);
-  
-  let bestDist = best.distance;
-  let result = null;
-
-  for (let i = lo; i <= hi; i++) {
-    const window = contentLines.slice(i, i + windowSize).join('\n');
-    const dist = levenshtein(window, target);
-    if (dist < bestDist) {
-      bestDist = dist;
-      result = { text: window, distance: dist, line: i + 1 };
-    }
-  }
-
-  return result;
-}
-
-module.exports = { normalizeWhitespace, fuzzyFindText, findMostSimilar };