@probelabs/probe 0.6.0-rc159 → 0.6.0-rc161

package/src/agent/RetryManager.js

@@ -0,0 +1,334 @@
+/**
+ * RetryManager - Handles retry logic with exponential backoff
+ *
+ * Provides configurable retry behavior for AI API calls with:
+ * - Exponential backoff
+ * - Configurable retry limits
+ * - Error type filtering
+ * - Detailed error context
+ */
+
+/**
+ * Default retryable error patterns
+ */
+const DEFAULT_RETRYABLE_ERRORS = [
+  'Overloaded',
+  'overloaded',
+  'rate_limit',
+  'rate limit',
+  '429',
+  '500',
+  '502',
+  '503',
+  '504',
+  'timeout',
+  'ECONNRESET',
+  'ETIMEDOUT',
+  'ENOTFOUND',
+  'api_error'
+];
+
+/**
+ * Check if an error is retryable based on error patterns
+ * @param {Error} error - The error to check
+ * @param {Array<string>} retryableErrors - List of retryable error patterns
+ * @returns {boolean} - True if error should be retried
+ */
+function isRetryableError(error, retryableErrors = DEFAULT_RETRYABLE_ERRORS) {
+  if (!error) return false;
+
+  const errorString = error.toString().toLowerCase();
+  const errorMessage = (error.message || '').toLowerCase();
+  const errorCode = (error.code || '').toLowerCase();
+  const errorType = (error.type || '').toLowerCase();
+  const statusCode = error.statusCode || error.status;
+
+  // Check if error matches any retryable pattern
+  for (const pattern of retryableErrors) {
+    const lowerPattern = pattern.toLowerCase();
+
+    if (errorString.includes(lowerPattern) ||
+        errorMessage.includes(lowerPattern) ||
+        errorCode.includes(lowerPattern) ||
+        errorType.includes(lowerPattern) ||
+        statusCode?.toString() === pattern) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Extract meaningful error information for logging
+ * @param {Error} error - The error to extract info from
+ * @returns {Object} - Error information object
+ */
+function extractErrorInfo(error) {
+  return {
+    message: error.message || error.toString(),
+    type: error.type || error.constructor.name,
+    code: error.code,
+    statusCode: error.statusCode || error.status,
+    provider: error.provider,
+    isRetryable: isRetryableError(error)
+  };
+}
+
+/**
+ * Sleep for a specified duration
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * RetryManager class for handling retry logic with exponential backoff
+ */
+export class RetryManager {
+  /**
+   * Create a new RetryManager
+   * @param {Object} options - Configuration options
+   * @param {number} [options.maxRetries=3] - Maximum retry attempts
+   * @param {number} [options.initialDelay=1000] - Initial delay in ms (1 second)
+   * @param {number} [options.maxDelay=30000] - Maximum delay in ms (30 seconds)
+   * @param {number} [options.backoffFactor=2] - Exponential backoff multiplier
+   * @param {Array<string>} [options.retryableErrors] - List of retryable error patterns
+   * @param {boolean} [options.debug=false] - Enable debug logging
+   */
+  constructor(options = {}) {
+    // Validate and set configuration with defaults
+    this.maxRetries = this._validateNumber(options.maxRetries, 3, 'maxRetries', 0, 100);
+    this.initialDelay = this._validateNumber(options.initialDelay, 1000, 'initialDelay', 0, 60000);
+    this.maxDelay = this._validateNumber(options.maxDelay, 30000, 'maxDelay', 0, 300000);
+    this.backoffFactor = this._validateNumber(options.backoffFactor, 2, 'backoffFactor', 1, 10);
+    this.retryableErrors = options.retryableErrors || DEFAULT_RETRYABLE_ERRORS;
+    this.debug = options.debug ?? false;
+    this.jitter = options.jitter ?? true; // Add random jitter by default
+
+    // Validate that maxDelay >= initialDelay
+    if (this.maxDelay < this.initialDelay) {
+      throw new Error('maxDelay must be greater than or equal to initialDelay');
+    }
+
+    // Statistics
+    this.stats = {
+      totalAttempts: 0,
+      totalRetries: 0,
+      successfulRetries: 0,
+      failedRetries: 0
+    };
+  }
+
+  /**
+   * Validate a numeric parameter
+   * @param {*} value - Value to validate
+   * @param {number} defaultValue - Default if undefined
+   * @param {string} name - Parameter name for error messages
+   * @param {number} min - Minimum allowed value
+   * @param {number} max - Maximum allowed value
+   * @returns {number} - Validated number
+   * @private
+   */
+  _validateNumber(value, defaultValue, name, min, max) {
+    if (value === undefined || value === null) {
+      return defaultValue;
+    }
+
+    const num = Number(value);
+
+    if (isNaN(num)) {
+      throw new Error(`${name} must be a number, got: ${value}`);
+    }
+
+    if (num < min || num > max) {
+      throw new Error(`${name} must be between ${min} and ${max}, got: ${num}`);
+    }
+
+    return num;
+  }
+
+  /**
+   * Execute a function with retry logic
+   * @param {Function} fn - Async function to execute
+   * @param {Object} [context={}] - Context information for logging
+   * @param {AbortSignal} [context.signal] - Optional abort signal for cancellation
+   * @returns {Promise<*>} - Result from the function
+   * @throws {Error} - If all retries are exhausted or operation is aborted
+   */
+  async executeWithRetry(fn, context = {}) {
+    let lastError = null;
+    let currentDelay = this.initialDelay;
+
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      // Check for abort signal
+      if (context.signal?.aborted) {
+        const abortError = new Error('Operation aborted');
+        abortError.name = 'AbortError';
+        throw abortError;
+      }
+
+      this.stats.totalAttempts++;
+
+      try {
+        if (this.debug && attempt > 0) {
+          console.log(`[RetryManager] Retry attempt ${attempt}/${this.maxRetries}`, context);
+        }
+
+        const result = await fn();
+
+        // Success!
+        if (attempt > 0) {
+          this.stats.successfulRetries++;
+          if (this.debug) {
+            console.log(`[RetryManager] ✅ Retry successful on attempt ${attempt + 1}`, context);
+          }
+        }
+
+        return result;
+
+      } catch (error) {
+        lastError = error;
+        const errorInfo = extractErrorInfo(error);
+
+        // Check if we should retry
+        const shouldRetry = isRetryableError(error, this.retryableErrors);
+        const hasRetriesLeft = attempt < this.maxRetries;
+
+        if (this.debug) {
+          console.log(`[RetryManager] ❌ Attempt ${attempt + 1}/${this.maxRetries + 1} failed:`, {
+            ...context,
+            error: errorInfo,
+            shouldRetry,
+            hasRetriesLeft
+          });
+        }
+
+        // If this is not a retryable error or no retries left, throw
+        if (!shouldRetry) {
+          if (this.debug) {
+            console.log(`[RetryManager] Error is not retryable, failing immediately`, errorInfo);
+          }
+          throw error;
+        }
+
+        if (!hasRetriesLeft) {
+          this.stats.failedRetries++;
+          if (this.debug) {
+            console.log(`[RetryManager] Max retries (${this.maxRetries}) exhausted`, context);
+          }
+          throw error;
+        }
+
+        // Wait before retrying with exponential backoff
+        this.stats.totalRetries++;
+
+        // Add jitter to prevent thundering herd
+        let delayWithJitter = currentDelay;
+        if (this.jitter) {
+          // Add ±25% jitter
+          const jitterAmount = currentDelay * 0.25;
+          delayWithJitter = currentDelay + (Math.random() * jitterAmount * 2 - jitterAmount);
+        }
+
+        if (this.debug) {
+          console.log(`[RetryManager] Waiting ${Math.round(delayWithJitter)}ms before retry...`);
+        }
+
+        await sleep(delayWithJitter);
+
+        // Calculate next delay with exponential backoff
+        currentDelay = Math.min(currentDelay * this.backoffFactor, this.maxDelay);
+      }
+    }
+
+    // This should never be reached, but just in case
+    throw lastError;
+  }
+
+  /**
+   * Check if an error is retryable
+   * @param {Error} error - The error to check
+   * @returns {boolean} - True if error should be retried
+   */
+  isRetryable(error) {
+    return isRetryableError(error, this.retryableErrors);
+  }
+
+  /**
+   * Get retry statistics
+   * @returns {Object} - Statistics object
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalAttempts: 0,
+      totalRetries: 0,
+      successfulRetries: 0,
+      failedRetries: 0
+    };
+  }
+}
+
+/**
+ * Create a RetryManager from environment variables
+ * @param {boolean} [debug=false] - Enable debug logging
+ * @returns {RetryManager} - Configured RetryManager instance
+ */
+export function createRetryManagerFromEnv(debug = false) {
+  const options = { debug };
+
+  // Parse and validate environment variables
+  if (process.env.MAX_RETRIES) {
+    const parsed = parseInt(process.env.MAX_RETRIES, 10);
+    if (!isNaN(parsed) && parsed >= 0 && parsed <= 50) {
+      options.maxRetries = parsed;
+    } else {
+      console.warn(`[RetryManager] MAX_RETRIES must be between 0 and 50, using default`);
+    }
+  }
+
+  if (process.env.RETRY_INITIAL_DELAY) {
+    const parsed = parseInt(process.env.RETRY_INITIAL_DELAY, 10);
+    if (!isNaN(parsed) && parsed >= 0 && parsed <= 60000) {
+      options.initialDelay = parsed;
+    } else {
+      console.warn(`[RetryManager] RETRY_INITIAL_DELAY must be between 0 and 60000ms, using default`);
+    }
+  }
+
+  if (process.env.RETRY_MAX_DELAY) {
+    const parsed = parseInt(process.env.RETRY_MAX_DELAY, 10);
+    if (!isNaN(parsed) && parsed >= 0 && parsed <= 300000) {
+      options.maxDelay = parsed;
+    } else {
+      console.warn(`[RetryManager] RETRY_MAX_DELAY must be between 0 and 300000ms, using default`);
+    }
+  }
+
+  if (process.env.RETRY_BACKOFF_FACTOR) {
+    const parsed = parseFloat(process.env.RETRY_BACKOFF_FACTOR);
+    if (!isNaN(parsed) && parsed >= 1 && parsed <= 10) {
+      options.backoffFactor = parsed;
+    } else {
+      console.warn(`[RetryManager] RETRY_BACKOFF_FACTOR must be between 1 and 10, using default`);
+    }
+  }
+
+  if (process.env.RETRY_JITTER === '0' || process.env.RETRY_JITTER === 'false') {
+    options.jitter = false;
+  }
+
+  return new RetryManager(options);
+}
+
+// Export utility functions
+export { isRetryableError, extractErrorInfo, DEFAULT_RETRYABLE_ERRORS };

package/src/agent/acp/tools.js

@@ -286,7 +286,7 @@ export class ACPToolManager {
             },
             allow_tests: {
               type: 'boolean',
-              description: 'Include test files in results (default: false)'
+              description: 'Include test files in results (default: true)'
             }
           },
           required: ['query']
@@ -314,6 +314,10 @@ export class ACPToolManager {
             max_results: {
               type: 'number',
               description: 'Maximum number of results to return (default: 10)'
+            },
+            allow_tests: {
+              type: 'boolean',
+              description: 'Allow test files in search results (default: true)'
             }
           },
           required: ['pattern']
@@ -337,7 +341,7 @@ export class ACPToolManager {
             },
             allow_tests: {
               type: 'boolean',
-              description: 'Allow test files in results (default: false)'
+              description: 'Allow test files in results (default: true)'
             },
             format: {
               type: 'string',

package/src/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/src/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/src/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/src/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: