@probelabs/probe 0.6.0-rc257 → 0.6.0-rc259

package/build/agent/probeTool.js

@@ -256,6 +256,15 @@ export function createWrappedTools(baseTools) {
     );
   }
 
+  // Wrap multi_edit tool
+  if (baseTools.multiEditTool) {
+    wrappedTools.multiEditToolInstance = wrapToolWithEmitter(
+      baseTools.multiEditTool,
+      'multi_edit',
+      baseTools.multiEditTool.execute
+    );
+  }
+
   return wrappedTools;
 }
 

package/build/agent/shared/prompts.js

@@ -56,20 +56,52 @@ When reviewing code:
 
   'code-review-template': `You are going to perform code review according to provided user rules. Ensure to review only code provided in diff and latest commit, if provided. However you still need to fully understand how modified code works, and read dependencies if something is not clear.`,
 
-  'engineer': `You are senior engineer focused on software architecture and design.
-Before jumping on the task you first, in details analyse user request, and try to provide elegant and concise solution.
-If solution is clear, you can jump to implementation right away, if not, you can ask user a clarification question, by calling attempt_completion tool, with required details.
+  'engineer': `You are a senior engineer focused on software architecture and design.
+Before jumping on the task you first analyse the user request in detail, and try to provide an elegant and concise solution.
+If the solution is clear, you can jump to implementation right away. If not, ask the user a clarification question by calling the attempt_completion tool with the required details.
 
-Before jumping to implementation:
+# Tone and Style
+- Be concise and direct. Explain your approach briefly before implementing, then let the code speak for itself.
+- Do not add unnecessary preamble or postamble. Skip "Here is what I will do" or "Here is a summary of changes" unless the user asks.
+- 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
-- Focus on backward compatibility.
+- Focus on backward compatibility
 - Consider scalability, maintainability, and extensibility in your analysis
 
-During the implementation:
-- Avoid implementing special cases
-- Do not forget to add the tests`,
+# Following Conventions
+- NEVER assume a library or dependency is available. Before using any library, check the project's dependency file (package.json, Cargo.toml, go.mod, requirements.txt, etc.) to confirm it exists in the project.
+- Before writing new code, look at neighboring files and existing implementations to understand the project's code style, naming conventions, and patterns. Mimic them.
+- Check imports and existing utilities before creating new helpers — the project may already have what you need.
+
+# Task Planning
+- If the task tool is available, use it to break complex work into milestones before starting implementation.
+- Stay flexible — if your understanding changes mid-task, add, remove, or reorganize tasks as needed. The plan should serve you, not constrain you.
+
+# 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.
+- Avoid implementing special cases when a general approach works
+- Never expose secrets, API keys, or credentials in generated code. Never log sensitive information.
+- Do not surprise the user with unrequested changes. Do what was asked, including reasonable follow-up actions, but do not refactor surrounding code or add features that were not requested.
+- After every significant change, verify the project still builds and passes linting. Do not wait until the end to discover breakage.
+
+# After Implementation
+- Always run the project's tests before considering the task complete. If tests fail, fix them.
+- Run lint and typecheck commands if known for the project.
+- If a build, lint, or test fails, fix the issue before finishing.
+- When the task is done, respond to the user with a concise summary of what was implemented, what files were changed, and any relevant details. Include links (e.g. pull request URL) so the user has everything they need.
+
+# GitHub Integration
+- Use the \`gh\` CLI for all GitHub operations: issues, pull requests, checks, releases.
+- To create a pull request: commit your changes, push the branch, then use \`gh pr create --title "..." --body "..."\`.
+- To view issues or PRs: \`gh issue view <number>\`, \`gh pr view <number>\`.
+- If given a GitHub URL, use \`gh\` to fetch the relevant information rather than guessing.
+- Always return the pull request URL to the user after creating one.
+- When checking GitHub Actions, only read logs of failed jobs — do not waste time on successful ones. Use \`gh run view <run-id> --log-failed\` to fetch only the relevant output.`,
 
   'support': `You are ProbeChat Support, a specialized AI assistant focused on helping developers troubleshoot issues and solve problems. Your primary function is to help users diagnose errors, understand unexpected behaviors, and find solutions using the provided code analysis tools.
 

package/build/agent/tools.js

@@ -10,6 +10,7 @@ import {
   bashTool,
   editTool,
   createTool,
+  multiEditTool,
   DEFAULT_SYSTEM_MESSAGE,
   attemptCompletionSchema,
   attemptCompletionToolDefinition,
@@ -23,6 +24,7 @@ import {
   bashSchema,
   editSchema,
   createSchema,
+  multiEditSchema,
   searchToolDefinition,
   queryToolDefinition,
   extractToolDefinition,
@@ -33,6 +35,7 @@ import {
   bashToolDefinition,
   editToolDefinition,
   createToolDefinition,
+  multiEditToolDefinition,
   googleSearchToolDefinition,
   urlContextToolDefinition,
   parseXmlToolCall
@@ -87,6 +90,9 @@ export function createTools(configOptions) {
   if (configOptions.allowEdit && isToolAllowed('create')) {
     tools.createTool = createTool(configOptions);
   }
+  if (configOptions.allowEdit && isToolAllowed('multi_edit')) {
+    tools.multiEditTool = multiEditTool(configOptions);
+  }
   return tools;
 }
 
@@ -114,6 +120,7 @@ export {
   bashSchema,
   editSchema,
   createSchema,
+  multiEditSchema,
   attemptCompletionSchema,
   searchToolDefinition,
   queryToolDefinition,
@@ -125,6 +132,7 @@ export {
   bashToolDefinition,
   editToolDefinition,
   createToolDefinition,
+  multiEditToolDefinition,
   attemptCompletionToolDefinition,
   googleSearchToolDefinition,
   urlContextToolDefinition,

package/build/index.js

@@ -44,13 +44,15 @@ import {
 import {
 	editSchema,
 	createSchema,
+	multiEditSchema,
 	editToolDefinition,
-	createToolDefinition
+	createToolDefinition,
+	multiEditToolDefinition
 } from './tools/edit.js';
 import { searchTool, queryTool, extractTool, delegateTool, analyzeAllTool } from './tools/vercel.js';
 import { createExecutePlanTool, getExecutePlanToolDefinition, createCleanupExecutePlanTool, getCleanupExecutePlanToolDefinition } from './tools/executePlan.js';
 import { bashTool } from './tools/bash.js';
-import { editTool, createTool } from './tools/edit.js';
+import { editTool, createTool, multiEditTool } from './tools/edit.js';
 import { FileTracker } from './tools/fileTracker.js';
 import { ProbeAgent } from './agent/ProbeAgent.js';
 import { SimpleTelemetry, SimpleAppTracer, initializeSimpleTelemetryFromOptions } from './agent/simpleTelemetry.js';
@@ -99,6 +101,7 @@ export {
 	bashTool,
 	editTool,
 	createTool,
+	multiEditTool,
 	FileTracker,
 	// Export tool instances
 	listFilesToolInstance,
@@ -115,6 +118,7 @@ export {
 	bashSchema,
 	editSchema,
 	createSchema,
+	multiEditSchema,
 	// Export tool definitions
 	searchToolDefinition,
 	queryToolDefinition,
@@ -127,6 +131,7 @@ export {
 	bashToolDefinition,
 	editToolDefinition,
 	createToolDefinition,
+	multiEditToolDefinition,
 	googleSearchToolDefinition,
 	urlContextToolDefinition,
 	// Export parser function

package/build/tools/common.js

@@ -5,7 +5,7 @@
 
 import { z } from 'zod';
 import { resolve, isAbsolute } from 'path';
-import { editSchema, createSchema } from './edit.js';
+import { editSchema, createSchema, multiEditSchema } from './edit.js';
 import { taskSchema } from '../agent/tasks/taskTool.js';
 
 // Common schemas for tool parameters (used for internal execution after XML parsing)
@@ -492,7 +492,8 @@ function getValidParamsForTool(toolName) {
 		task: taskSchema,
 		attempt_completion: attemptCompletionSchema,
 		edit: editSchema,
-		create: createSchema
+		create: createSchema,
+		multi_edit: multiEditSchema
 	};
 
 	const schema = schemaMap[toolName];
@@ -538,6 +539,15 @@ export function unescapeXmlEntities(str) {
 		.replace(/&/g, '&');
 }
 
+// Parameters that contain arbitrary code/file content — use lastIndexOf for closing tag
+// to handle cases where the content itself contains the closing tag string.
+const RAW_CONTENT_PARAMS = new Set(['content', 'new_string', 'old_string']);
+
+// Tools whose content can include their own closing tag string (e.g., file content
+// containing </create> or </edit>). Use lastIndexOf for outer tag boundary, same
+// strategy already used for attempt_completion.
+const LAST_INDEX_TOOLS = new Set(['attempt_completion', 'create', 'edit']);
+
 // Simple XML parser helper - safer string-based approach
 export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 	// Find the tool that appears EARLIEST in the string
@@ -564,13 +574,13 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 	const closeTag = `</${toolName}>`;
 	const openIndex = earliestOpenIndex;
 
-	// For attempt_completion, use lastIndexOf to find the LAST occurrence of closing tag
-	// This prevents issues where the content contains the closing tag string (e.g., in regex patterns)
-	// For other tools, use indexOf from the opening tag position
+	// For tools that contain arbitrary content (file content, code), use lastIndexOf
+	// to find the LAST occurrence of the closing tag. This prevents issues where the
+	// content itself contains the closing tag string (e.g., file content with </create>).
+	// For other tools, use indexOf from the opening tag position.
 	let closeIndex;
-	if (toolName === 'attempt_completion') {
+	if (LAST_INDEX_TOOLS.has(toolName)) {
 		// Find the last occurrence of the closing tag in the entire string
-		// This assumes attempt_completion doesn't have nested tags of the same name
 		closeIndex = xmlString.lastIndexOf(closeTag);
 		// Make sure the closing tag is after the opening tag
 		if (closeIndex !== -1 && closeIndex <= openIndex + openTag.length) {
@@ -610,7 +620,19 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 			continue; // Parameter not found
 		}
 
-		let paramCloseIndex = innerContent.indexOf(paramCloseTag, paramOpenIndex + paramOpenTag.length);
+		// For raw content params (file content, code), use lastIndexOf to find the
+		// LAST closing tag — the content itself may contain the closing tag string.
+		// For other params (file_path, overwrite, etc.), use indexOf (first match).
+		let paramCloseIndex;
+		if (RAW_CONTENT_PARAMS.has(paramName)) {
+			paramCloseIndex = innerContent.lastIndexOf(paramCloseTag);
+			// Ensure it's after the opening tag
+			if (paramCloseIndex !== -1 && paramCloseIndex <= paramOpenIndex + paramOpenTag.length) {
+				paramCloseIndex = -1;
+			}
+		} else {
+			paramCloseIndex = innerContent.indexOf(paramCloseTag, paramOpenIndex + paramOpenTag.length);
+		}
 
 		// Handle unclosed parameter tags - use content until next tag or end of content
 		if (paramCloseIndex === -1) {
@@ -626,23 +648,34 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 			paramCloseIndex = nextTagIndex;
 		}
 
-		let paramValue = unescapeXmlEntities(innerContent.substring(
+		const rawValue = innerContent.substring(
 			paramOpenIndex + paramOpenTag.length,
 			paramCloseIndex
-		).trim());
-
-		// Basic type inference (can be improved)
-		if (paramValue.toLowerCase() === 'true') {
-			paramValue = true;
-		} else if (paramValue.toLowerCase() === 'false') {
-			paramValue = false;
-		} else if (!isNaN(paramValue) && paramValue.trim() !== '') {
-			// Check if it's potentially a number (handle integers and floats)
-			const num = Number(paramValue);
-			if (Number.isFinite(num)) { // Use Number.isFinite to avoid Infinity/NaN
-				paramValue = num;
+		);
+
+		// For raw content params, preserve whitespace (only strip XML formatting newlines).
+		// For other params, trim all whitespace.
+		let paramValue;
+		if (RAW_CONTENT_PARAMS.has(paramName)) {
+			paramValue = unescapeXmlEntities(rawValue.replace(/^\n/, '').replace(/\n$/, ''));
+		} else {
+			paramValue = unescapeXmlEntities(rawValue.trim());
+		}
+
+		// Type coercion for non-content params only (content/new_string/old_string must stay strings)
+		if (!RAW_CONTENT_PARAMS.has(paramName)) {
+			if (paramValue.toLowerCase() === 'true') {
+				paramValue = true;
+			} else if (paramValue.toLowerCase() === 'false') {
+				paramValue = false;
+			} else if (!isNaN(paramValue) && paramValue.trim() !== '') {
+				// Check if it's potentially a number (handle integers and floats)
+				const num = Number(paramValue);
+				if (Number.isFinite(num)) { // Use Number.isFinite to avoid Infinity/NaN
+					paramValue = num;
+				}
+				// Keep as string if not a valid finite number
 			}
-			// Keep as string if not a valid finite number
 		}
 
 		params[paramName] = paramValue;
@@ -707,7 +740,7 @@ export function detectUnrecognizedToolCall(xmlString, validTools) {
 	const knownToolNames = [
 		'search', 'query', 'extract', 'listFiles', 'searchFiles',
 		'listSkills', 'useSkill', 'readImage', 'edit',
-		'create', 'delegate', 'bash', 'task', 'attempt_completion',
+		'create', 'multi_edit', 'delegate', 'bash', 'task', 'attempt_completion',
 		'attempt_complete', 'read_file', 'write_file', 'run_command',
 		'grep', 'find', 'cat', 'list_directory'
 	];

package/build/tools/edit.js

@@ -363,7 +363,7 @@ Parameters:
       required: ['file_path', 'new_string']
     },
 
-    execute: async ({ file_path, old_string, new_string, replace_all = false, symbol, position, start_line, end_line }) => {
+    execute: async ({ file_path, old_string, new_string, replace_all = false, symbol, position, start_line, end_line, workingDirectory }) => {
       try {
         // Validate input parameters
         if (!file_path || typeof file_path !== 'string' || file_path.trim() === '') {
@@ -373,8 +373,9 @@ Parameters:
           return `Error editing file: Invalid new_string - must be a string. Provide the replacement content as a string value (empty string "" is valid for deletions).`;
         }
 
-        // Resolve the file path
-        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(cwd || process.cwd(), file_path);
+        // Resolve the file path (workingDirectory from runtime takes priority over cwd from tool creation)
+        const effectiveCwd = workingDirectory || cwd || process.cwd();
+        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(effectiveCwd, file_path);
 
         if (debug) {
           console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
@@ -530,7 +531,7 @@ Important:
       required: ['file_path', 'content']
     },
 
-    execute: async ({ file_path, content, overwrite = false }) => {
+    execute: async ({ file_path, content, overwrite = false, workingDirectory }) => {
       try {
         // Validate input parameters
         if (!file_path || typeof file_path !== 'string' || file_path.trim() === '') {
@@ -540,8 +541,9 @@ Important:
           return `Error creating file: Invalid content - must be a string. Provide the file content as a string value (empty string "" is valid for an empty file).`;
         }
 
-        // Resolve the file path
-        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(cwd || process.cwd(), file_path);
+        // Resolve the file path (workingDirectory from runtime takes priority over cwd from tool creation)
+        const effectiveCwd = workingDirectory || cwd || process.cwd();
+        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(effectiveCwd, file_path);
 
         if (debug) {
           console.error(`[Create] Attempting to create file: ${resolvedPath}`);
@@ -587,6 +589,86 @@ Important:
   });
 };
 
+/**
+ * Multi-edit tool — apply multiple edit operations in a single call.
+ * Reuses the edit tool internally; edits are applied sequentially.
+ *
+ * @param {Object} [options] - Same configuration as editTool
+ * @returns {Object} Configured multi_edit tool
+ */
+export const multiEditTool = (options = {}) => {
+  const editInstance = editTool(options);
+
+  return tool({
+    name: 'multi_edit',
+    description: 'Apply multiple file edits in a single tool call. Accepts a JSON array of edit operations.',
+
+    inputSchema: {
+      type: 'object',
+      properties: {
+        edits: {
+          type: 'string',
+          description: 'JSON array of edit operations. Each object supports: file_path, old_string, new_string, replace_all, symbol, position, start_line, end_line.'
+        }
+      },
+      required: ['edits']
+    },
+
+    execute: async ({ edits: rawEdits }) => {
+      let edits;
+      if (typeof rawEdits === 'string') {
+        try {
+          edits = JSON.parse(rawEdits);
+        } catch (e) {
+          return `Error: Invalid JSON in edits parameter - ${e.message}. Provide a raw JSON array between <edits> tags.`;
+        }
+      } else if (Array.isArray(rawEdits)) {
+        edits = rawEdits;
+      } else {
+        return 'Error: edits must be a JSON array of edit operations.';
+      }
+
+      if (!Array.isArray(edits) || edits.length === 0) {
+        return 'Error: edits must be a non-empty JSON array.';
+      }
+      if (edits.length > 50) {
+        return `Error: Too many edits (${edits.length}). Maximum 50 per batch.`;
+      }
+
+      const results = [];
+      let successCount = 0;
+      let failCount = 0;
+
+      for (let i = 0; i < edits.length; i++) {
+        const editOp = edits[i];
+        if (!editOp || typeof editOp !== 'object' || Array.isArray(editOp)) {
+          results.push(`[${i + 1}] FAIL: Invalid edit operation - must be an object`);
+          failCount++;
+          continue;
+        }
+        try {
+          const result = await editInstance.execute(editOp);
+          const isError = typeof result === 'string' && result.startsWith('Error');
+          if (isError) {
+            results.push(`[${i + 1}] FAIL: ${result}`);
+            failCount++;
+          } else {
+            results.push(`[${i + 1}] OK: ${result}`);
+            successCount++;
+          }
+        } catch (error) {
+          results.push(`[${i + 1}] FAIL: ${error.message}`);
+          failCount++;
+        }
+      }
+
+      const summary = `Multi-edit: ${successCount}/${edits.length} succeeded` +
+        (failCount > 0 ? `, ${failCount} failed` : '');
+      return summary + '\n\n' + results.join('\n');
+    }
+  });
+};
+
 // Export schemas for tool definitions
 export const editSchema = {
   type: 'object',
@@ -647,9 +729,21 @@ export const createSchema = {
   required: ['file_path', 'content']
 };
 
+export const multiEditSchema = {
+  type: 'object',
+  properties: {
+    edits: {
+      type: 'string',
+      description: 'JSON array of edit operations'
+    }
+  },
+  required: ['edits']
+};
+
 // Tool descriptions for XML definitions
 export const editDescription = 'Edit files using text replacement, AST-aware symbol operations, or line-targeted editing. Supports fuzzy matching for text edits and optional hash-based integrity verification for line edits.';
 export const createDescription = 'Create new files with specified content. Will create parent directories if needed.';
+export const multiEditDescription = 'Apply multiple file edits in a single tool call. Accepts a JSON array of edit operations, each supporting the same modes as the edit tool.';
 
 // XML tool definitions
 export const editToolDefinition = `
@@ -808,3 +902,42 @@ Examples:
 This is a new project.</content>
 <overwrite>true</overwrite>
 </create>`;
+
+export const multiEditToolDefinition = `
+## multi_edit
+Description: ${multiEditDescription}
+
+Apply multiple edits in one call. Each operation in the array uses the same parameters as the edit tool:
+- file_path, old_string, new_string (text mode)
+- file_path, symbol, new_string (symbol replace)
+- file_path, symbol, new_string, position (symbol insert)
+- file_path, start_line, new_string (line-targeted)
+
+Edits are applied sequentially. Failures do not stop remaining edits. Maximum 50 edits per call.
+
+Parameters:
+- edits: (required) JSON array of edit objects. Place raw JSON between tags.
+
+When to use multi_edit vs edit:
+- Use edit for a single change to one file
+- Use multi_edit when making 2+ related changes across files (e.g., rename a function and update all call sites)
+- Use multi_edit for coordinated multi-file refactoring where order matters
+
+Examples:
+
+Multiple text replacements across files:
+<multi_edit>
+<edits>[
+  {"file_path": "src/main.js", "old_string": "return false;", "new_string": "return true;"},
+  {"file_path": "src/config.js", "old_string": "debug: false", "new_string": "debug: true"}
+]</edits>
+</multi_edit>
+
+Mixed edit modes in one batch:
+<multi_edit>
+<edits>[
+  {"file_path": "src/utils.js", "symbol": "oldHelper", "new_string": "function newHelper() { return 42; }"},
+  {"file_path": "src/main.js", "old_string": "oldHelper()", "new_string": "newHelper()", "replace_all": true},
+  {"file_path": "src/index.js", "start_line": "10", "end_line": "12", "new_string": "export { newHelper };"}
+]</edits>
+</multi_edit>`;

package/build/tools/index.js

@@ -6,7 +6,7 @@
 // Export Vercel AI SDK tool generators
 export { searchTool, queryTool, extractTool, delegateTool } from './vercel.js';
 export { bashTool } from './bash.js';
-export { editTool, createTool } from './edit.js';
+export { editTool, createTool, multiEditTool } from './edit.js';
 
 // Export LangChain tools
 export { createSearchTool, createQueryTool, createExtractTool } from './langchain.js';
@@ -39,10 +39,13 @@ export {
 export {
 	editSchema,
 	createSchema,
+	multiEditSchema,
 	editDescription,
 	createDescription,
+	multiEditDescription,
 	editToolDefinition,
-	createToolDefinition
+	createToolDefinition,
+	multiEditToolDefinition
 } from './edit.js';
 
 // Export system message