@probelabs/probe 0.6.0-rc154 → 0.6.0-rc161

package/build/downloader.js

@@ -17,6 +17,35 @@ import { getPackageBinDir } from './directory-resolver.js';
 
 const exec = promisify(execCallback);
 
+/**
+ * Create a plain, serializable Error from possibly complex/circular errors (e.g., axios)
+ * Avoids passing circular req/res objects to IPC serializers and test runners.
+ */
+function sanitizeError(err) {
+    try {
+        const status = err?.response?.status;
+        const statusText = err?.response?.statusText;
+        const url = err?.config?.url || err?.response?.config?.url;
+        const code = err?.code;
+        const serverMsg = typeof err?.response?.data === 'string'
+            ? err.response.data.slice(0, 500)
+            : (typeof err?.response?.data?.message === 'string' ? err.response.data.message : undefined);
+        const base = err?.message || String(err);
+        const parts = [base];
+        if (status || statusText) parts.push(`[${(status ?? '')} ${(statusText ?? '')}]`.trim());
+        if (code) parts.push(`code=${code}`);
+        if (url) parts.push(`url=${url}`);
+        if (serverMsg) parts.push(`server="${String(serverMsg).replace(/\s+/g, ' ').trim()}"`);
+        const e = new Error(parts.filter(Boolean).join(' '));
+        if (status) e.status = status;
+        if (code) e.code = code;
+        if (url) e.url = url;
+        return e;
+    } catch (_) {
+        return new Error(err?.message || String(err));
+    }
+}
+
 // GitHub repository information
 const REPO_OWNER = "probelabs";
 const REPO_NAME = "probe";
@@ -69,7 +98,7 @@ async function acquireFileLock(lockPath, version) {
 			console.log(`Acquired file lock: ${lockPath}`);
 		}
 		return true;
-	} catch (error) {
+    } catch (error) {
 		if (error.code === 'EEXIST') {
 			// Lock file exists - check if it's stale
 			try {
@@ -265,13 +294,13 @@ function detectOsArch() {
 	let archInfo;
 
 	// Detect OS
-	switch (osType) {
-		case 'linux':
-			osInfo = {
-				type: 'linux',
-				keywords: ['linux', 'Linux', 'gnu']
-			};
-			break;
+    switch (osType) {
+        case 'linux':
+            osInfo = {
+                type: 'linux',
+                keywords: ['linux', 'Linux', 'musl', 'gnu']
+            };
+            break;
 		case 'darwin':
 			osInfo = {
 				type: 'darwin',
@@ -324,11 +353,11 @@ function constructAssetInfo(version, osInfo, archInfo) {
 	let extension;
 	
 	// Map OS and arch to the expected format in release names
-	switch (osInfo.type) {
-		case 'linux':
-			platform = `${archInfo.type}-unknown-linux-gnu`;
-			extension = 'tar.gz';
-			break;
+    switch (osInfo.type) {
+        case 'linux':
+            platform = `${archInfo.type}-unknown-linux-musl`;
+            extension = 'tar.gz';
+            break;
 		case 'darwin':
 			platform = `${archInfo.type}-apple-darwin`;
 			extension = 'tar.gz';
@@ -482,7 +511,7 @@ async function getLatestRelease(version) {
 			return { tag, assets };
 		}
 
-		throw error;
+		throw sanitizeError(error);
 	}
 }
 
@@ -787,7 +816,7 @@ async function extractBinary(assetPath, outputDir) {
 		return binaryPath;
 	} catch (error) {
 		console.error(`Error extracting binary: ${error instanceof Error ? error.message : String(error)}`);
-		throw error;
+		throw sanitizeError(error);
 	}
 }
 
@@ -1032,7 +1061,7 @@ export async function downloadProbeBinary(version) {
 		}
 		return await withDownloadLock(version, () => doDownload(version));
 	} catch (error) {
-		console.error('Error downloading probe binary:', error);
-		throw error;
+		console.error('Error downloading probe binary:', error?.message || String(error));
+		throw sanitizeError(error);
 	}
 }

package/build/extractor.js

@@ -27,16 +27,16 @@ function detectPlatform() {
 	let extension;
 
 	// Map to the same format used in release artifacts
-	if (osType === 'linux') {
-		if (archType === 'x64') {
-			platform = 'x86_64-unknown-linux-gnu';
-			extension = 'tar.gz';
-		} else if (archType === 'arm64') {
-			platform = 'aarch64-unknown-linux-gnu';
-			extension = 'tar.gz';
-		} else {
-			throw new Error(`Unsupported Linux architecture: ${archType}`);
-		}
+    if (osType === 'linux') {
+        if (archType === 'x64') {
+            platform = 'x86_64-unknown-linux-musl';
+            extension = 'tar.gz';
+        } else if (archType === 'arm64') {
+            platform = 'aarch64-unknown-linux-musl';
+            extension = 'tar.gz';
+        } else {
+            throw new Error(`Unsupported Linux architecture: ${archType}`);
+        }
 	} else if (osType === 'darwin') {
 		if (archType === 'x64') {
 			platform = 'x86_64-apple-darwin';
@@ -191,8 +191,8 @@ export async function extractBundledBinary(version) {
 			`Searched in: ${binariesDir}\n` +
 			`\n` +
 			`Supported platforms:\n` +
-			`  - x86_64-unknown-linux-gnu (Linux x64)\n` +
-			`  - aarch64-unknown-linux-gnu (Linux ARM64)\n` +
+            `  - x86_64-unknown-linux-musl (Linux x64, static)\n` +
+            `  - aarch64-unknown-linux-musl (Linux ARM64, static)\n` +
 			`  - x86_64-apple-darwin (macOS Intel)\n` +
 			`  - aarch64-apple-darwin (macOS Apple Silicon)\n` +
 			`  - x86_64-pc-windows-msvc (Windows x64)\n` +

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:
 

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';