@probelabs/probe 0.6.0-rc253 → 0.6.0-rc255

package/src/tools/executePlan.js

@@ -436,6 +436,7 @@ ${lastError}
 
 RULES REMINDER:
 - search(query) is KEYWORD SEARCH — pass a search query, NOT a filename. Use extract(filepath) to read file contents.
+- search(query, path) — the path argument must be a STRING, not an object. Use field.file_path, not field.
 - search() returns up to 20K tokens by default. Use search(query, path, {maxTokens: null}) for unlimited, or searchAll(query) to auto-paginate ALL results.
 - search(), searchAll(), query(), extract(), listFiles(), bash() all return STRINGS, not arrays.
 - Use chunk(stringData) to split a string into an array of chunks.
@@ -444,7 +445,8 @@ RULES REMINDER:
 - Do NOT define helper functions that call tools — write logic inline.
 - Do NOT use async/await, template literals, or shorthand properties.
 - Do NOT use regex literals (/pattern/) — use String methods like indexOf, includes, startsWith instead.
-- String concatenation with +, not template literals.`;
+- String concatenation with +, not template literals.
+- IMPORTANT: If a tool returns "ERROR: ...", do NOT pass that error string to LLM() — handle or skip it.`;
 
               const fixedCode = await llmCallFn(fixPrompt, '', { maxTokens: 4000, temperature: 0.2 });
               // Strip markdown fences and XML tags the LLM might add

package/src/tools/fileTracker.js

@@ -0,0 +1,318 @@
+/**
+ * FileTracker — per-session content-aware file state tracking for safe multi-edit workflows
+ *
+ * Two-tier tracking:
+ * 1. _seenFiles (Set) — which files the LLM has "seen" via search/extract. Guards against blind edits.
+ * 2. _contentRecords (Map) — per-symbol content hashes from extract #symbol targets. Detects stale edits.
+ *
+ * Key benefit: edits proceed when the target symbol hasn't changed, even if other parts of the file changed.
+ * Uses SHA-256 content hashing instead of mtime/size for precise change detection.
+ *
+ * @module tools/fileTracker
+ */
+
+import { createHash } from 'crypto';
+import { resolve, isAbsolute } from 'path';
+import { findSymbol } from './symbolEdit.js';
+
+/**
+ * Compute a SHA-256 content hash for a code block.
+ * Normalizes trailing whitespace per line for robustness against editor formatting.
+ * @param {string} content - The code content to hash
+ * @returns {string} First 16 hex chars of SHA-256 hash (64 bits of collision resistance)
+ */
+export function computeContentHash(content) {
+  const normalized = (content || '').split('\n').map(l => l.trimEnd()).join('\n');
+  return createHash('sha256').update(normalized).digest('hex').slice(0, 16);
+}
+
+/**
+ * Extract the file path portion from an extract target string.
+ * Strips symbol references (#Symbol) and line references (:line, :start-end).
+ * @param {string} target - Extract target (e.g. "file.js#fn", "file.js:10-20")
+ * @returns {string} Just the file path
+ */
+function extractFilePath(target) {
+  // Strip #Symbol suffix
+  const hashIdx = target.indexOf('#');
+  if (hashIdx !== -1) {
+    return target.slice(0, hashIdx);
+  }
+  // Strip :line or :start-end suffix (use lastIndexOf to skip Windows drive letter colons)
+  const colonIdx = target.lastIndexOf(':');
+  if (colonIdx !== -1) {
+    // Only strip if what follows looks like a line reference (digits, dash)
+    const after = target.slice(colonIdx + 1);
+    if (/^\d+(-\d+)?$/.test(after)) {
+      return target.slice(0, colonIdx);
+    }
+  }
+  return target;
+}
+
+/**
+ * Extract the symbol name from an extract target string.
+ * @param {string} target - Extract target (e.g. "file.js#fn")
+ * @returns {string|null} Symbol name or null if not a symbol target
+ */
+function extractSymbolName(target) {
+  const hashIdx = target.indexOf('#');
+  if (hashIdx !== -1) {
+    const symbol = target.slice(hashIdx + 1);
+    return symbol || null;
+  }
+  return null;
+}
+
+/**
+ * Parse file paths from probe search/extract output.
+ * Looks for "File: path" headers and "--- path ---" separators.
+ * @param {string} output - Probe output text
+ * @returns {string[]} Array of file paths found
+ */
+function parseFilePathsFromOutput(output) {
+  const paths = [];
+  const regex = /^(?:File:\s+|---\s+)([^\s].*?)(?:\s+---)?$/gm;
+  let match;
+  while ((match = regex.exec(output)) !== null) {
+    const path = match[1].trim();
+    // Skip things that look like metadata, not file paths
+    if (path && !path.startsWith('Results') && !path.startsWith('Page') && (path.includes('/') || path.includes('.') || path.includes('\\'))) {
+      paths.push(path);
+    }
+  }
+  return paths;
+}
+
+export class FileTracker {
+  /**
+   * @param {Object} [options]
+   * @param {boolean} [options.debug=false] - Enable debug logging
+   */
+  constructor(options = {}) {
+    this.debug = options.debug || false;
+    /** @type {Set<string>} Files seen via search/extract */
+    this._seenFiles = new Set();
+    /** @type {Map<string, {contentHash: string, startLine: number, endLine: number, symbolName: string|null, source: string, timestamp: number}>} */
+    this._contentRecords = new Map();
+  }
+
+  /**
+   * Mark a file as "seen" — the LLM has read its content.
+   * @param {string} resolvedPath - Absolute path to the file
+   */
+  markFileSeen(resolvedPath) {
+    this._seenFiles.add(resolvedPath);
+    if (this.debug) {
+      console.error(`[FileTracker] Marked as seen: ${resolvedPath}`);
+    }
+  }
+
+  /**
+   * Check if a file has been seen in this session.
+   * @param {string} resolvedPath - Absolute path to the file
+   * @returns {boolean}
+   */
+  isFileSeen(resolvedPath) {
+    return this._seenFiles.has(resolvedPath);
+  }
+
+  /**
+   * Store a content hash for a symbol in a file.
+   * @param {string} resolvedPath - Absolute path to the file
+   * @param {string} symbolName - Symbol name (e.g. "calculateTotal")
+   * @param {string} code - The symbol's source code
+   * @param {number} startLine - 1-indexed start line
+   * @param {number} endLine - 1-indexed end line
+   * @param {string} [source='extract'] - How the content was obtained
+   */
+  trackSymbolContent(resolvedPath, symbolName, code, startLine, endLine, source = 'extract') {
+    const key = `${resolvedPath}#${symbolName}`;
+    const contentHash = computeContentHash(code);
+    this._contentRecords.set(key, {
+      contentHash,
+      startLine,
+      endLine,
+      symbolName,
+      source,
+      timestamp: Date.now()
+    });
+    if (this.debug) {
+      console.error(`[FileTracker] Tracked symbol ${key} (hash: ${contentHash}, lines ${startLine}-${endLine})`);
+    }
+  }
+
+  /**
+   * Look up a stored content record for a symbol.
+   * @param {string} resolvedPath - Absolute path to the file
+   * @param {string} symbolName - Symbol name
+   * @returns {Object|null} The stored record or null
+   */
+  getSymbolRecord(resolvedPath, symbolName) {
+    return this._contentRecords.get(`${resolvedPath}#${symbolName}`) || null;
+  }
+
+  /**
+   * Check if a symbol's current content matches what was stored.
+   * @param {string} resolvedPath - Absolute path to the file
+   * @param {string} symbolName - Symbol name
+   * @param {string} currentCode - The symbol's current source code (from findSymbol)
+   * @returns {{ok: boolean, reason?: string, message?: string}}
+   */
+  checkSymbolContent(resolvedPath, symbolName, currentCode) {
+    const key = `${resolvedPath}#${symbolName}`;
+    const record = this._contentRecords.get(key);
+
+    if (!record) {
+      // No record for this specific symbol — allow (file was seen, this is first edit)
+      return { ok: true };
+    }
+
+    const currentHash = computeContentHash(currentCode);
+    if (currentHash === record.contentHash) {
+      return { ok: true };
+    }
+
+    return {
+      ok: false,
+      reason: 'stale',
+      message: `Symbol "${symbolName}" has changed since you last read it (hash: ${record.contentHash} → ${currentHash}).`
+    };
+  }
+
+  /**
+   * Track files from extract target strings.
+   * Marks each file as seen. For #symbol targets, calls findSymbol to get and hash the code.
+   * @param {string[]} targets - Array of extract targets (e.g. ["file.js#fn", "file.js:10-20"])
+   * @param {string} cwd - Working directory for resolving relative paths
+   */
+  async trackFilesFromExtract(targets, cwd) {
+    const seenPaths = new Set();
+    const symbolPromises = [];
+
+    for (const target of targets) {
+      const filePath = extractFilePath(target);
+      const resolved = isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+
+      // Mark file as seen (deduplicate)
+      if (!seenPaths.has(resolved)) {
+        seenPaths.add(resolved);
+        this.markFileSeen(resolved);
+      }
+
+      // For symbol targets, get the content hash
+      const symbolName = extractSymbolName(target);
+      if (symbolName) {
+        symbolPromises.push(
+          findSymbol(resolved, symbolName, cwd)
+            .then(symbolInfo => {
+              if (symbolInfo) {
+                this.trackSymbolContent(
+                  resolved, symbolName, symbolInfo.code,
+                  symbolInfo.startLine, symbolInfo.endLine, 'extract'
+                );
+              }
+            })
+            .catch(err => {
+              if (this.debug) {
+                console.error(`[FileTracker] Failed to track symbol "${symbolName}" in ${resolved}: ${err.message}`);
+              }
+            })
+        );
+      }
+    }
+
+    if (symbolPromises.length > 0) {
+      await Promise.all(symbolPromises);
+    }
+  }
+
+  /**
+   * Track files discovered in probe search/extract output.
+   * Parses "File: path" headers and "--- path ---" separators, marks each as "seen".
+   * @param {string} output - Probe output text
+   * @param {string} cwd - Working directory for resolving relative paths
+   */
+  async trackFilesFromOutput(output, cwd) {
+    const paths = parseFilePathsFromOutput(output);
+    for (const filePath of paths) {
+      const resolved = isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+      this.markFileSeen(resolved);
+    }
+  }
+
+  /**
+   * Check if a file is safe to edit (seen-check only).
+   * Mode-specific content verification happens in edit handlers.
+   * @param {string} resolvedPath - Absolute path to the file
+   * @returns {{ok: boolean, reason?: string, message?: string}}
+   */
+  checkBeforeEdit(resolvedPath) {
+    if (!this._seenFiles.has(resolvedPath)) {
+      return {
+        ok: false,
+        reason: 'untracked',
+        message: 'This file has not been read yet in this session. Use extract or search to read the file first.'
+      };
+    }
+    return { ok: true };
+  }
+
+  /**
+   * Mark a file as seen after a successful write (backward compat).
+   * Also invalidates content records for the file since its content changed.
+   * @param {string} resolvedPath - Absolute path to the file
+   */
+  async trackFileAfterWrite(resolvedPath) {
+    this.markFileSeen(resolvedPath);
+    this.invalidateFileRecords(resolvedPath);
+  }
+
+  /**
+   * Update the stored hash for a symbol after a successful write.
+   * Enables chained edits to the same symbol.
+   * @param {string} resolvedPath - Absolute path to the file
+   * @param {string} symbolName - Symbol name
+   * @param {string} code - The symbol's new source code
+   * @param {number} startLine - 1-indexed start line (new position)
+   * @param {number} endLine - 1-indexed end line (new position)
+   */
+  trackSymbolAfterWrite(resolvedPath, symbolName, code, startLine, endLine) {
+    this.trackSymbolContent(resolvedPath, symbolName, code, startLine, endLine, 'edit');
+  }
+
+  /**
+   * Remove all content records for a file.
+   * Called after non-symbol edits (text/line mode) since those change content
+   * without providing a symbol-level update.
+   * @param {string} resolvedPath - Absolute path to the file
+   */
+  invalidateFileRecords(resolvedPath) {
+    const prefix = resolvedPath + '#';
+    for (const key of this._contentRecords.keys()) {
+      if (key.startsWith(prefix)) {
+        this._contentRecords.delete(key);
+      }
+    }
+    if (this.debug) {
+      console.error(`[FileTracker] Invalidated content records for ${resolvedPath}`);
+    }
+  }
+
+  /**
+   * Quick sync check if a file is being tracked (alias for isFileSeen).
+   * @param {string} resolvedPath - Absolute path to the file
+   * @returns {boolean}
+   */
+  isTracked(resolvedPath) {
+    return this.isFileSeen(resolvedPath);
+  }
+
+  /**
+   * Clear all tracking state.
+   */
+  clear() {
+    this._seenFiles.clear();
+    this._contentRecords.clear();
+  }
+}

package/src/tools/fuzzyMatch.js

@@ -0,0 +1,271 @@
+/**
+ * Progressive fuzzy string matching for the edit tool.
+ * Strategies are tried in order:
+ *   exact (handled by caller) → line-trimmed → whitespace-normalized → indent-flexible
+ *
+ * All functions are PURE — no file I/O, no side effects.
+ * Each match function returns the ACTUAL text from the file content (not the search string),
+ * so the caller can do content.replace(matchedText, newString).
+ *
+ * @module tools/fuzzyMatch
+ */
+
+/**
+ * Try all fuzzy strategies in order. Returns first match or null.
+ * @param {string} content - Full file content
+ * @param {string} searchString - String to find
+ * @returns {{ matchedText: string, strategy: string, count: number } | null}
+ */
+export function findFuzzyMatch(content, searchString) {
+  // Guard: empty or whitespace-only search string
+  if (!searchString || searchString.trim().length === 0) {
+    return null;
+  }
+
+  // Normalize \r\n to \n for consistent handling
+  const normalizedContent = content.replace(/\r\n/g, '\n');
+  const normalizedSearch = searchString.replace(/\r\n/g, '\n');
+
+  const contentLines = normalizedContent.split('\n');
+  const searchLines = normalizedSearch.split('\n');
+
+  // Strategy 1: Line-trimmed
+  const trimmed = lineTrimmedMatch(contentLines, searchLines);
+  if (trimmed) return { ...trimmed, strategy: 'line-trimmed' };
+
+  // Strategy 2: Whitespace-normalized
+  const normalized = whitespaceNormalizedMatch(normalizedContent, normalizedSearch);
+  if (normalized) return { ...normalized, strategy: 'whitespace-normalized' };
+
+  // Strategy 3: Indentation-flexible
+  const indentFlex = indentFlexibleMatch(contentLines, searchLines);
+  if (indentFlex) return { ...indentFlex, strategy: 'indent-flexible' };
+
+  return null;
+}
+
+/**
+ * Line-trimmed matching: trims each line before comparing.
+ * Slides a window of searchLines.length across contentLines.
+ * If trimmed lines match, returns the actual text from content at those line positions.
+ *
+ * @param {string[]} contentLines - Lines of the full file content
+ * @param {string[]} searchLines - Lines of the search string
+ * @returns {{ matchedText: string, count: number } | null}
+ */
+export function lineTrimmedMatch(contentLines, searchLines) {
+  if (searchLines.length === 0) return null;
+
+  const trimmedSearchLines = searchLines.map(line => line.trim());
+
+  // If all search lines are empty after trimming, no meaningful match
+  if (trimmedSearchLines.every(line => line === '')) return null;
+
+  const windowSize = searchLines.length;
+  const matches = [];
+
+  for (let i = 0; i <= contentLines.length - windowSize; i++) {
+    let allMatch = true;
+    for (let j = 0; j < windowSize; j++) {
+      if (contentLines[i + j].trim() !== trimmedSearchLines[j]) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      const matchedText = contentLines.slice(i, i + windowSize).join('\n');
+      matches.push(matchedText);
+    }
+  }
+
+  if (matches.length === 0) return null;
+
+  return {
+    matchedText: matches[0],
+    count: matches.length,
+  };
+}
+
+/**
+ * Whitespace-normalized matching: collapses all whitespace runs (spaces, tabs)
+ * to a single space before comparing. Returns actual text from content.
+ *
+ * Builds a character index map from normalized positions back to original positions
+ * so we can extract the actual content substring.
+ *
+ * @param {string} content - Full file content
+ * @param {string} search - Search string
+ * @returns {{ matchedText: string, count: number } | null}
+ */
+export function whitespaceNormalizedMatch(content, search) {
+  if (!search || search.trim().length === 0) return null;
+
+  // Build normalized content with position mapping.
+  // We normalize horizontal whitespace (spaces, tabs) to single space,
+  // but preserve newlines as meaningful structure.
+  const { normalized: normContent, indexMap: contentMap } = buildNormalizedMap(content);
+  const { normalized: normSearch } = buildNormalizedMap(search);
+
+  if (normSearch.length === 0) return null;
+
+  // Find all occurrences of normalized search in normalized content
+  const matches = [];
+  let searchStart = 0;
+
+  while (searchStart <= normContent.length - normSearch.length) {
+    const idx = normContent.indexOf(normSearch, searchStart);
+    if (idx === -1) break;
+
+    // Map normalized positions back to original content positions
+    const originalStart = contentMap[idx];
+    const originalEnd = contentMap[idx + normSearch.length - 1];
+
+    // Extract actual text from original content — include the full last character
+    // We need to find the end of the character at originalEnd
+    let actualEnd = originalEnd + 1;
+    // If the original character at originalEnd started a whitespace run that was collapsed,
+    // extend to include the full whitespace run
+    while (actualEnd < content.length && /[ \t]/.test(content[actualEnd]) && (actualEnd === originalEnd + 1 || /[ \t]/.test(content[actualEnd - 1]))) {
+      // Only extend if the next normalized position would be beyond our match
+      if (contentMap.indexOf(actualEnd) > idx + normSearch.length - 1 || contentMap.indexOf(actualEnd) === -1) {
+        break;
+      }
+      actualEnd++;
+    }
+
+    const matchedText = content.substring(originalStart, actualEnd);
+    matches.push(matchedText);
+
+    searchStart = idx + 1;
+  }
+
+  if (matches.length === 0) return null;
+
+  return {
+    matchedText: matches[0],
+    count: matches.length,
+  };
+}
+
+/**
+ * Build a normalized string and a map from normalized character index to original index.
+ * Collapses runs of horizontal whitespace (spaces, tabs) to a single space.
+ * Preserves newlines.
+ *
+ * @param {string} str - Original string
+ * @returns {{ normalized: string, indexMap: number[] }}
+ */
+function buildNormalizedMap(str) {
+  const normalized = [];
+  const indexMap = [];
+  let i = 0;
+
+  while (i < str.length) {
+    const ch = str[i];
+
+    if (ch === ' ' || ch === '\t') {
+      // Start of a whitespace run — collapse to single space
+      normalized.push(' ');
+      indexMap.push(i);
+      // Skip the rest of the whitespace run
+      while (i < str.length && (str[i] === ' ' || str[i] === '\t')) {
+        i++;
+      }
+    } else {
+      normalized.push(ch);
+      indexMap.push(i);
+      i++;
+    }
+  }
+
+  return {
+    normalized: normalized.join(''),
+    indexMap,
+  };
+}
+
+/**
+ * Indentation-flexible matching: strips minimum common indentation from both
+ * content window and search lines, then compares.
+ *
+ * @param {string[]} contentLines - Lines of the full file content
+ * @param {string[]} searchLines - Lines of the search string
+ * @returns {{ matchedText: string, count: number } | null}
+ */
+export function indentFlexibleMatch(contentLines, searchLines) {
+  if (searchLines.length === 0) return null;
+
+  // If all search lines are empty, no meaningful match
+  if (searchLines.every(line => line.trim() === '')) return null;
+
+  // Strip minimum indent from search lines
+  const searchMinIndent = getMinIndent(searchLines);
+  const strippedSearch = searchLines.map(line => stripIndent(line, searchMinIndent));
+
+  const windowSize = searchLines.length;
+  const matches = [];
+
+  for (let i = 0; i <= contentLines.length - windowSize; i++) {
+    const windowLines = contentLines.slice(i, i + windowSize);
+    const windowMinIndent = getMinIndent(windowLines);
+    const strippedWindow = windowLines.map(line => stripIndent(line, windowMinIndent));
+
+    let allMatch = true;
+    for (let j = 0; j < windowSize; j++) {
+      if (strippedWindow[j] !== strippedSearch[j]) {
+        allMatch = false;
+        break;
+      }
+    }
+
+    if (allMatch) {
+      const matchedText = windowLines.join('\n');
+      matches.push(matchedText);
+    }
+  }
+
+  if (matches.length === 0) return null;
+
+  return {
+    matchedText: matches[0],
+    count: matches.length,
+  };
+}
+
+/**
+ * Get the minimum indentation level (number of leading whitespace characters)
+ * across all non-empty lines.
+ *
+ * @param {string[]} lines
+ * @returns {number}
+ */
+function getMinIndent(lines) {
+  let min = Infinity;
+
+  for (const line of lines) {
+    // Skip empty or whitespace-only lines for indent calculation
+    if (line.trim() === '') continue;
+
+    const match = line.match(/^([ \t]*)/);
+    if (match) {
+      min = Math.min(min, match[1].length);
+    }
+  }
+
+  return min === Infinity ? 0 : min;
+}
+
+/**
+ * Strip a fixed number of leading characters from a line.
+ * For empty/whitespace-only lines, return them as-is (trimmed to empty)
+ * to handle blank lines in code blocks gracefully.
+ *
+ * @param {string} line
+ * @param {number} amount - Number of leading characters to strip
+ * @returns {string}
+ */
+function stripIndent(line, amount) {
+  if (line.trim() === '') return '';
+  if (amount <= 0) return line;
+  return line.substring(Math.min(amount, line.length));
+}