@probelabs/probe-chat 0.6.0-rc116 → 0.6.0-rc118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe-chat",
-  "version": "0.6.0-rc116",
+  "version": "0.6.0-rc118",
   "description": "CLI and web interface for Probe code search (formerly @probelabs/probe-web and @probelabs/probe-chat)",
   "main": "index.js",
   "type": "module",
@@ -84,7 +84,6 @@
     "probeChat.js",
     "tokenCounter.js",
     "tokenUsageDisplay.js",
-    "tools.js",
     "webServer.js",
     "auth.js",
     "probeTool.js",

package/probeTool.js

@@ -1,14 +1,15 @@
-// Import tool generators from @probelabs/probe package
-import { searchTool, queryTool, extractTool, DEFAULT_SYSTEM_MESSAGE, listFilesByLevel } from '@probelabs/probe';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
+// Import tool generators and instances from @probelabs/probe package
+import {
+	searchTool,
+	queryTool,
+	extractTool,
+	DEFAULT_SYSTEM_MESSAGE,
+	listFilesToolInstance as packageListFilesToolInstance,
+	searchFilesToolInstance as packageSearchFilesToolInstance
+} from '@probelabs/probe';
+import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import { EventEmitter } from 'events';
-import fs from 'fs';
-import { promises as fsPromises } from 'fs';
-import path from 'path';
-import os from 'os';
-import { glob } from 'glob';
 
 // Import the new pluggable implementation tool
 import { createImplementTool } from './implement/core/ImplementTool.js';
@@ -323,28 +324,18 @@ const baseImplementTool = {
 	}
 };
 
-// Create the listFiles tool
+// Wrapper for listFiles tool with ALLOWED_FOLDERS security
 const baseListFilesTool = {
-	name: "listFiles",
-	description: 'List files in a specified directory',
-	inputSchema: {
-		type: 'object',
-		properties: {
-			directory: {
-				type: 'string',
-				description: 'The directory path to list files from. Defaults to current directory if not specified.'
-			}
-		},
-		required: []
-	},
-	execute: async ({ directory = '.', sessionId }) => {
+	...packageListFilesToolInstance,
+	execute: async (params) => {
+		const { directory = '.', sessionId } = params;
 		const debug = process.env.DEBUG_CHAT === '1';
 		const currentWorkingDir = process.cwd();
-		
+
 		// Get allowed folders from environment variable
 		const allowedFoldersEnv = process.env.ALLOWED_FOLDERS;
 		let allowedFolders = [];
-		
+
 		if (allowedFoldersEnv) {
 			allowedFolders = allowedFoldersEnv.split(',').map(folder => folder.trim()).filter(folder => folder.length > 0);
 		}
@@ -359,13 +350,13 @@ const baseListFilesTool = {
 			}
 		}
 
-		const targetDir = path.resolve(currentWorkingDir, targetDirectory);
+		const targetDir = require('path').resolve(currentWorkingDir, targetDirectory);
 
 		// Validate that the target directory is within allowed folders
 		if (allowedFolders.length > 0) {
 			const isAllowed = allowedFolders.some(allowedFolder => {
-				const resolvedAllowedFolder = path.resolve(currentWorkingDir, allowedFolder);
-				return targetDir === resolvedAllowedFolder || targetDir.startsWith(resolvedAllowedFolder + path.sep);
+				const resolvedAllowedFolder = require('path').resolve(currentWorkingDir, allowedFolder);
+				return targetDir === resolvedAllowedFolder || targetDir.startsWith(resolvedAllowedFolder + require('path').sep);
 			});
 
 			if (!isAllowed) {
@@ -377,107 +368,27 @@ const baseListFilesTool = {
 			}
 		}
 
-		if (debug) {
-			console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
-		}
-
-		try {
-			// Read the directory contents
-			const files = await fs.promises.readdir(targetDir, { withFileTypes: true });
-
-			// Format size for human readability
-			const formatSize = (size) => {
-				if (size < 1024) return `${size}B`;
-				if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
-				if (size < 1024 * 1024 * 1024) return `${(size / (1024 * 1024)).toFixed(1)}M`;
-				return `${(size / (1024 * 1024 * 1024)).toFixed(1)}G`;
-			};
-
-			// Format the results as ls-style output
-			const entries = await Promise.all(files.map(async (file) => {
-				const isDirectory = file.isDirectory();
-				const fullPath = path.join(targetDir, file.name);
-
-				let size = 0;
-				try {
-					const stats = await fs.promises.stat(fullPath);
-					size = stats.size;
-				} catch (statError) {
-					if (debug) {
-						console.log(`[DEBUG] Could not stat file ${file.name}:`, statError.message);
-					}
-				}
-
-				return {
-					name: file.name,
-					isDirectory,
-					size
-				};
-			}));
-
-			// Sort: directories first, then files, both alphabetically
-			entries.sort((a, b) => {
-				if (a.isDirectory && !b.isDirectory) return -1;
-				if (!a.isDirectory && b.isDirectory) return 1;
-				return a.name.localeCompare(b.name);
-			});
-
-			// Format entries
-			const formatted = entries.map(entry => {
-				const type = entry.isDirectory ? 'dir ' : 'file';
-				const sizeStr = formatSize(entry.size).padStart(8);
-				return `${type} ${sizeStr}  ${entry.name}`;
-			});
-
-			if (debug) {
-				console.log(`[DEBUG] Found ${entries.length} files/directories in ${targetDir}`);
-			}
-
-			// Return as formatted text output
-			const header = `${targetDir}:\n`;
-			const output = header + formatted.join('\n');
-
-			return output;
-		} catch (error) {
-			console.error(`Error listing files in ${targetDir}:`, error);
-			return `Error: ${error.message || 'Unknown error listing files'}`;
-		}
+		// Call the package tool with workingDirectory parameter
+		return packageListFilesToolInstance.execute({
+			...params,
+			directory: targetDirectory,
+			workingDirectory: currentWorkingDir
+		});
 	}
 };
 
-// Create the searchFiles tool
+// Wrapper for searchFiles tool with ALLOWED_FOLDERS security
 const baseSearchFilesTool = {
-	name: "searchFiles",
-	description: 'Search for files using a glob pattern, recursively by default',
-	inputSchema: {
-		type: 'object',
-		properties: {
-			pattern: {
-				type: 'string',
-				description: 'The glob pattern to search for (e.g., "**/*.js", "*.md")'
-			},
-			directory: {
-				type: 'string',
-				description: 'The directory to search in. Defaults to current directory if not specified.'
-			},
-			recursive: {
-				type: 'boolean',
-				description: 'Whether to search recursively. Defaults to true.'
-			}
-		},
-		required: ['pattern']
-	},
-	execute: async ({ pattern, directory, recursive = true, sessionId }) => {
-		// Ensure directory defaults to current directory
-		directory = directory || '.';
-
+	...packageSearchFilesToolInstance,
+	execute: async (params) => {
+		const { pattern, directory = '.', recursive = true, sessionId } = params;
 		const debug = process.env.DEBUG_CHAT === '1';
 		const currentWorkingDir = process.cwd();
-		
+
 		// Get allowed folders from environment variable
 		const allowedFoldersEnv = process.env.ALLOWED_FOLDERS;
 		let allowedFolders = [];
-		
+
 		if (allowedFoldersEnv) {
 			allowedFolders = allowedFoldersEnv.split(',').map(folder => folder.trim()).filter(folder => folder.length > 0);
 		}
@@ -492,13 +403,13 @@ const baseSearchFilesTool = {
 			}
 		}
 
-		const targetDir = path.resolve(currentWorkingDir, targetDirectory);
+		const targetDir = require('path').resolve(currentWorkingDir, targetDirectory);
 
 		// Validate that the target directory is within allowed folders
 		if (allowedFolders.length > 0) {
 			const isAllowed = allowedFolders.some(allowedFolder => {
-				const resolvedAllowedFolder = path.resolve(currentWorkingDir, allowedFolder);
-				return targetDir === resolvedAllowedFolder || targetDir.startsWith(resolvedAllowedFolder + path.sep);
+				const resolvedAllowedFolder = require('path').resolve(currentWorkingDir, allowedFolder);
+				return targetDir === resolvedAllowedFolder || targetDir.startsWith(resolvedAllowedFolder + require('path').sep);
 			});
 
 			if (!isAllowed) {
@@ -518,160 +429,34 @@ const baseSearchFilesTool = {
 
 		// Log execution parameters to stderr for visibility
 		console.error(`Executing searchFiles with params: pattern="${pattern}", directory="${targetDirectory}", recursive=${recursive}`);
-		console.error(`Resolved target directory: ${targetDir}`);
-		console.error(`Current working directory: ${currentWorkingDir}`);
-
-		if (debug) {
-			console.log(`[DEBUG] Searching for files with pattern: ${pattern}`);
-			console.log(`[DEBUG] In directory: ${targetDir}`);
-			console.log(`[DEBUG] Recursive: ${recursive}`);
-		}
-
-		// Validate pattern to prevent overly complex patterns
-		if (pattern.includes('**/**') || pattern.split('*').length > 10) {
-			console.error(`Pattern too complex: ${pattern}`);
-			return {
-				success: false,
-				directory: targetDir,
-				pattern: pattern,
-				error: 'Pattern too complex. Please use a simpler glob pattern.',
-				timestamp: new Date().toISOString()
-			};
-		}
 
 		try {
-			// Set glob options with timeout and limits
-			const options = {
-				cwd: targetDir,
-				dot: true, // Include dotfiles
-				nodir: true, // Only return files, not directories
-				absolute: false, // Return paths relative to the search directory
-				timeout: 10000, // 10 second timeout
-				maxDepth: recursive ? 10 : 1, // Limit recursion depth
-			};
-
-			// If not recursive, modify the pattern to only search the top level
-			const searchPattern = recursive ? pattern : pattern.replace(/^\*\*\//, '');
-
-			console.error(`Starting glob search with pattern: ${searchPattern} in ${targetDir}`);
-			console.error(`Glob options: ${JSON.stringify(options)}`);
-
-			// Use a safer approach with manual file searching if the pattern is simple enough
-			let files = [];
-
-			// For simple patterns like "*.js" or "bin/*.js", use a more direct approach
-			if (pattern.includes('*') && !pattern.includes('**') && pattern.split('/').length <= 2) {
-				console.error(`Using direct file search for simple pattern: ${pattern}`);
-
-				try {
-					// Handle patterns like "dir/*.ext" or "*.ext"
-					const parts = pattern.split('/');
-					let searchDir = targetDir;
-					let filePattern;
-
-					if (parts.length === 2) {
-						// Pattern like "dir/*.ext"
-						searchDir = path.join(targetDir, parts[0]);
-						filePattern = parts[1];
-					} else {
-						// Pattern like "*.ext"
-						filePattern = parts[0];
-					}
-
-					console.error(`Searching in directory: ${searchDir} for files matching: ${filePattern}`);
-
-					// Check if directory exists
-					try {
-						await fsPromises.access(searchDir);
-					} catch (err) {
-						console.error(`Directory does not exist: ${searchDir}`);
-						console.error(`Falling back to search in parent directory: ${targetDir}`);
-						// Fall back to searching in the parent directory instead of failing
-						searchDir = targetDir;
-						// Adjust the pattern to include the subdirectory in the search
-						filePattern = pattern; // Use the original pattern for glob matching
-					}
-
-					// Read directory contents
-					const dirEntries = await fsPromises.readdir(searchDir, { withFileTypes: true });
-
-					// Convert glob pattern to regex
-					const regexPattern = filePattern
-						.replace(/\./g, '\\.')
-						.replace(/\*/g, '.*');
-					const regex = new RegExp(`^${regexPattern}$`);
-
-					// Filter files based on pattern
-					files = dirEntries
-						.filter(entry => entry.isFile() && regex.test(entry.name))
-						.map(entry => {
-							const relativePath = parts.length === 2
-								? path.join(parts[0], entry.name)
-								: entry.name;
-							return relativePath;
-						});
-
-					console.error(`Direct search found ${files.length} files matching ${filePattern}`);
-				} catch (err) {
-					console.error(`Error in direct file search: ${err.message}`);
-					// Fall back to glob if direct search fails
-					console.error(`Falling back to glob search`);
-
-					// Create a promise that rejects after a timeout
-					const timeoutPromise = new Promise((_, reject) => {
-						setTimeout(() => reject(new Error('Search operation timed out after 10 seconds')), 10000);
-					});
-
-					// Use glob without promisify since it might already return a Promise
-					files = await Promise.race([
-						glob(searchPattern, options),
-						timeoutPromise
-					]);
-				}
-			} else {
-				console.error(`Using glob for complex pattern: ${pattern}`);
-
-				// Create a promise that rejects after a timeout
-				const timeoutPromise = new Promise((_, reject) => {
-					setTimeout(() => reject(new Error('Search operation timed out after 10 seconds')), 10000);
-				});
-
-				// Use glob without promisify since it might already return a Promise
-				files = await Promise.race([
-					glob(searchPattern, options),
-					timeoutPromise
-				]);
-			}
-
-			console.error(`Search completed, found ${files.length} files in ${targetDir}`);
-			console.error(`Pattern: ${pattern}, Recursive: ${recursive}`);
+			// Call the package tool with workingDirectory parameter
+			const files = await packageSearchFilesToolInstance.execute({
+				...params,
+				directory: targetDirectory,
+				recursive,
+				workingDirectory: currentWorkingDir
+			});
 
 			if (debug) {
 				console.log(`[DEBUG] Found ${files.length} files matching pattern ${pattern}`);
 			}
 
-			// Limit the number of results to prevent memory issues
-			const maxResults = 1000;
-			const limitedFiles = files.length > maxResults ? files.slice(0, maxResults) : files;
-
-			if (files.length > maxResults) {
-				console.warn(`Warning: Limited results to ${maxResults} files out of ${files.length} total matches`);
-			}
-
+			// Return in the expected format for backward compatibility
 			return {
 				success: true,
 				directory: targetDir,
 				pattern: pattern,
 				recursive: recursive,
-				files: limitedFiles.map(file => path.join(targetDirectory, file)),
-				count: limitedFiles.length,
+				files: files.map(file => require('path').join(targetDirectory, file)),
+				count: files.length,
 				totalMatches: files.length,
-				limited: files.length > maxResults,
+				limited: false,
 				timestamp: new Date().toISOString()
 			};
 		} catch (error) {
 			console.error(`Error searching files with pattern "${pattern}" in ${targetDir}:`, error);
-			console.error(`Search parameters: directory="${targetDirectory}", recursive=${recursive}, sessionId=${sessionId}`);
 			return {
 				success: false,
 				directory: targetDir,
@@ -704,71 +489,3 @@ if (process.env.DEBUG_CHAT === '1') {
 	console.log('[DEBUG] ========================================\n');
 }
 
-// --- Backward Compatibility Layer (probeTool mapping to searchToolInstance) ---
-// This might be less relevant if the AI is strictly using the new XML format,
-// but keep it for potential direct API calls or older UI elements.
-export const probeTool = {
-	...searchToolInstance, // Inherit schema description etc. from the wrapped search tool
-	name: "search", // Explicitly set name
-	description: 'DEPRECATED: Use <search> tool instead. Search code using keywords.',
-	// parameters: searchSchema, // Use the imported schema
-	execute: async (params) => { // Expects { keywords, folder, ..., sessionId }
-		const debug = process.env.DEBUG_CHAT === '1';
-		if (debug) {
-			console.log(`[DEBUG] probeTool (Compatibility Layer) executing for session ${params.sessionId}`);
-		}
-
-		// Map old params ('keywords', 'folder') to new ones ('query', 'path')
-		const { keywords, folder, sessionId, ...rest } = params;
-		const mappedParams = {
-			query: keywords,
-			path: folder || '.', // Default path if folder is missing
-			sessionId: sessionId, // Pass session ID through
-			...rest // Pass other params like allow_tests, maxResults etc.
-		};
-
-		if (debug) {
-			console.log("[DEBUG] probeTool mapped params: ", mappedParams);
-		}
-
-		// Call the *wrapped* searchToolInstance execute function
-		// It will handle cancellation checks and event emitting internally
-		try {
-			// Note: The name emitted by searchToolInstance will be 'search', not 'probeTool' or 'searchCode'
-			const result = await searchToolInstance.execute(mappedParams);
-
-			// Format the result for backward compatibility if needed by caller
-			// The raw result from searchToolInstance is likely just the search results array/string
-			const formattedResult = {
-				results: result, // Assuming result is the direct data
-				command: `probe search --query "${keywords}" --path "${folder || '.'}"`, // Reconstruct approx command
-				timestamp: new Date().toISOString()
-			};
-			if (debug) {
-				console.log("[DEBUG] probeTool compatibility layer returning formatted result.");
-			}
-			return formattedResult;
-
-		} catch (error) {
-			if (debug) {
-				console.error(`[DEBUG] Error in probeTool compatibility layer:`, error);
-			}
-			// Error is already emitted by the wrapped searchToolInstance, just re-throw
-			throw error;
-		}
-	}
-};
-// Export necessary items
-export { DEFAULT_SYSTEM_MESSAGE, listFilesByLevel };
-// Export the tool generator functions if needed elsewhere
-export { searchTool, queryTool, extractTool };
-
-// Export capabilities information for the new tools
-export const toolCapabilities = {
-	search: "Search code using keywords and patterns",
-	query: "Query code with structured parameters for more precise results",
-	extract: "Extract code blocks and context from files",
-	implement: "Implement features or fix bugs using aider (requires --allow-edit)",
-	listFiles: "List files and directories in a specified location",
-	searchFiles: "Find files matching a glob pattern with recursive search capability"
-};

package/tools.js

@@ -1,186 +0,0 @@
-// This file might become obsolete or significantly simplified if tools
-// are only defined/described in the system prompt and not passed to Vercel AI SDK.
-
-// Let's comment it out for now, assuming it's not directly used in the new flow.
-// If specific exports are needed elsewhere (like DEFAULT_SYSTEM_MESSAGE), they
-// should be moved or imported directly from @probelabs/probe.
-
-
-// Import tool generators and schemas from @probelabs/probe package
-import {
-  searchTool,
-  queryTool,
-  extractTool,
-  DEFAULT_SYSTEM_MESSAGE,
-  attemptCompletionSchema,
-  attemptCompletionToolDefinition,
-  searchSchema,
-  querySchema,
-  extractSchema,
-  searchToolDefinition,
-  queryToolDefinition,
-  extractToolDefinition,
-  // Add the implement tool definition import if it exists in @probelabs/probe
-  // If not, we define it here. Assuming it's not in the package yet:
-} from '@probelabs/probe';
-import { randomUUID } from 'crypto';
-
-// Generate a session ID
-const sessionId = process.env.PROBE_SESSION_ID || randomUUID();
-console.error(`Generated session ID for search caching: ${sessionId}`);
-
-// Debug mode
-const debug = process.env.DEBUG_CHAT === '1';
-
-// Configure tools with the session ID
-const configOptions = {
-  sessionId,
-  debug
-};
-
-// Create configured tool instances
-export const tools = {
-  searchTool: searchTool(configOptions),
-  queryTool: queryTool(configOptions),
-  extractTool: extractTool(configOptions),
-  // Note: The actual implement tool *instance* comes from probeTool.js
-  // This file primarily deals with definitions for the system prompt.
-};
-
-// Export individual tools for direct use
-export const { searchTool: searchToolInstance, queryTool: queryToolInstance, extractTool: extractToolInstance } = tools;
-
-// For backward compatibility, export the original tool objects
-export {
-  searchToolInstance as searchTool,
-  queryToolInstance as queryTool,
-  extractToolInstance as extractTool,
-  DEFAULT_SYSTEM_MESSAGE,
-  // Export schemas
-  searchSchema,
-  querySchema,
-  extractSchema,
-  attemptCompletionSchema,
-  // Export tool definitions
-  searchToolDefinition,
-  queryToolDefinition,
-  extractToolDefinition,
-  attemptCompletionToolDefinition,
-};
-
-// Define the implement tool XML definition
-export const implementToolDefinition = `
-## implement
-Description: Implement a given task. Can modify files. Can be used ONLY if task explicitly stated that something requires modification or implementation.
-
-Parameters:
-- task: (required) The task description. Should be as detailed as possible, ideally pointing to exact files which needs be modified or created.
-- autoCommits: (optional) Whether to enable auto-commits in aider. Default is false.
-
-Usage Example:
-
-<examples>
-
-User: Can you implement a function to calculate Fibonacci numbers in main.js?
-<implement>
-<task>Implement a recursive function to calculate the nth Fibonacci number in main.js</task>
-</implement>
-
-User: Can you implement a function to calculate Fibonacci numbers in main.js with auto-commits?
-<implement>
-<task>Implement a recursive function to calculate the nth Fibonacci number in main.js</task>
-<autoCommits>true</autoCommits>
-</implement>
-
-</examples>
-`;
-
-// Define the listFiles tool XML definition
-export const listFilesToolDefinition = `
-## listFiles
-Description: List files and directories in a specified location.
-
-Parameters:
-- directory: (optional) The directory path to list files from. Defaults to current directory if not specified.
-
-Usage Example:
-
-<examples>
-
-User: Can you list the files in the src directory?
-<listFiles>
-<directory>src</directory>
-</listFiles>
-
-User: What files are in the current directory?
-<listFiles>
-</listFiles>
-
-</examples>
-`;
-
-// Define the searchFiles tool XML definition
-export const searchFilesToolDefinition = `
-## searchFiles
-Description: Find files with name matching a glob pattern with recursive search capability.
-
-Parameters:
-- pattern: (required) The glob pattern to search for (e.g., "**/*.js", "*.md").
-- directory: (optional) The directory to search in. Defaults to current directory if not specified.
-- recursive: (optional) Whether to search recursively. Defaults to true.
-
-Usage Example:
-
-<examples>
-
-User: Can you find all JavaScript files in the project?
-<searchFiles>
-<pattern>**/*.js</pattern>
-</searchFiles>
-
-User: Find all markdown files in the docs directory, but only at the top level.
-<searchFiles>
-<pattern>*.md</pattern>
-<directory>docs</directory>
-<recursive>false</recursive>
-</searchFiles>
-
-</examples>
-`;
-
-
-// Import the XML parser function from @probelabs/probe
-import { parseXmlToolCall } from '@probelabs/probe';
-
-// Re-export the original parseXmlToolCall
-export { parseXmlToolCall };
-
-/**
- * Enhanced XML parser that handles thinking tags
- * This function removes any <thinking></thinking> tags from the input string
- * before passing it to the original parseXmlToolCall function
- * @param {string} xmlString - The XML string to parse
- * @returns {Object|null} - The parsed tool call or null if no valid tool call found
- */
-export function parseXmlToolCallWithThinking(xmlString) {
-  // Extract thinking content if present (for potential logging or analysis)
-  const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  const thinkingContent = thinkingMatch ? thinkingMatch[1].trim() : null;
-
-  // Remove thinking tags and their content from the XML string
-  const cleanedXmlString = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
-
-  // Use the original parseXmlToolCall function to parse the cleaned XML string
-  const parsedTool = parseXmlToolCall(cleanedXmlString);
-
-  // If debugging is enabled, log the thinking content
-  if (process.env.DEBUG_CHAT === '1' && thinkingContent) {
-    console.log(`[DEBUG] AI Thinking Process:\n${thinkingContent}`);
-  }
-
-  return parsedTool;
-}
-
-// If tool instances are needed directly (e.g., for API endpoints bypassing the LLM loop),
-// they are now created and exported from probeTool.js.
-// We should ensure those are imported where needed.