@probelabs/probe 0.6.0-rc266 → 0.6.0-rc268

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc266",
+  "version": "0.6.0-rc268",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/agent/ProbeAgent.js

@@ -1836,9 +1836,13 @@ export class ProbeAgent {
     }
 
     // Add all enabled tools from toolImplementations
+    // Note: MCP tools are also in toolImplementations but have no schema in _getToolSchemaAndDescription.
+    // They are handled separately via mcpBridge.getVercelTools() below, so we skip them here.
     for (const [toolName, toolImpl] of Object.entries(this.toolImplementations)) {
       // Get schema and description for this tool
-      const { schema, description } = this._getToolSchemaAndDescription(toolName);
+      const toolInfo = this._getToolSchemaAndDescription(toolName);
+      if (!toolInfo) continue;
+      const { schema, description } = toolInfo;
       if (schema && description) {
         nativeTools[toolName] = wrapTool(toolName, schema, description, toolImpl.execute);
       }
@@ -2944,11 +2948,11 @@ Follow these instructions carefully:
 6. Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.${this.allowEdit ? `
 7. When modifying files, choose the appropriate tool:
     - Use 'edit' for all code modifications:
-      * For small changes (a line or a few lines), use old_string + new_string — copy old_string verbatim from the file.
-      * For rewriting entire functions/classes/methods, use the symbol parameter instead (no exact text matching needed).
-      * For editing specific lines from search/extract output, use start_line (and optionally end_line) with the line numbers shown in the output.${this.hashLines ? ' Line references include content hashes (e.g. "42:ab") for integrity verification.' : ''}
+      * PREFERRED: Use start_line (and optionally end_line) for line-targeted editing — this is the safest and most precise approach.${this.hashLines ? ' Use the line:hash references from extract/search output (e.g. "42:ab") for integrity verification.' : ''} Always use extract first to see line numbers${this.hashLines ? ' and hashes' : ''}, then edit by line reference.
       * For editing inside large functions: first use extract with the symbol target (e.g. "file.js#myFunction") to see the function with line numbers${this.hashLines ? ' and hashes' : ''}, then use start_line/end_line to surgically edit specific lines within it.
-      * IMPORTANT: Keep old_string as small as possible — include only the lines you need to change plus minimal context for uniqueness. For replacing large blocks (10+ lines), prefer line-targeted editing with start_line/end_line to constrain scope.
+      * For rewriting entire functions/classes/methods, use the symbol parameter instead (no exact text matching needed).
+      * FALLBACK ONLY: Use old_string + new_string for simple single-line changes where the text is unique. Copy old_string verbatim from the file. Keep old_string as small as possible.
+      * IMPORTANT: After multiple edits to the same file, re-read the changed areas before continuing — use extract with a targeted symbol (e.g. "file.js#myFunction") or a line range (e.g. "file.js:50-80") instead of re-reading the full file.
     - Use 'create' for new files or complete file rewrites.
     - If an edit fails, read the error message — it tells you exactly how to fix the call and retry.
     - The system tracks which files you've seen via search/extract. If you try to edit a file you haven't read, or one that changed since you last read it, the edit will fail with instructions to re-read first. Always use extract before editing to ensure you have current file content.` : ''}

package/src/agent/shared/prompts.js

@@ -5,6 +5,9 @@
 export const predefinedPrompts = {
   'code-explorer': `You are ProbeChat Code Explorer, a specialized AI assistant focused on helping developers, product managers, and QAs understand and navigate codebases. Your primary function is to answer questions based on code, explain how systems work, and provide insights into code functionality using the provided code analysis tools.
 
+CRITICAL - You are READ-ONLY:
+You must NEVER create, modify, delete, or write files. You are strictly an exploration and analysis tool. If asked to make changes, implement features, fix bugs, or modify a PR, refuse and explain that file modifications must be done by the engineer tool — your role is only to investigate code and answer questions. Do not attempt workarounds using bash commands (echo, cat, tee, sed, etc.) to write files.
+
 When exploring code:
 - Provide clear, concise explanations based on user request
 - Find and highlight the most relevant code snippets, if required

package/src/tools/edit.js

@@ -420,6 +420,15 @@ Parameters:
 
         // ─── Text-based edit mode ───
 
+        // Check if file has had too many consecutive text edits without a re-read
+        if (options.fileTracker) {
+          const staleCheck = options.fileTracker.checkTextEditStaleness(resolvedPath);
+          if (!staleCheck.ok) {
+            const displayPath = toRelativePath(resolvedPath, workspaceRoot);
+            return `Error editing ${displayPath}: ${staleCheck.message}\n\nExample: <extract><targets>${displayPath}</targets></extract>`;
+          }
+        }
+
         // Read the file
         const content = await fs.readFile(resolvedPath, 'utf-8');
 
@@ -470,7 +479,10 @@ Parameters:
 
         // Write the file back
         await fs.writeFile(resolvedPath, newContent, 'utf-8');
-        if (options.fileTracker) await options.fileTracker.trackFileAfterWrite(resolvedPath);
+        if (options.fileTracker) {
+          await options.fileTracker.trackFileAfterWrite(resolvedPath);
+          options.fileTracker.recordTextEdit(resolvedPath);
+        }
 
         const replacedCount = replace_all ? occurrences : 1;
 

package/src/tools/fileTracker.js

@@ -95,6 +95,10 @@ export class FileTracker {
     this._seenFiles = new Set();
     /** @type {Map<string, {contentHash: string, startLine: number, endLine: number, symbolName: string|null, source: string, timestamp: number}>} */
     this._contentRecords = new Map();
+    /** @type {Map<string, number>} Consecutive text edits since last read, per file */
+    this._textEditCounts = new Map();
+    /** @type {number} Max consecutive text edits before requiring a re-read */
+    this.maxConsecutiveTextEdits = 3;
   }
 
   /**
@@ -103,6 +107,7 @@ export class FileTracker {
    */
   markFileSeen(resolvedPath) {
     this._seenFiles.add(resolvedPath);
+    this._textEditCounts.set(resolvedPath, 0);
     if (this.debug) {
       console.error(`[FileTracker] Marked as seen: ${resolvedPath}`);
     }
@@ -264,10 +269,40 @@ export class FileTracker {
    * @param {string} resolvedPath - Absolute path to the file
    */
   async trackFileAfterWrite(resolvedPath) {
-    this.markFileSeen(resolvedPath);
+    this._seenFiles.add(resolvedPath);
     this.invalidateFileRecords(resolvedPath);
   }
 
+  /**
+   * Record a text-mode edit (old_string/new_string) to a file.
+   * Increments the consecutive edit counter.
+   * @param {string} resolvedPath - Absolute path to the file
+   */
+  recordTextEdit(resolvedPath) {
+    const count = (this._textEditCounts.get(resolvedPath) || 0) + 1;
+    this._textEditCounts.set(resolvedPath, count);
+    if (this.debug) {
+      console.error(`[FileTracker] Text edit #${count} for ${resolvedPath}`);
+    }
+  }
+
+  /**
+   * Check if a file has had too many consecutive text edits without a re-read.
+   * @param {string} resolvedPath - Absolute path to the file
+   * @returns {{ok: boolean, editCount?: number, message?: string}}
+   */
+  checkTextEditStaleness(resolvedPath) {
+    const count = this._textEditCounts.get(resolvedPath) || 0;
+    if (count >= this.maxConsecutiveTextEdits) {
+      return {
+        ok: false,
+        editCount: count,
+        message: `This file has been edited ${count} times without being re-read. Use 'extract' to re-read the current file content before making more edits, to ensure you are working with the actual state of the file.`
+      };
+    }
+    return { ok: true, editCount: count };
+  }
+
   /**
    * Update the stored hash for a symbol after a successful write.
    * Enables chained edits to the same symbol.
@@ -314,5 +349,6 @@ export class FileTracker {
   clear() {
     this._seenFiles.clear();
     this._contentRecords.clear();
+    this._textEditCounts.clear();
   }
 }