@probelabs/probe 0.6.0-rc253 → 0.6.0-rc255

package/src/tools/hashline.js

@@ -0,0 +1,131 @@
+/**
+ * Hash-based line integrity utilities for line-targeted editing.
+ * Uses DJB2 hash of whitespace-stripped content, mod 256, as 2-char hex.
+ * Pure functions, zero external dependencies.
+ * @module tools/hashline
+ */
+
+/**
+ * Compute a 2-char hex hash for a line of code.
+ * DJB2 hash of whitespace-stripped content mod 256.
+ * @param {string} line - The line content
+ * @returns {string} 2-char hex hash (e.g. "ab")
+ */
+export function computeLineHash(line) {
+  const stripped = (line || '').replace(/\s+/g, '');
+  let h = 5381;
+  for (let i = 0; i < stripped.length; i++) {
+    h = ((h << 5) + h + stripped.charCodeAt(i)) & 0xFFFFFFFF;
+  }
+  return ((h >>> 0) % 256).toString(16).padStart(2, '0');
+}
+
+/**
+ * Parse a line reference string into line number and optional hash.
+ * Handles XML coercion: number 42 → {line:42, hash:null}
+ * String formats: "42" → {line:42, hash:null}, "42:ab" → {line:42, hash:"ab"}
+ * @param {string|number} ref - Line reference
+ * @returns {{line: number, hash: string|null}|null} Parsed ref or null if invalid
+ */
+export function parseLineRef(ref) {
+  if (ref === undefined || ref === null) return null;
+
+  const str = String(ref).trim();
+  if (!str) return null;
+
+  // Format: "42:ab" (line with hash)
+  const hashMatch = str.match(/^(\d+):([0-9a-fA-F]{2})$/);
+  if (hashMatch) {
+    const line = parseInt(hashMatch[1], 10);
+    if (line < 1 || !isFinite(line)) return null;
+    return { line, hash: hashMatch[2].toLowerCase() };
+  }
+
+  // Format: "42" (plain line number)
+  const lineMatch = str.match(/^(\d+)$/);
+  if (lineMatch) {
+    const line = parseInt(lineMatch[1], 10);
+    if (line < 1 || !isFinite(line)) return null;
+    return { line, hash: null };
+  }
+
+  return null;
+}
+
+/**
+ * Validate a hash against the actual file content at a line number.
+ * @param {number} lineNum - 1-indexed line number
+ * @param {string} hash - Expected 2-char hex hash
+ * @param {string[]} fileLines - Array of file lines
+ * @returns {{valid: boolean, actualHash: string, actualContent: string}}
+ */
+export function validateLineHash(lineNum, hash, fileLines) {
+  const idx = lineNum - 1;
+  if (idx < 0 || idx >= fileLines.length) {
+    return { valid: false, actualHash: '', actualContent: '' };
+  }
+  const actualContent = fileLines[idx];
+  const actualHash = computeLineHash(actualContent);
+  return {
+    valid: actualHash === hash.toLowerCase(),
+    actualHash,
+    actualContent
+  };
+}
+
+/**
+ * Annotate probe output with line hashes.
+ * Transforms "  42 |" to "  42:ab |" in each line.
+ * Handles the probe output format: optional whitespace + line number + space(s) + pipe.
+ * @param {string} output - Raw probe output
+ * @returns {string} Annotated output with hashes
+ */
+export function annotateOutputWithHashes(output) {
+  if (!output || typeof output !== 'string') return output;
+
+  return output.split('\n').map(line => {
+    // Strip trailing \r from CRLF line endings before matching
+    const cleanLine = line.endsWith('\r') ? line.slice(0, -1) : line;
+    // Match probe output format: leading whitespace + digits + whitespace + pipe
+    const match = cleanLine.match(/^(\s*)(\d+)(\s*\|)(.*)$/);
+    if (!match) return line;
+
+    const [, prefix, lineNum, pipeSection, content] = match;
+    const hash = computeLineHash(content);
+    const cr = line.endsWith('\r') ? '\r' : '';
+    return `${prefix}${lineNum}:${hash}${pipeSection}${content}${cr}`;
+  }).join('\n');
+}
+
+/**
+ * Strip accidental line-number or line:hash prefixes from LLM new_string content.
+ * LLMs sometimes echo the "42:ab | " or "42 | " prefix format in their replacement text.
+ * @param {string} text - The new_string content
+ * @returns {{cleaned: string, stripped: boolean}} Cleaned text and whether stripping occurred
+ */
+export function stripHashlinePrefixes(text) {
+  if (!text || typeof text !== 'string') return { cleaned: text || '', stripped: false };
+
+  const lines = text.split('\n');
+  if (lines.length === 0) return { cleaned: '', stripped: false };
+
+  // Check if majority of non-empty lines have the prefix pattern
+  const nonEmptyLines = lines.filter(l => l.trim().length > 0);
+  if (nonEmptyLines.length === 0) return { cleaned: text, stripped: false };
+
+  // Pattern: optional whitespace + digits + optional ":xx" + space(s) + pipe + space
+  const prefixPattern = /^\s*\d+(?::[0-9a-fA-F]{2})?\s*\|\s?/;
+  const matchCount = nonEmptyLines.filter(l => prefixPattern.test(l)).length;
+
+  // Only strip if majority (>50%) of non-empty lines have prefixes
+  if (matchCount / nonEmptyLines.length <= 0.5) {
+    return { cleaned: text, stripped: false };
+  }
+
+  const cleaned = lines.map(line => {
+    if (line.trim().length === 0) return line;
+    return line.replace(prefixPattern, '');
+  }).join('\n');
+
+  return { cleaned, stripped: true };
+}

package/src/tools/lineEditHeuristics.js

@@ -0,0 +1,138 @@
+/**
+ * Heuristic corrections for common LLM mistakes in line-targeted edits.
+ * Handles echo stripping, indent restoration, and prefix stripping.
+ * @module tools/lineEditHeuristics
+ */
+
+import { detectBaseIndent, reindent } from './symbolEdit.js';
+import { stripHashlinePrefixes } from './hashline.js';
+
+/**
+ * Strip boundary lines that LLMs accidentally echo from the file context.
+ *
+ * Rules:
+ * - Replace: if first line of new_string matches the line before start_line → strip it.
+ *            if last line matches the line after end_line → strip it.
+ * - Insert-after: if first line matches the anchor line → strip it.
+ * - Insert-before: if last line matches the anchor line → strip it.
+ * - Blank lines are never considered matches (two blanks matching is coincidence).
+ *
+ * @param {string} newStr - The new_string content
+ * @param {string[]} fileLines - Array of file lines (0-indexed)
+ * @param {number} startLine - 1-indexed start line
+ * @param {number} endLine - 1-indexed end line (same as startLine for single-line or insert)
+ * @param {string|undefined} position - "before", "after", or undefined (replace mode)
+ * @returns {{result: string, modifications: string[]}}
+ */
+export function stripEchoedBoundaries(newStr, fileLines, startLine, endLine, position) {
+  const modifications = [];
+  let lines = newStr.split('\n');
+
+  if (lines.length === 0) return { result: newStr, modifications };
+
+  if (position === 'after') {
+    // Insert-after: anchor line is at startLine (1-indexed)
+    const anchorIdx = startLine - 1;
+    if (anchorIdx >= 0 && anchorIdx < fileLines.length) {
+      const anchorTrimmed = fileLines[anchorIdx].trim();
+      if (anchorTrimmed.length > 0 && lines.length > 0 && lines[0].trim() === anchorTrimmed) {
+        lines = lines.slice(1);
+        modifications.push('stripped echoed anchor line (insert-after)');
+      }
+    }
+  } else if (position === 'before') {
+    // Insert-before: anchor line is at startLine (1-indexed)
+    const anchorIdx = startLine - 1;
+    if (anchorIdx >= 0 && anchorIdx < fileLines.length) {
+      const anchorTrimmed = fileLines[anchorIdx].trim();
+      if (anchorTrimmed.length > 0 && lines.length > 0 && lines[lines.length - 1].trim() === anchorTrimmed) {
+        lines = lines.slice(0, -1);
+        modifications.push('stripped echoed anchor line (insert-before)');
+      }
+    }
+  } else {
+    // Replace mode: check line before start and line after end
+    const beforeIdx = startLine - 2; // line before start (0-indexed)
+    if (beforeIdx >= 0 && beforeIdx < fileLines.length) {
+      const beforeTrimmed = fileLines[beforeIdx].trim();
+      if (beforeTrimmed.length > 0 && lines.length > 0 && lines[0].trim() === beforeTrimmed) {
+        lines = lines.slice(1);
+        modifications.push('stripped echoed line before range');
+      }
+    }
+
+    const afterIdx = endLine; // line after end (0-indexed, since endLine is 1-indexed)
+    if (afterIdx >= 0 && afterIdx < fileLines.length) {
+      const afterTrimmed = fileLines[afterIdx].trim();
+      if (afterTrimmed.length > 0 && lines.length > 0 && lines[lines.length - 1].trim() === afterTrimmed) {
+        lines = lines.slice(0, -1);
+        modifications.push('stripped echoed line after range');
+      }
+    }
+  }
+
+  return { result: lines.join('\n'), modifications };
+}
+
+/**
+ * Restore indentation if the replacement has a different base indent than the original lines.
+ * @param {string} newStr - The new_string content
+ * @param {string[]} originalLines - The original lines being replaced (from the file)
+ * @returns {{result: string, modifications: string[]}}
+ */
+export function restoreIndentation(newStr, originalLines) {
+  const modifications = [];
+
+  if (!newStr || !originalLines || originalLines.length === 0) {
+    return { result: newStr || '', modifications };
+  }
+
+  const originalCode = originalLines.join('\n');
+  const targetIndent = detectBaseIndent(originalCode);
+  const newIndent = detectBaseIndent(newStr);
+
+  if (targetIndent !== newIndent) {
+    const reindented = reindent(newStr, targetIndent);
+    if (reindented !== newStr) {
+      modifications.push(`reindented from "${newIndent}" to "${targetIndent}"`);
+      return { result: reindented, modifications };
+    }
+  }
+
+  return { result: newStr, modifications };
+}
+
+/**
+ * Pipeline: stripHashlinePrefixes → stripEchoedBoundaries → restoreIndentation.
+ * @param {string} newStr - The new_string content
+ * @param {string[]} fileLines - Array of all file lines (0-indexed)
+ * @param {number} startLine - 1-indexed start line
+ * @param {number} endLine - 1-indexed end line
+ * @param {string|undefined} position - "before", "after", or undefined
+ * @returns {{cleaned: string, modifications: string[]}}
+ */
+export function cleanNewString(newStr, fileLines, startLine, endLine, position) {
+  const modifications = [];
+
+  if (!newStr && newStr !== '') return { cleaned: '', modifications };
+
+  // Step 1: Strip hashline prefixes
+  const { cleaned: afterPrefixes, stripped } = stripHashlinePrefixes(newStr);
+  if (stripped) modifications.push('stripped line-number prefixes');
+
+  // Step 2: Strip echoed boundaries
+  const { result: afterEchoes, modifications: echoMods } = stripEchoedBoundaries(
+    afterPrefixes, fileLines, startLine, endLine, position
+  );
+  modifications.push(...echoMods);
+
+  // Step 3: Restore indentation (only for replace mode, not insert)
+  if (!position) {
+    const originalLines = fileLines.slice(startLine - 1, endLine);
+    const { result: afterIndent, modifications: indentMods } = restoreIndentation(afterEchoes, originalLines);
+    modifications.push(...indentMods);
+    return { cleaned: afterIndent, modifications };
+  }
+
+  return { cleaned: afterEchoes, modifications };
+}

package/src/tools/symbolEdit.js

@@ -0,0 +1,119 @@
+/**
+ * AST-aware symbol editing helpers
+ * Uses probe's tree-sitter AST parsing to find and manipulate code symbols.
+ * @module tools/symbolEdit
+ */
+
+import { extract } from '../extract.js';
+
+/**
+ * Look up a symbol in a file using probe's AST-based extract
+ * @param {string} filePath - Absolute path to the file
+ * @param {string} symbolName - Name of the symbol to find
+ * @param {string} cwd - Working directory for extract
+ * @returns {Promise<Object|null>} Symbol info with startLine, endLine, code, nodeType, file; or null
+ */
+export async function findSymbol(filePath, symbolName, cwd) {
+  try {
+    const result = await extract({
+      files: [`${filePath}#${symbolName}`],
+      format: 'json',
+      json: true,
+      cwd
+    });
+
+    if (!result || !result.results || result.results.length === 0) {
+      return null;
+    }
+
+    const match = result.results[0];
+    return {
+      startLine: match.lines[0],  // 1-indexed
+      endLine: match.lines[1],    // 1-indexed
+      code: match.code,
+      nodeType: match.node_type,
+      file: match.file
+    };
+  } catch (error) {
+    if (process.env.DEBUG === '1') {
+      console.error(`[SymbolEdit] findSymbol error for "${symbolName}" in ${filePath}: ${error.message}`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Look up ALL matching symbols in a file using probe's AST-based extract.
+ * When a bare name like "process" matches multiple definitions (e.g. a top-level
+ * function AND class methods), this returns all of them with qualified names.
+ * @param {string} filePath - Absolute path to the file
+ * @param {string} symbolName - Name of the symbol to find
+ * @param {string} cwd - Working directory for extract
+ * @returns {Promise<Array<Object>>} Array of symbol info objects (may be empty)
+ */
+export async function findAllSymbols(filePath, symbolName, cwd) {
+  try {
+    const result = await extract({
+      files: [`${filePath}#${symbolName}`],
+      format: 'json',
+      json: true,
+      cwd
+    });
+
+    if (!result || !result.results || result.results.length === 0) {
+      return [];
+    }
+
+    return result.results.map(match => ({
+      startLine: match.lines[0],
+      endLine: match.lines[1],
+      code: match.code,
+      nodeType: match.node_type,
+      file: match.file,
+      qualifiedName: match.symbol_signature || symbolName,
+    }));
+  } catch (error) {
+    if (process.env.DEBUG === '1') {
+      console.error(`[SymbolEdit] findAllSymbols error for "${symbolName}" in ${filePath}: ${error.message}`);
+    }
+    return [];
+  }
+}
+
+/**
+ * Detect the base indentation of a code block (leading whitespace of first non-empty line)
+ * @param {string} code - The code block
+ * @returns {string} The leading whitespace string
+ */
+export function detectBaseIndent(code) {
+  const lines = code.split('\n');
+  for (const line of lines) {
+    if (line.trim().length > 0) {
+      const match = line.match(/^(\s*)/);
+      return match ? match[1] : '';
+    }
+  }
+  return '';
+}
+
+/**
+ * Reindent new content to match a target indentation level.
+ * Strips the existing base indent from the new content and replaces it with the target indent.
+ * @param {string} newContent - The new code content to reindent
+ * @param {string} targetIndent - The target indentation string
+ * @returns {string} Reindented content
+ */
+export function reindent(newContent, targetIndent) {
+  const lines = newContent.split('\n');
+  const sourceIndent = detectBaseIndent(newContent);
+
+  return lines.map(line => {
+    if (line.trim().length === 0) {
+      return '';
+    }
+    if (line.startsWith(sourceIndent)) {
+      return targetIndent + line.slice(sourceIndent.length);
+    }
+    return line;
+  }).join('\n');
+}

package/src/tools/vercel.js

@@ -11,6 +11,7 @@ import { delegate } from '../delegate.js';
 import { analyzeAll } from './analyzeAll.js';
 import { searchSchema, querySchema, extractSchema, delegateSchema, analyzeAllSchema, searchDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription, parseTargets, parseAndResolvePaths, resolveTargetPath } from './common.js';
 import { formatErrorForAI } from '../utils/error-types.js';
+import { annotateOutputWithHashes } from './hashline.js';
 
 const CODE_SEARCH_SCHEMA = {
 	type: 'object',
@@ -161,9 +162,17 @@ export const searchTool = (options = {}) => {
 		maxTokens = 20000,
 		debug = false,
 		outline = false,
-		searchDelegate = false
+		searchDelegate = false,
+		hashLines = false
 	} = options;
 
+	const maybeAnnotate = (result) => {
+		if (hashLines && typeof result === 'string') {
+			return annotateOutputWithHashes(result);
+		}
+		return result;
+	};
+
 	return tool({
 		name: 'search',
 		description: searchDelegate
@@ -215,7 +224,12 @@ export const searchTool = (options = {}) => {
 
 			if (!searchDelegate) {
 				try {
-					return await runRawSearch();
+					const result = maybeAnnotate(await runRawSearch());
+					// Track files found in search results for staleness detection
+					if (options.fileTracker && typeof result === 'string') {
+						options.fileTracker.trackFilesFromOutput(result, options.cwd || '.').catch(() => {});
+					}
+					return result;
 				} catch (error) {
 					console.error('Error executing search command:', error);
 					return formatErrorForAI(error);
@@ -265,7 +279,11 @@ export const searchTool = (options = {}) => {
 					if (debug) {
 						console.error('Delegated search returned no targets; falling back to raw search');
 					}
-					return await runRawSearch();
+					const fallbackResult = maybeAnnotate(await runRawSearch());
+					if (options.fileTracker && typeof fallbackResult === 'string') {
+						options.fileTracker.trackFilesFromOutput(fallbackResult, options.cwd || '.').catch(() => {});
+					}
+					return fallbackResult;
 				}
 
 				// Resolve relative paths against the actual search directory, not the general cwd.
@@ -288,14 +306,18 @@ export const searchTool = (options = {}) => {
 				// Strip workspace root prefix from extract output so paths are relative
 				if (resolutionBase && typeof extractResult === 'string') {
 					const wsPrefix = resolutionBase.endsWith('/') ? resolutionBase : resolutionBase + '/';
-					return extractResult.split(wsPrefix).join('');
+					return maybeAnnotate(extractResult.split(wsPrefix).join(''));
 				}
 
-				return extractResult;
+				return maybeAnnotate(extractResult);
 			} catch (error) {
 				console.error('Delegated search failed, falling back to raw search:', error);
 				try {
-					return await runRawSearch();
+					const fallbackResult2 = maybeAnnotate(await runRawSearch());
+					if (options.fileTracker && typeof fallbackResult2 === 'string') {
+						options.fileTracker.trackFilesFromOutput(fallbackResult2, options.cwd || '.').catch(() => {});
+					}
+					return fallbackResult2;
 				} catch (fallbackError) {
 					console.error('Error executing search command:', fallbackError);
 					// Both delegation and fallback failed - provide detailed error
@@ -366,7 +388,7 @@ export const queryTool = (options = {}) => {
  * @returns {Object} Configured extract tool
  */
 export const extractTool = (options = {}) => {
-	const { debug = false, outline = false } = options;
+	const { debug = false, outline = false, hashLines = false } = options;
 
 	return tool({
 		name: 'extract',
@@ -388,6 +410,7 @@ export const extractTool = (options = {}) => {
 				// Create a temporary file for input content if provided
 				let tempFilePath = null;
 				let extractOptions = { cwd: effectiveCwd };
+				let extractFiles = null; // Track resolved file targets for content hashing
 
 				if (input_content) {
 					// Import required modules
@@ -424,7 +447,7 @@ export const extractTool = (options = {}) => {
 					const parsedTargets = parseTargets(targets);
 
 					// Resolve relative paths in targets against cwd
-					const files = parsedTargets.map(target => resolveTargetPath(target, effectiveCwd));
+					extractFiles = parsedTargets.map(target => resolveTargetPath(target, effectiveCwd));
 
 					// Apply format mapping for outline-xml to xml
 					let effectiveFormat = format;
@@ -434,7 +457,7 @@ export const extractTool = (options = {}) => {
 
 					// Set up extract options with files
 					extractOptions = {
-						files,
+						files: extractFiles,
 						cwd: effectiveCwd,
 						allowTests: allow_tests ?? true,
 						contextLines: context_lines,
@@ -447,6 +470,11 @@ export const extractTool = (options = {}) => {
 				// Execute the extract command
 				const results = await extract(extractOptions);
 
+				// Track files and symbol content for staleness detection (post-extract)
+				if (options.fileTracker && extractFiles && extractFiles.length > 0) {
+					options.fileTracker.trackFilesFromExtract(extractFiles, effectiveCwd).catch(() => {});
+				}
+
 				// Clean up temporary file if created
 				if (tempFilePath) {
 					const { unlinkSync } = await import('fs');
@@ -460,6 +488,9 @@ export const extractTool = (options = {}) => {
 					}
 				}
 
+				if (hashLines && typeof results === 'string') {
+					return annotateOutputWithHashes(results);
+				}
 				return results;
 			} catch (error) {
 				console.error('Error executing extract command:', error);