@probelabs/probe 0.6.0-rc159 → 0.6.0-rc162

package/build/agent/probeTool.js

@@ -204,12 +204,30 @@ export function createWrappedTools(baseTools) {
   // Wrap bash tool
   if (baseTools.bashTool) {
     wrappedTools.bashToolInstance = wrapToolWithEmitter(
-      baseTools.bashTool, 
-      'bash', 
+      baseTools.bashTool,
+      'bash',
       baseTools.bashTool.execute
     );
   }
 
+  // Wrap edit tool
+  if (baseTools.editTool) {
+    wrappedTools.editToolInstance = wrapToolWithEmitter(
+      baseTools.editTool,
+      'edit',
+      baseTools.editTool.execute
+    );
+  }
+
+  // Wrap create tool
+  if (baseTools.createTool) {
+    wrappedTools.createToolInstance = wrapToolWithEmitter(
+      baseTools.createTool,
+      'create',
+      baseTools.createTool.execute
+    );
+  }
+
   return wrappedTools;
 }
 

package/build/agent/schemaUtils.js

@@ -100,6 +100,13 @@ export function decodeHtmlEntities(text) {
 /**
  * Clean AI response by extracting JSON content when response contains JSON
  * Only processes responses that contain JSON structures { or [
+ *
+ * NOTE: This function handles both JSON extraction AND content stripping.
+ * Future improvement: Consider splitting into separate functions for better separation of concerns:
+ * - extractJsonContent() - Find and extract JSON from response
+ * - stripNonJsonContent() - Remove explanatory text while preserving validation-relevant content
+ * This would allow validation to run on full responses before content is discarded.
+ *
  * @param {string} response - Raw AI response
  * @returns {string} - Cleaned response with JSON boundaries extracted if applicable
  */

package/build/agent/tools.js

@@ -5,6 +5,8 @@ import {
   extractTool,
   delegateTool,
   bashTool,
+  editTool,
+  createTool,
   DEFAULT_SYSTEM_MESSAGE,
   attemptCompletionSchema,
   attemptCompletionToolDefinition,
@@ -13,11 +15,15 @@ import {
   extractSchema,
   delegateSchema,
   bashSchema,
+  editSchema,
+  createSchema,
   searchToolDefinition,
   queryToolDefinition,
   extractToolDefinition,
   delegateToolDefinition,
   bashToolDefinition,
+  editToolDefinition,
+  createToolDefinition,
   parseXmlToolCall
 } from '../index.js';
 import { randomUUID } from 'crypto';
@@ -37,6 +43,12 @@ export function createTools(configOptions) {
     tools.bashTool = bashTool(configOptions);
   }
 
+  // Add edit and create tools if enabled
+  if (configOptions.allowEdit) {
+    tools.editTool = editTool(configOptions);
+    tools.createTool = createTool(configOptions);
+  }
+
   return tools;
 }
 
@@ -48,12 +60,16 @@ export {
   extractSchema,
   delegateSchema,
   bashSchema,
+  editSchema,
+  createSchema,
   attemptCompletionSchema,
   searchToolDefinition,
   queryToolDefinition,
   extractToolDefinition,
   delegateToolDefinition,
   bashToolDefinition,
+  editToolDefinition,
+  createToolDefinition,
   attemptCompletionToolDefinition,
   parseXmlToolCall
 };

package/build/agent/xmlParsingUtils.js

@@ -59,10 +59,30 @@ export function extractThinkingContent(xmlString) {
 export function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
   // Check for <attempt_completion> with content (with or without closing tag)
   // This handles: "<attempt_completion>content" or "<attempt_completion>content</attempt_completion>"
-  const attemptCompletionMatch = cleanedXmlString.match(/<attempt_completion>([\s\S]*?)(?:<\/attempt_completion>|$)/);
-  if (attemptCompletionMatch) {
-    const content = attemptCompletionMatch[1].trim();
-    const hasClosingTag = cleanedXmlString.includes('</attempt_completion>');
+
+  // IMPORTANT: Use greedy match ([\s\S]*) instead of non-greedy ([\s\S]*?) to handle cases
+  // where the content contains the string "</attempt_completion>" (e.g., in regex patterns or code examples).
+  // We want to find the LAST occurrence of </attempt_completion>, not the first one.
+  const openTagIndex = cleanedXmlString.indexOf('<attempt_completion>');
+  if (openTagIndex !== -1) {
+    const afterOpenTag = cleanedXmlString.substring(openTagIndex + '<attempt_completion>'.length);
+    const closeTagIndex = cleanedXmlString.lastIndexOf('</attempt_completion>');
+
+    let content;
+    let hasClosingTag = false;
+
+    if (closeTagIndex !== -1 && closeTagIndex >= openTagIndex + '<attempt_completion>'.length) {
+      // Found a closing tag at or after the opening tag - extract content between them
+      content = cleanedXmlString.substring(
+        openTagIndex + '<attempt_completion>'.length,
+        closeTagIndex
+      ).trim();
+      hasClosingTag = true;
+    } else {
+      // No closing tag - use content from opening tag to end of string
+      content = afterOpenTag.trim();
+      hasClosingTag = false;
+    }
 
     if (content) {
       // If there's content after the tag, use it as the result

package/build/index.js

@@ -35,8 +35,15 @@ import {
 	bashToolDefinition,
 	parseXmlToolCall
 } from './tools/common.js';
+import {
+	editSchema,
+	createSchema,
+	editToolDefinition,
+	createToolDefinition
+} from './tools/edit.js';
 import { searchTool, queryTool, extractTool, delegateTool } from './tools/vercel.js';
 import { bashTool } from './tools/bash.js';
+import { editTool, createTool } from './tools/edit.js';
 import { ProbeAgent } from './agent/ProbeAgent.js';
 import { SimpleTelemetry, SimpleAppTracer, initializeSimpleTelemetryFromOptions } from './agent/simpleTelemetry.js';
 import { listFilesToolInstance, searchFilesToolInstance } from './agent/probeTool.js';
@@ -72,6 +79,8 @@ export {
 	extractTool,
 	delegateTool,
 	bashTool,
+	editTool,
+	createTool,
 	// Export tool instances
 	listFilesToolInstance,
 	searchFilesToolInstance,
@@ -82,6 +91,8 @@ export {
 	delegateSchema,
 	attemptCompletionSchema,
 	bashSchema,
+	editSchema,
+	createSchema,
 	// Export tool definitions
 	searchToolDefinition,
 	queryToolDefinition,
@@ -89,6 +100,8 @@ export {
 	delegateToolDefinition,
 	attemptCompletionToolDefinition,
 	bashToolDefinition,
+	editToolDefinition,
+	createToolDefinition,
 	// Export parser function
 	parseXmlToolCall
 };

package/build/tools/common.js

@@ -15,12 +15,13 @@ export const querySchema = z.object({
 	pattern: z.string().describe('AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc.'),
 	path: z.string().optional().default('.').describe('Path to search in'),
 	language: z.string().optional().default('rust').describe('Programming language to use for parsing'),
-	allow_tests: z.boolean().optional().default(false).describe('Allow test files in search results')
+	allow_tests: z.boolean().optional().default(true).describe('Allow test files in search results')
 });
 
 export const extractSchema = z.object({
 	targets: z.string().optional().describe('File paths or symbols to extract from. Formats: "file.js" (whole file), "file.js:42" (line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (symbol). Multiple targets separated by spaces.'),
-	input_content: z.string().optional().describe('Text content to extract file paths from (alternative to targets)')
+	input_content: z.string().optional().describe('Text content to extract file paths from (alternative to targets)'),
+	allow_tests: z.boolean().optional().default(true).describe('Include test files in extraction results')
 });
 
 export const delegateSchema = z.object({
@@ -163,7 +164,7 @@ Parameters:
 - pattern: (required) AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc.
 - path: (optional, default: '.') Path to search in.
 - language: (optional, default: 'rust') Programming language to use for parsing.
-- allow_tests: (optional, default: false) Allow test files in search results (true/false).
+- allow_tests: (optional, default: true) Allow test files in search results (true/false).
 Usage Example:
 
 <examples>
@@ -189,6 +190,7 @@ Full file extraction should be the LAST RESORT! Always prefer search.
 Parameters:
 - targets: (required) File paths or symbols to extract from. Formats: "file.js" (whole file), "file.js:42" (code block at line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (specific symbol). Multiple targets separated by spaces.
 - input_content: (optional) Text content to extract file paths from (alternative to targets for processing diffs/logs).
+- allow_tests: (optional, default: true) Include test files in extraction results.
 
 Usage Example:
 
@@ -382,7 +384,22 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 			continue; // Tool not found, try next tool
 		}
 
-		let closeIndex = xmlString.indexOf(closeTag, openIndex + openTag.length);
+		// 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
+		let closeIndex;
+		if (toolName === 'attempt_completion') {
+			// 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) {
+				closeIndex = -1; // Invalid, treat as no closing tag
+			}
+		} else {
+			closeIndex = xmlString.indexOf(closeTag, openIndex + openTag.length);
+		}
+
 		let hasClosingTag = closeIndex !== -1;
 
 		// If no closing tag found, use content until end of string

package/build/tools/edit.js

@@ -0,0 +1,409 @@
+/**
+ * Edit and Create tools for file modification
+ * @module tools/edit
+ */
+
+import { tool } from 'ai';
+import { promises as fs } from 'fs';
+import { dirname, resolve, isAbsolute, sep } from 'path';
+import { existsSync } from 'fs';
+
+/**
+ * Validates that a path is within allowed directories
+ * @param {string} filePath - Path to validate
+ * @param {string[]} allowedFolders - List of allowed folders
+ * @returns {boolean} True if path is allowed
+ */
+function isPathAllowed(filePath, allowedFolders) {
+  if (!allowedFolders || allowedFolders.length === 0) {
+    // If no restrictions, allow current directory and below
+    const resolvedPath = resolve(filePath);
+    const cwd = resolve(process.cwd());
+    // Ensure proper path separator to prevent path traversal
+    return resolvedPath === cwd || resolvedPath.startsWith(cwd + sep);
+  }
+
+  const resolvedPath = resolve(filePath);
+  return allowedFolders.some(folder => {
+    const allowedPath = resolve(folder);
+    // Ensure proper path separator to prevent path traversal
+    return resolvedPath === allowedPath || resolvedPath.startsWith(allowedPath + sep);
+  });
+}
+
+/**
+ * Common configuration for file tools
+ * @param {Object} options - Configuration options
+ * @returns {Object} Parsed configuration
+ */
+function parseFileToolOptions(options = {}) {
+  return {
+    debug: options.debug || false,
+    allowedFolders: options.allowedFolders || [],
+    defaultPath: options.defaultPath
+  };
+}
+
+/**
+ * Edit tool generator - Claude Code style string replacement
+ *
+ * @param {Object} [options] - Configuration options
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @param {string[]} [options.allowedFolders] - Allowed directories for file operations
+ * @param {string} [options.defaultPath] - Default working directory
+ * @returns {Object} Configured edit tool
+ */
+export const editTool = (options = {}) => {
+  const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+
+  return tool({
+    name: 'edit',
+    description: `Edit files using exact string replacement (Claude Code style).
+
+This tool performs exact string replacements in files. It requires the old_string to match exactly what's in the file, including all whitespace and indentation.
+
+Parameters:
+- file_path: Path to the file to edit (absolute or relative)
+- old_string: Exact text to find and replace (must be unique in the file unless replace_all is true)
+- new_string: Text to replace with
+- replace_all: (optional) Replace all occurrences instead of requiring uniqueness
+
+Important:
+- The old_string must match EXACTLY including whitespace
+- If old_string appears multiple times and replace_all is false, the edit will fail
+- Use larger context around the string to ensure uniqueness when needed`,
+
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_path: {
+          type: 'string',
+          description: 'Path to the file to edit'
+        },
+        old_string: {
+          type: 'string',
+          description: 'Exact text to find and replace'
+        },
+        new_string: {
+          type: 'string',
+          description: 'Text to replace with'
+        },
+        replace_all: {
+          type: 'boolean',
+          description: 'Replace all occurrences (default: false)',
+          default: false
+        }
+      },
+      required: ['file_path', 'old_string', 'new_string']
+    },
+
+    execute: async ({ file_path, old_string, new_string, replace_all = false }) => {
+      try {
+        // Validate input parameters
+        if (!file_path || typeof file_path !== 'string' || file_path.trim() === '') {
+          return `Error editing file: Invalid file_path - must be a non-empty string`;
+        }
+        if (old_string === undefined || old_string === null || typeof old_string !== 'string') {
+          return `Error editing file: Invalid old_string - must be a string`;
+        }
+        if (new_string === undefined || new_string === null || typeof new_string !== 'string') {
+          return `Error editing file: Invalid new_string - must be a string`;
+        }
+
+        // Resolve the file path
+        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(defaultPath || process.cwd(), file_path);
+
+        if (debug) {
+          console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
+        }
+
+        // Check if path is allowed
+        if (!isPathAllowed(resolvedPath, allowedFolders)) {
+          return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
+        }
+
+        // Check if file exists
+        if (!existsSync(resolvedPath)) {
+          return `Error editing file: File not found - ${file_path}`;
+        }
+
+        // Read the file
+        const content = await fs.readFile(resolvedPath, 'utf-8');
+
+        // Check if old_string exists in the file
+        if (!content.includes(old_string)) {
+          return `Error editing file: String not found - the specified old_string was not found in ${file_path}`;
+        }
+
+        // Count occurrences
+        const occurrences = content.split(old_string).length - 1;
+
+        // Check uniqueness if not replacing all
+        if (!replace_all && occurrences > 1) {
+          return `Error editing file: Multiple occurrences found - the old_string appears ${occurrences} times. Use replace_all: true to replace all occurrences, or provide more context to make the string unique.`;
+        }
+
+        // Perform the replacement
+        let newContent;
+        if (replace_all) {
+          newContent = content.replaceAll(old_string, new_string);
+        } else {
+          newContent = content.replace(old_string, new_string);
+        }
+
+        // Check if replacement was made
+        if (newContent === content) {
+          return `Error editing file: No changes made - old_string and new_string might be the same`;
+        }
+
+        // Write the file back
+        await fs.writeFile(resolvedPath, newContent, 'utf-8');
+
+        const replacedCount = replace_all ? occurrences : 1;
+
+        if (debug) {
+          console.error(`[Edit] Successfully edited ${resolvedPath}, replaced ${replacedCount} occurrence(s)`);
+        }
+
+        // Return success message as a string (matching other tools pattern)
+        return `Successfully edited ${file_path} (${replacedCount} replacement${replacedCount !== 1 ? 's' : ''})`;
+
+      } catch (error) {
+        console.error('[Edit] Error:', error);
+        return `Error editing file: ${error.message}`;
+      }
+    }
+  });
+};
+
+/**
+ * Create tool generator - Create new files
+ *
+ * @param {Object} [options] - Configuration options
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @param {string[]} [options.allowedFolders] - Allowed directories for file operations
+ * @param {string} [options.defaultPath] - Default working directory
+ * @returns {Object} Configured create tool
+ */
+export const createTool = (options = {}) => {
+  const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+
+  return tool({
+    name: 'create',
+    description: `Create new files with specified content.
+
+This tool creates new files in the filesystem. It will create parent directories if they don't exist.
+
+Parameters:
+- file_path: Path where the file should be created (absolute or relative)
+- content: Content to write to the file
+- overwrite: (optional) Whether to overwrite if file exists (default: false)
+
+Important:
+- By default, will fail if the file already exists
+- Set overwrite: true to replace existing files
+- Parent directories will be created automatically if needed`,
+
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_path: {
+          type: 'string',
+          description: 'Path where the file should be created'
+        },
+        content: {
+          type: 'string',
+          description: 'Content to write to the file'
+        },
+        overwrite: {
+          type: 'boolean',
+          description: 'Overwrite if file exists (default: false)',
+          default: false
+        }
+      },
+      required: ['file_path', 'content']
+    },
+
+    execute: async ({ file_path, content, overwrite = false }) => {
+      try {
+        // Validate input parameters
+        if (!file_path || typeof file_path !== 'string' || file_path.trim() === '') {
+          return `Error creating file: Invalid file_path - must be a non-empty string`;
+        }
+        if (content === undefined || content === null || typeof content !== 'string') {
+          return `Error creating file: Invalid content - must be a string`;
+        }
+
+        // Resolve the file path
+        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(defaultPath || process.cwd(), file_path);
+
+        if (debug) {
+          console.error(`[Create] Attempting to create file: ${resolvedPath}`);
+        }
+
+        // Check if path is allowed
+        if (!isPathAllowed(resolvedPath, allowedFolders)) {
+          return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
+        }
+
+        // Check if file exists
+        if (existsSync(resolvedPath) && !overwrite) {
+          return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
+        }
+
+        // Ensure parent directory exists
+        const dir = dirname(resolvedPath);
+        await fs.mkdir(dir, { recursive: true });
+
+        // Write the file
+        await fs.writeFile(resolvedPath, content, 'utf-8');
+
+        const action = existsSync(resolvedPath) && overwrite ? 'overwrote' : 'created';
+        const bytes = Buffer.byteLength(content, 'utf-8');
+
+        if (debug) {
+          console.error(`[Create] Successfully ${action} ${resolvedPath}`);
+        }
+
+        // Return success message as a string (matching other tools pattern)
+        return `Successfully ${action} ${file_path} (${bytes} bytes)`;
+
+      } catch (error) {
+        console.error('[Create] Error:', error);
+        return `Error creating file: ${error.message}`;
+      }
+    }
+  });
+};
+
+// Export schemas for tool definitions
+export const editSchema = {
+  type: 'object',
+  properties: {
+    file_path: {
+      type: 'string',
+      description: 'Path to the file to edit'
+    },
+    old_string: {
+      type: 'string',
+      description: 'Exact text to find and replace'
+    },
+    new_string: {
+      type: 'string',
+      description: 'Text to replace with'
+    },
+    replace_all: {
+      type: 'boolean',
+      description: 'Replace all occurrences (default: false)'
+    }
+  },
+  required: ['file_path', 'old_string', 'new_string']
+};
+
+export const createSchema = {
+  type: 'object',
+  properties: {
+    file_path: {
+      type: 'string',
+      description: 'Path where the file should be created'
+    },
+    content: {
+      type: 'string',
+      description: 'Content to write to the file'
+    },
+    overwrite: {
+      type: 'boolean',
+      description: 'Overwrite if file exists (default: false)'
+    }
+  },
+  required: ['file_path', 'content']
+};
+
+// Tool descriptions for XML definitions
+export const editDescription = 'Edit files using exact string replacement. Requires exact match including whitespace.';
+export const createDescription = 'Create new files with specified content. Will create parent directories if needed.';
+
+// XML tool definitions
+export const editToolDefinition = `
+## edit
+Description: ${editDescription}
+
+When to use:
+- For precise, surgical edits to existing files
+- When you need to change specific lines or blocks of code
+- For renaming functions, variables, or updating configuration values
+- When the exact text to replace is known and unique (or use replace_all for multiple occurrences)
+
+When NOT to use:
+- For creating new files (use 'create' tool instead)
+- When you cannot determine the exact text to replace
+- When changes span multiple locations that would be better handled together
+
+Parameters:
+- file_path: (required) Path to the file to edit
+- old_string: (required) Exact text to find and replace (must match including whitespace, newlines, and indentation)
+- new_string: (required) Text to replace with
+- replace_all: (optional, default: false) Replace all occurrences if the string appears multiple times
+
+Important notes:
+- The old_string MUST match EXACTLY, including all whitespace, indentation, and line breaks
+- If old_string appears multiple times and replace_all is false, the tool will fail
+- Always verify the exact formatting of the text you want to replace
+
+Examples:
+<edit>
+<file_path>src/main.js</file_path>
+<old_string>function oldName() {
+  return 42;
+}</old_string>
+<new_string>function newName() {
+  return 42;
+}</new_string>
+</edit>
+
+<edit>
+<file_path>config.json</file_path>
+<old_string>"debug": false</old_string>
+<new_string>"debug": true</new_string>
+<replace_all>true</replace_all>
+</edit>`;
+
+export const createToolDefinition = `
+## create
+Description: ${createDescription}
+
+When to use:
+- For creating brand new files from scratch
+- When you need to add configuration files, documentation, or new modules
+- For generating boilerplate code or templates
+- When you have the complete content ready to write
+
+When NOT to use:
+- For editing existing files (use 'edit' tool instead)
+- When a file already exists unless you explicitly want to overwrite it
+
+Parameters:
+- file_path: (required) Path where the file should be created
+- content: (required) Complete content to write to the file
+- overwrite: (optional, default: false) Whether to overwrite if file already exists
+
+Important notes:
+- Parent directories will be created automatically if they don't exist
+- The tool will fail if the file already exists and overwrite is false
+- Be careful with the overwrite option as it completely replaces existing files
+
+Examples:
+<create>
+<file_path>src/newFile.js</file_path>
+<content>export function hello() {
+  return "Hello, world!";
+}</content>
+</create>
+
+<create>
+<file_path>README.md</file_path>
+<content># My Project
+
+This is a new project.</content>
+<overwrite>true</overwrite>
+</create>`;

package/build/tools/index.js

@@ -6,6 +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 LangChain tools
 export { createSearchTool, createQueryTool, createExtractTool } from './langchain.js';
@@ -25,6 +26,16 @@ export {
 	attemptCompletionToolDefinition
 } from './common.js';
 
+// Export edit and create schemas
+export {
+	editSchema,
+	createSchema,
+	editDescription,
+	createDescription,
+	editToolDefinition,
+	createToolDefinition
+} from './edit.js';
+
 // Export system message
 export { DEFAULT_SYSTEM_MESSAGE } from './system-message.js';