@probelabs/probe 0.6.0-rc291 → 0.6.0-rc293

package/build/agent/dsl/environment.js

@@ -234,7 +234,14 @@ export function generateSandboxGlobals(options) {
         }
         return tryParseJSONValue(text);
       };
-      globals[name] = traceToolCall(name, rawMcpFn, tracer, logFn);
+      const tracedFn = traceToolCall(name, rawMcpFn, tracer, logFn);
+      globals[name] = tracedFn;
+      // Register sanitized alias for names with hyphens/dots/etc that aren't valid JS identifiers
+      // e.g. "workable-api" → also available as "workable_api"
+      const sanitized = name.replace(/[^a-zA-Z0-9_$]/g, '_');
+      if (sanitized !== name) {
+        globals[sanitized] = tracedFn;
+      }
     }
   }
 

package/build/agent/dsl/runtime.js

@@ -181,9 +181,17 @@ export function createDSLRuntime(options) {
         'dsl.error': e.message?.substring(0, 500),
       });
 
+      // Enrich "X is not defined" errors with available tool names
+      let errorMsg = `Execution failed: ${e.message}`;
+      if (e.message && e.message.includes('is not defined')) {
+        const globalNames = Object.keys(toolGlobals).sort();
+        errorMsg += `\nAvailable functions: ${globalNames.join(', ')}`;
+        errorMsg += `\nNote: Tools with hyphens (e.g. "my-tool") are available with underscores: my_tool()`;
+      }
+
       return {
         status: 'error',
-        error: `Execution failed: ${e.message}`,
+        error: errorMsg,
         logs,
       };
     }

package/build/agent/shared/prompts.js

@@ -90,9 +90,9 @@ If the solution is clear, you can jump to implementation right away. If not, ask
 - Do not add code comments unless the logic is genuinely complex and non-obvious.
 
 # Before Implementation
-- Focus on high-level design patterns and system organization
-- Identify architectural patterns and component relationships
-- Evaluate system structure and suggest architectural improvements
+- Read tests first — find existing test files for the module you're changing. They reveal expected behavior, edge cases, and the project's testing patterns.
+- Read neighboring files — understand naming conventions, error handling patterns, import style, and existing utilities before creating new ones.
+- Trace the call chain — follow how the code you're changing is called and what depends on it. Check interfaces, types, and consumers.
 - Focus on backward compatibility
 - Consider scalability, maintainability, and extensibility in your analysis
 
@@ -117,6 +117,20 @@ Before building or testing, determine the project's toolchain:
 - Read README for build/test instructions if the above are unclear
 - Common patterns: \`make build\`/\`make test\`, \`npm run build\`/\`npm test\`, \`cargo build\`/\`cargo test\`, \`go build ./...\`/\`go test ./...\`, \`python -m pytest\`
 
+# File Editing Rules
+You have access to the \`edit\`, \`create\`, and \`multi_edit\` tools for modifying files. You MUST use these tools for ALL code changes. They are purpose-built, atomic, and safe.
+
+DO NOT use sed, awk, echo/cat redirection, or heredocs to modify source code. These commands cause real damage in practice: truncated lines, duplicate code blocks, broken syntax. Every bad edit wastes iterations on fix-up commits.
+
+Use the right tool:
+1. To MODIFY existing code → \`edit\` tool (old_string → new_string, or start_line/end_line)
+2. To CREATE a new file → \`create\` tool
+3. To CHANGE multiple files at once → \`multi_edit\` tool
+4. To READ code → \`extract\` or \`search\` tools
+5. If \`edit\` fails with "file has not been read yet" → use \`extract\` with the EXACT same file path you will pass to \`edit\`. Relative vs absolute path mismatch causes this error. Use the same path format consistently. If it still fails, use bash \`cat\` to read the file, then use \`create\` to write the entire modified file. Do NOT fall back to sed.
+
+Bash is fine for: formatters (gofmt, prettier, black), build/test/lint commands, git operations, and read-only file inspection (cat, head, tail). sed/awk should ONLY be used for trivial non-code tasks (e.g., config file tweaks) where the replacement is a simple literal string swap.
+
 # During Implementation
 - Always create a new branch before making changes to the codebase.
 - Fix problems at the root cause, not with surface-level patches. Prefer general solutions over special cases.
@@ -143,6 +157,22 @@ Before committing or creating a PR, run through this checklist:
 
 Do NOT skip verification. Do NOT proceed to PR creation with a broken build or failing tests.
 
+# Output Integrity
+Your final output MUST accurately reflect what ACTUALLY happened. Do NOT fabricate, hallucinate, or report aspirational results.
+
+- Only report PR URLs you actually created or updated with \`gh pr create\` or \`git push\`. If you checked out an existing PR but did NOT push changes to it, do NOT claim you updated it.
+- Describe what you ACTUALLY DID, not what you planned or intended to do. If you ran out of iterations, say so. If tests failed, say so.
+- Only list files you actually modified AND committed.
+- If you could not complete the task — ran out of iterations, tests failed, build broken, push rejected — report the real reason honestly.
+
+NEVER claim success when:
+- You did not run \`git push\` successfully
+- Tests failed and you did not fix them
+- You hit the iteration limit before completing the work
+- You only analyzed/investigated but did not implement changes
+
+A false success report is WORSE than an honest failure — it misleads the user into thinking work is done when it is not.
+
 # GitHub Integration
 - Use the \`gh\` CLI for all GitHub operations: issues, pull requests, checks, releases.
 - To view issues or PRs: \`gh issue view <number>\`, \`gh pr view <number>\`.

package/build/tools/executePlan.js

@@ -778,6 +778,7 @@ return table;
 - Do NOT define helper functions that call tools. Write all logic inline or use for..of loops.
 - Do NOT use regex literals (/pattern/) — use String methods like indexOf, includes, startsWith instead.
 - ONLY use functions listed below. Do NOT call functions that are not listed.
+- MCP tools with hyphens in their names (e.g. \`workable-api\`) are available using underscores: \`workable_api()\`. Hyphens are not valid in JS identifiers.
 
 ### Available functions
 

package/build/tools/fileTracker.js

@@ -12,9 +12,22 @@
  */
 
 import { createHash } from 'crypto';
-import { resolve, isAbsolute } from 'path';
+import { resolve, isAbsolute, normalize } from 'path';
 import { findSymbol } from './symbolEdit.js';
 
+/**
+ * Normalize a file path for consistent storage and lookup.
+ * Resolves '.', '..', double slashes, and ensures absolute paths are canonical.
+ * Does NOT resolve symlinks (that would be expensive and might fail for non-existent files).
+ * @param {string} filePath - Path to normalize
+ * @returns {string} Normalized path
+ */
+function normalizePath(filePath) {
+  if (!filePath) return filePath;
+  // resolve() handles '.', '..', double slashes, and makes the path absolute
+  return resolve(filePath);
+}
+
 /**
  * Compute a SHA-256 content hash for a code block.
  * Normalizes trailing whitespace per line for robustness against editor formatting.
@@ -106,10 +119,11 @@ export class FileTracker {
    * @param {string} resolvedPath - Absolute path to the file
    */
   markFileSeen(resolvedPath) {
-    this._seenFiles.add(resolvedPath);
-    this._textEditCounts.set(resolvedPath, 0);
+    const normalized = normalizePath(resolvedPath);
+    this._seenFiles.add(normalized);
+    this._textEditCounts.set(normalized, 0);
     if (this.debug) {
-      console.error(`[FileTracker] Marked as seen: ${resolvedPath}`);
+      console.error(`[FileTracker] Marked as seen: ${normalized}`);
     }
   }
 
@@ -119,7 +133,7 @@ export class FileTracker {
    * @returns {boolean}
    */
   isFileSeen(resolvedPath) {
-    return this._seenFiles.has(resolvedPath);
+    return this._seenFiles.has(normalizePath(resolvedPath));
   }
 
   /**
@@ -132,7 +146,7 @@ export class FileTracker {
    * @param {string} [source='extract'] - How the content was obtained
    */
   trackSymbolContent(resolvedPath, symbolName, code, startLine, endLine, source = 'extract') {
-    const key = `${resolvedPath}#${symbolName}`;
+    const key = `${normalizePath(resolvedPath)}#${symbolName}`;
     const contentHash = computeContentHash(code);
     this._contentRecords.set(key, {
       contentHash,
@@ -154,7 +168,7 @@ export class FileTracker {
    * @returns {Object|null} The stored record or null
    */
   getSymbolRecord(resolvedPath, symbolName) {
-    return this._contentRecords.get(`${resolvedPath}#${symbolName}`) || null;
+    return this._contentRecords.get(`${normalizePath(resolvedPath)}#${symbolName}`) || null;
   }
 
   /**
@@ -165,7 +179,7 @@ export class FileTracker {
    * @returns {{ok: boolean, reason?: string, message?: string}}
    */
   checkSymbolContent(resolvedPath, symbolName, currentCode) {
-    const key = `${resolvedPath}#${symbolName}`;
+    const key = `${normalizePath(resolvedPath)}#${symbolName}`;
     const record = this._contentRecords.get(key);
 
     if (!record) {
@@ -253,7 +267,7 @@ export class FileTracker {
    * @returns {{ok: boolean, reason?: string, message?: string}}
    */
   checkBeforeEdit(resolvedPath) {
-    if (!this._seenFiles.has(resolvedPath)) {
+    if (!this._seenFiles.has(normalizePath(resolvedPath))) {
       return {
         ok: false,
         reason: 'untracked',
@@ -269,8 +283,9 @@ export class FileTracker {
    * @param {string} resolvedPath - Absolute path to the file
    */
   async trackFileAfterWrite(resolvedPath) {
-    this._seenFiles.add(resolvedPath);
-    this.invalidateFileRecords(resolvedPath);
+    const normalized = normalizePath(resolvedPath);
+    this._seenFiles.add(normalized);
+    this.invalidateFileRecords(normalized);
   }
 
   /**
@@ -279,10 +294,11 @@ export class FileTracker {
    * @param {string} resolvedPath - Absolute path to the file
    */
   recordTextEdit(resolvedPath) {
-    const count = (this._textEditCounts.get(resolvedPath) || 0) + 1;
-    this._textEditCounts.set(resolvedPath, count);
+    const normalized = normalizePath(resolvedPath);
+    const count = (this._textEditCounts.get(normalized) || 0) + 1;
+    this._textEditCounts.set(normalized, count);
     if (this.debug) {
-      console.error(`[FileTracker] Text edit #${count} for ${resolvedPath}`);
+      console.error(`[FileTracker] Text edit #${count} for ${normalized}`);
     }
   }
 
@@ -292,7 +308,7 @@ export class FileTracker {
    * @returns {{ok: boolean, editCount?: number, message?: string}}
    */
   checkTextEditStaleness(resolvedPath) {
-    const count = this._textEditCounts.get(resolvedPath) || 0;
+    const count = this._textEditCounts.get(normalizePath(resolvedPath)) || 0;
     if (count >= this.maxConsecutiveTextEdits) {
       return {
         ok: false,
@@ -323,7 +339,7 @@ export class FileTracker {
    * @param {string} resolvedPath - Absolute path to the file
    */
   invalidateFileRecords(resolvedPath) {
-    const prefix = resolvedPath + '#';
+    const prefix = normalizePath(resolvedPath) + '#';
     for (const key of this._contentRecords.keys()) {
       if (key.startsWith(prefix)) {
         this._contentRecords.delete(key);
@@ -340,7 +356,7 @@ export class FileTracker {
    * @returns {boolean}
    */
   isTracked(resolvedPath) {
-    return this.isFileSeen(resolvedPath);
+    return this.isFileSeen(normalizePath(resolvedPath));
   }
 
   /**

package/build/tools/fuzzyMatch.js

@@ -73,7 +73,17 @@ export function lineTrimmedMatch(contentLines, searchLines) {
       }
     }
     if (allMatch) {
-      const matchedText = contentLines.slice(i, i + windowSize).join('\n');
+      // Limit indent tolerance: even though trimmed content matches, reject when
+      // the indentation level difference is too large — it likely means the match
+      // is in a completely different scope (issue #507).
+      const windowLines = contentLines.slice(i, i + windowSize);
+      const windowMinIndent = getMinIndent(windowLines);
+      const searchMinIndent = getMinIndent(searchLines);
+      const indentDiff = Math.abs(windowMinIndent - searchMinIndent);
+      if (isIndentDiffTooLarge(windowLines, searchLines, indentDiff)) {
+        continue; // Skip — too far off in nesting
+      }
+      const matchedText = windowLines.join('\n');
       matches.push(matchedText);
     }
   }
@@ -134,6 +144,19 @@ export function whitespaceNormalizedMatch(content, search) {
     }
 
     const matchedText = content.substring(originalStart, actualEnd);
+
+    // Limit indent tolerance: reject matches where the indentation level
+    // difference is too large — likely a wrong-scope match (issue #507).
+    const matchedLines = matchedText.split('\n');
+    const searchLines = search.split('\n');
+    const matchMinIndent = getMinIndent(matchedLines);
+    const searchMinIndent = getMinIndent(searchLines);
+    const indentDiff = Math.abs(matchMinIndent - searchMinIndent);
+    if (isIndentDiffTooLarge(matchedLines, searchLines, indentDiff)) {
+      searchStart = idx + 1;
+      continue; // Skip — too far off in nesting
+    }
+
     matches.push(matchedText);
 
     searchStart = idx + 1;
@@ -219,6 +242,15 @@ export function indentFlexibleMatch(contentLines, searchLines) {
     }
 
     if (allMatch) {
+      // Limit indent tolerance: reject matches where indentation differs by more than
+      // 1 level. Larger differences likely mean the match is in a completely different
+      // scope/nesting level — silent file corruption risk (issue #507).
+      // For tabs: 1 tab = 1 level, so max diff = 1.
+      // For spaces: detect indent unit (2 or 4), allow 1 unit of difference.
+      const indentDiff = Math.abs(windowMinIndent - searchMinIndent);
+      if (isIndentDiffTooLarge(windowLines, searchLines, indentDiff)) {
+        continue; // Skip — too far off in nesting
+      }
       const matchedText = windowLines.join('\n');
       matches.push(matchedText);
     }
@@ -232,6 +264,25 @@ export function indentFlexibleMatch(contentLines, searchLines) {
   };
 }
 
+/**
+ * Check if an indentation difference exceeds the allowed limit.
+ * Uses tab-aware threshold: 1 for tabs, 4 for spaces.
+ * Checks BOTH sides for tab usage to avoid asymmetric detection.
+ *
+ * @param {string[]} linesA - First set of lines
+ * @param {string[]} linesB - Second set of lines
+ * @param {number} indentDiff - Absolute difference in min indent
+ * @returns {boolean} true if the diff exceeds the limit
+ */
+function isIndentDiffTooLarge(linesA, linesB, indentDiff) {
+  if (indentDiff <= 0) return false;
+  const sampleA = linesA.find(l => l.trim().length > 0) || '';
+  const sampleB = linesB.find(l => l.trim().length > 0) || '';
+  const useTabs = sampleA.startsWith('\t') || sampleB.startsWith('\t');
+  const maxAllowedDiff = useTabs ? 1 : 4;
+  return indentDiff > maxAllowedDiff;
+}
+
 /**
  * Get the minimum indentation level (number of leading whitespace characters)
  * across all non-empty lines.

package/build/tools/lineEditHeuristics.js

@@ -92,6 +92,17 @@ export function restoreIndentation(newStr, originalLines) {
   const newIndent = detectBaseIndent(newStr);
 
   if (targetIndent !== newIndent) {
+    // Limit auto-reindent tolerance: reject when indentation differs by more than
+    // 1 level. Larger differences likely mean the match landed in a completely
+    // different scope — allowing it risks silent file corruption (issue #507).
+    // For tabs: 1 tab = 1 level, so max diff = 1 char.
+    // For spaces: 1 level = up to 4 spaces, so max diff = 4 chars.
+    const indentDiff = Math.abs(targetIndent.length - newIndent.length);
+    const useTabs = targetIndent.includes('\t') || newIndent.includes('\t');
+    const maxAllowedDiff = useTabs ? 1 : 4;
+    if (indentDiff > maxAllowedDiff) {
+      return { result: newStr, modifications };
+    }
     const reindented = reindent(newStr, targetIndent);
     if (reindented !== newStr) {
       modifications.push(`reindented from "${newIndent}" to "${targetIndent}"`);

package/build/tools/vercel.js

@@ -385,7 +385,7 @@ export const searchTool = (options = {}) => {
 			? searchDelegateDescription
 			: searchDescription,
 		inputSchema: searchSchema,
-		execute: async ({ query: searchQuery, path, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage }) => {
+		execute: async ({ query: searchQuery, path, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage, workingDirectory }) => {
 			// Auto-quote mixed-case and underscore terms to prevent unwanted stemming/splitting
 			// Skip when exact=true since that already preserves the literal string
 			if (!exact && searchQuery) {
@@ -399,15 +399,18 @@ export const searchTool = (options = {}) => {
 			// Use parameter maxTokens if provided, otherwise use the default
 			const effectiveMaxTokens = paramMaxTokens || maxTokens;
 
+			// Use workingDirectory (injected by _buildNativeTools at runtime) > cwd from config > fallback
+			const effectiveSearchCwd = workingDirectory || options.cwd || '.';
+
 			// Parse and resolve paths (supports comma-separated and relative paths)
 			let searchPaths;
 			if (path) {
-				searchPaths = parseAndResolvePaths(path, options.cwd);
+				searchPaths = parseAndResolvePaths(path, effectiveSearchCwd);
 			}
 
 			// Default to cwd or '.' if no paths provided
 			if (!searchPaths || searchPaths.length === 0) {
-				searchPaths = [options.cwd || '.'];
+				searchPaths = [effectiveSearchCwd];
 			}
 
 			// Join paths with space for CLI (probe search supports multiple paths)
@@ -416,7 +419,7 @@ export const searchTool = (options = {}) => {
 			const searchOptions = {
 				query: searchQuery,
 				path: searchPath,
-				cwd: options.cwd, // Working directory for resolving relative paths
+				cwd: effectiveSearchCwd, // Working directory for resolving relative paths
 				allowTests: allow_tests ?? true,
 				exact,
 				json: false,
@@ -473,7 +476,7 @@ export const searchTool = (options = {}) => {
 					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(() => {});
+						options.fileTracker.trackFilesFromOutput(result, effectiveSearchCwd).catch(() => {});
 					}
 					return result;
 				} catch (error) {
@@ -532,7 +535,7 @@ export const searchTool = (options = {}) => {
 					}
 					const fallbackResult = maybeAnnotate(await runRawSearch());
 					if (options.fileTracker && typeof fallbackResult === 'string') {
-						options.fileTracker.trackFilesFromOutput(fallbackResult, options.cwd || '.').catch(() => {});
+						options.fileTracker.trackFilesFromOutput(fallbackResult, effectiveSearchCwd).catch(() => {});
 					}
 					return fallbackResult;
 				}
@@ -614,7 +617,7 @@ export const searchTool = (options = {}) => {
 				try {
 					const fallbackResult2 = maybeAnnotate(await runRawSearch());
 					if (options.fileTracker && typeof fallbackResult2 === 'string') {
-						options.fileTracker.trackFilesFromOutput(fallbackResult2, options.cwd || '.').catch(() => {});
+						options.fileTracker.trackFilesFromOutput(fallbackResult2, effectiveSearchCwd).catch(() => {});
 					}
 					return fallbackResult2;
 				} catch (fallbackError) {
@@ -693,10 +696,10 @@ export const extractTool = (options = {}) => {
 		name: 'extract',
 		description: extractDescription,
 		inputSchema: extractSchema,
-		execute: async ({ targets, input_content, line, end_line, allow_tests, context_lines, format }) => {
+		execute: async ({ targets, input_content, line, end_line, allow_tests, context_lines, format, workingDirectory }) => {
 			try {
-				// Use the cwd from config for working directory
-				const effectiveCwd = options.cwd || '.';
+				// Use workingDirectory (injected by _buildNativeTools at runtime) > cwd from config > fallback
+				const effectiveCwd = workingDirectory || options.cwd || '.';
 
 				if (debug) {
 					if (targets) {