@probelabs/probe 0.6.0-rc117 → 0.6.0-rc119

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc117",
+  "version": "0.6.0-rc119",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -80,13 +80,13 @@
     "@opentelemetry/sdk-node": "^0.203.0",
     "@opentelemetry/sdk-trace-base": "^1.30.0",
     "@opentelemetry/semantic-conventions": "^1.36.0",
-    "@probelabs/maid": "^0.0.7",
+    "@probelabs/maid": "^0.0.8",
     "ai": "^5.0.0",
     "axios": "^1.8.3",
     "fs-extra": "^11.1.1",
     "glob": "^10.3.10",
+    "gpt-tokenizer": "^3.0.1",
     "tar": "^6.2.0",
-    "tiktoken": "^1.0.20",
     "zod": "^3.24.2"
   },
   "devDependencies": {

package/src/agent/ProbeAgent.js

@@ -380,6 +380,9 @@ export class ProbeAgent {
   async processImageReferences(content) {
     if (!content) return;
 
+    // First, try to parse listFiles output format to extract directory context
+    const listFilesDirectories = this.extractListFilesDirectories(content);
+
     // Enhanced pattern to detect image file mentions in various contexts
     // Looks for: "image", "file", "screenshot", etc. followed by path-like strings with image extensions
     const extensionsPattern = `(?:${SUPPORTED_IMAGE_EXTENSIONS.join('|')})`;
@@ -414,10 +417,55 @@ export class ProbeAgent {
 
     // Process each found path
     for (const imagePath of foundPaths) {
-      await this.loadImageIfValid(imagePath);
+      // Try to resolve the path with directory context from listFiles output
+      let resolvedPath = imagePath;
+
+      // If the path is just a filename (no directory separator), try to find it in listFiles directories
+      if (!imagePath.includes('/') && !imagePath.includes('\\')) {
+        for (const dir of listFilesDirectories) {
+          const potentialPath = resolve(dir, imagePath);
+          // Check if this file exists by attempting to load it
+          const loaded = await this.loadImageIfValid(potentialPath);
+          if (loaded) {
+            // Successfully loaded with this directory context
+            if (this.debug) {
+              console.log(`[DEBUG] Resolved ${imagePath} to ${potentialPath} using listFiles context`);
+            }
+            break; // Found it, no need to try other directories
+          }
+        }
+      } else {
+        // Path already has directory info, load as-is
+        await this.loadImageIfValid(resolvedPath);
+      }
     }
   }
 
+  /**
+   * Extract directory paths from listFiles tool output
+   * @param {string} content - Tool output content
+   * @returns {string[]} - Array of directory paths
+   */
+  extractListFilesDirectories(content) {
+    const directories = [];
+
+    // Pattern to match listFiles output format: "/path/to/directory:" at the start of a line
+    const dirPattern = /^([^\n:]+):\s*$/gm;
+
+    let match;
+    while ((match = dirPattern.exec(content)) !== null) {
+      const dirPath = match[1].trim();
+      if (dirPath && dirPath.length > 0) {
+        directories.push(dirPath);
+        if (this.debug) {
+          console.log(`[DEBUG] Extracted directory context from listFiles: ${dirPath}`);
+        }
+      }
+    }
+
+    return directories;
+  }
+
   /**
    * Load and cache an image if it's valid and accessible
    * @param {string} imagePath - Path to the image file
@@ -644,16 +692,23 @@ export class ProbeAgent {
       this.mcpBridge = new MCPXmlBridge({ debug: this.debug });
       await this.mcpBridge.initialize(mcpConfig);
 
-      const mcpToolCount = this.mcpBridge.getToolNames().length;
+      const mcpToolNames = this.mcpBridge.getToolNames();
+      const mcpToolCount = mcpToolNames.length;
       if (mcpToolCount > 0) {
         if (this.debug) {
-          console.log(`[DEBUG] Loaded ${mcpToolCount} MCP tools`);
+          console.error('\n[DEBUG] ========================================');
+          console.error(`[DEBUG] MCP Tools Initialized (${mcpToolCount} tools)`);
+          console.error('[DEBUG] Available MCP tools:');
+          for (const toolName of mcpToolNames) {
+            console.error(`[DEBUG]   - ${toolName}`);
+          }
+          console.error('[DEBUG] ========================================\n');
         }
       } else {
         // For backward compatibility: if no tools were loaded, set bridge to null
         // This maintains the behavior expected by existing tests
         if (this.debug) {
-          console.log('[DEBUG] No MCP tools loaded, setting bridge to null');
+          console.error('[DEBUG] No MCP tools loaded, setting bridge to null');
         }
         this.mcpBridge = null;
       }

package/src/agent/probeTool.js

@@ -223,9 +223,22 @@ export const listFilesTool = {
 
     // Security: Validate path to prevent traversal attacks
     const secureBaseDir = path.resolve(baseCwd);
-    const targetDir = path.resolve(secureBaseDir, directory);
-    if (!targetDir.startsWith(secureBaseDir + path.sep) && targetDir !== secureBaseDir) {
-      throw new Error('Path traversal attempt detected. Access denied.');
+
+    // If directory is absolute, check if it's within the secure base directory
+    // If it's relative, resolve it against the secure base directory
+    let targetDir;
+    if (path.isAbsolute(directory)) {
+      targetDir = path.resolve(directory);
+      // Check if the absolute path is within the secure base directory
+      if (!targetDir.startsWith(secureBaseDir + path.sep) && targetDir !== secureBaseDir) {
+        throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
+      }
+    } else {
+      targetDir = path.resolve(secureBaseDir, directory);
+      // Double-check the resolved path is still within the secure base directory
+      if (!targetDir.startsWith(secureBaseDir + path.sep) && targetDir !== secureBaseDir) {
+        throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
+      }
     }
 
     const debug = process.env.DEBUG === '1';
@@ -309,9 +322,22 @@ export const searchFilesTool = {
     // Security: Validate path to prevent traversal attacks
     const baseCwd = workingDirectory || process.cwd();
     const secureBaseDir = path.resolve(baseCwd);
-    const targetDir = path.resolve(secureBaseDir, directory);
-    if (!targetDir.startsWith(secureBaseDir + path.sep) && targetDir !== secureBaseDir) {
-      throw new Error('Path traversal attempt detected. Access denied.');
+
+    // If directory is absolute, check if it's within the secure base directory
+    // If it's relative, resolve it against the secure base directory
+    let targetDir;
+    if (path.isAbsolute(directory)) {
+      targetDir = path.resolve(directory);
+      // Check if the absolute path is within the secure base directory
+      if (!targetDir.startsWith(secureBaseDir + path.sep) && targetDir !== secureBaseDir) {
+        throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
+      }
+    } else {
+      targetDir = path.resolve(secureBaseDir, directory);
+      // Double-check the resolved path is still within the secure base directory
+      if (!targetDir.startsWith(secureBaseDir + path.sep) && targetDir !== secureBaseDir) {
+        throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
+      }
     }
 
     // Validate pattern complexity to prevent DoS

package/src/agent/tokenCounter.js

@@ -1,14 +1,14 @@
-import { get_encoding } from 'tiktoken';
+import { encode } from 'gpt-tokenizer';
 
 /**
  * TokenCounter class to track token usage in the agent
  */
 export class TokenCounter {
   constructor() {
-    // Initialize the tokenizer with cl100k_base encoding (works for both Claude and GPT models)
+    // Initialize the tokenizer with gpt-tokenizer (works for both Claude and GPT models)
     try {
-      // Initialize tokenizer
-      this.tokenizer = get_encoding('cl100k_base');
+      // gpt-tokenizer uses encode directly, no need to initialize
+      this.tokenizer = encode;
 
       // Context window tracking
       this.contextSize = 0; // Current size based on history
@@ -30,7 +30,7 @@ export class TokenCounter {
 
     } catch (error) {
       console.error('Error initializing tokenizer:', error);
-      // Fallback to a simple token counting method if tiktoken fails
+      // Fallback to a simple token counting method if gpt-tokenizer fails
       this.tokenizer = null;
       this.contextSize = 0;
       this.requestTokens = 0;
@@ -49,7 +49,7 @@ export class TokenCounter {
   }
 
   /**
-   * Count tokens in a string using tiktoken or fallback method
+   * Count tokens in a string using gpt-tokenizer or fallback method
    * @param {string} text - The text to count tokens for
    * @returns {number} - The number of tokens
    */
@@ -60,7 +60,7 @@ export class TokenCounter {
 
     if (this.tokenizer) {
       try {
-        const tokens = this.tokenizer.encode(text);
+        const tokens = this.tokenizer(text);
         return tokens.length;
       } catch (error) {
         // Fallback to a simple approximation (1 token ≈ 4 characters)