@probelabs/probe 0.6.0-rc100

package/build/tools/vercel.js

@@ -0,0 +1,271 @@
+/**
+ * Tools for Vercel AI SDK
+ * @module tools/vercel
+ */
+
+import { tool } from 'ai';
+import { search } from '../search.js';
+import { query } from '../query.js';
+import { extract } from '../extract.js';
+import { delegate } from '../delegate.js';
+import { searchSchema, querySchema, extractSchema, delegateSchema, searchDescription, queryDescription, extractDescription, delegateDescription } from './common.js';
+
+/**
+ * Search tool generator
+ * 
+ * @param {Object} [options] - Configuration options
+ * @param {string} [options.sessionId] - Session ID for caching search results
+ * @param {number} [options.maxTokens=10000] - Default max tokens
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @returns {Object} Configured search tool
+ */
+export const searchTool = (options = {}) => {
+	const { sessionId, maxTokens = 10000, debug = false, outline = false } = options;
+
+	return tool({
+		name: 'search',
+		description: searchDescription,
+		inputSchema: searchSchema,
+		execute: async ({ query: searchQuery, path, allow_tests, exact, maxTokens: paramMaxTokens, language }) => {
+			try {
+				// Use parameter maxTokens if provided, otherwise use the default
+				const effectiveMaxTokens = paramMaxTokens || maxTokens;
+
+				// Use the path from parameters if provided, otherwise use defaultPath from config
+				let searchPath = path || options.defaultPath || '.';
+
+				// If path is "." or "./", use the defaultPath if available
+				if ((searchPath === "." || searchPath === "./") && options.defaultPath) {
+					if (debug) {
+						console.error(`Using default path "${options.defaultPath}" instead of "${searchPath}"`);
+					}
+					searchPath = options.defaultPath;
+				}
+
+				if (debug) {
+					console.error(`Executing search with query: "${searchQuery}", path: "${searchPath}", exact: ${exact ? 'true' : 'false'}, language: ${language || 'all'}, session: ${sessionId || 'none'}`);
+				}
+
+				const searchOptions = {
+					query: searchQuery,
+					path: searchPath,
+					allowTests: allow_tests,
+					exact,
+					json: false,
+					maxTokens: effectiveMaxTokens,
+					session: sessionId, // Pass session ID if provided
+					language // Pass language parameter if provided
+				};
+
+				// Add outline format if enabled
+				if (outline) {
+					searchOptions.format = 'outline-xml';
+				}
+
+				const results = await search(searchOptions);
+
+				return results;
+			} catch (error) {
+				console.error('Error executing search command:', error);
+				return `Error executing search command: ${error.message}`;
+			}
+		}
+	});
+};
+
+/**
+ * Query tool generator
+ * 
+ * @param {Object} [options] - Configuration options
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @returns {Object} Configured query tool
+ */
+export const queryTool = (options = {}) => {
+	const { debug = false } = options;
+
+	return tool({
+		name: 'query',
+		description: queryDescription,
+		inputSchema: querySchema,
+		execute: async ({ pattern, path, language, allow_tests }) => {
+			try {
+				// Use the path from parameters if provided, otherwise use defaultPath from config
+				let queryPath = path || options.defaultPath || '.';
+
+				// If path is "." or "./", use the defaultPath if available
+				if ((queryPath === "." || queryPath === "./") && options.defaultPath) {
+					if (debug) {
+						console.error(`Using default path "${options.defaultPath}" instead of "${queryPath}"`);
+					}
+					queryPath = options.defaultPath;
+				}
+
+				if (debug) {
+					console.error(`Executing query with pattern: "${pattern}", path: "${queryPath}", language: ${language || 'auto'}`);
+				}
+
+				const results = await query({
+					pattern,
+					path: queryPath,
+					language,
+					allow_tests,
+					json: false
+				});
+
+				return results;
+			} catch (error) {
+				console.error('Error executing query command:', error);
+				return `Error executing query command: ${error.message}`;
+			}
+		}
+	});
+};
+
+/**
+ * Extract tool generator
+ * 
+ * @param {Object} [options] - Configuration options
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @returns {Object} Configured extract tool
+ */
+export const extractTool = (options = {}) => {
+	const { debug = false, outline = false } = options;
+
+	return tool({
+		name: 'extract',
+		description: extractDescription,
+		inputSchema: extractSchema,
+		execute: async ({ targets, input_content, line, end_line, allow_tests, context_lines, format }) => {
+			try {
+				// Use the defaultPath from config for context
+				let extractPath = options.defaultPath || '.';
+
+				// If path is "." or "./", use the defaultPath if available
+				if ((extractPath === "." || extractPath === "./") && options.defaultPath) {
+					if (debug) {
+						console.error(`Using default path "${options.defaultPath}" instead of "${extractPath}"`);
+					}
+					extractPath = options.defaultPath;
+				}
+
+				if (debug) {
+					if (targets) {
+						console.error(`Executing extract with targets: "${targets}", path: "${extractPath}", context lines: ${context_lines || 10}`);
+					} else if (input_content) {
+						console.error(`Executing extract with input content, path: "${extractPath}", context lines: ${context_lines || 10}`);
+					}
+				}
+
+				// Create a temporary file for input content if provided
+				let tempFilePath = null;
+				let extractOptions = { path: extractPath };
+
+				if (input_content) {
+					// Import required modules
+					const { writeFileSync, unlinkSync } = await import('fs');
+					const { join } = await import('path');
+					const { tmpdir } = await import('os');
+					const { randomUUID } = await import('crypto');
+
+					// Create a temporary file with the input content
+					tempFilePath = join(tmpdir(), `probe-extract-${randomUUID()}.txt`);
+					writeFileSync(tempFilePath, input_content);
+
+					if (debug) {
+						console.error(`Created temporary file for input content: ${tempFilePath}`);
+					}
+
+					// Apply format mapping for outline-xml to xml
+					let effectiveFormat = format;
+					if (outline && format === 'outline-xml') {
+						effectiveFormat = 'xml';
+					}
+
+					// Set up extract options with input file
+					extractOptions = {
+						inputFile: tempFilePath,
+						allowTests: allow_tests,
+						contextLines: context_lines,
+						format: effectiveFormat
+					};
+				} else if (targets) {
+					// Parse targets to handle line numbers and symbol names
+					const files = [targets];
+
+					// Apply format mapping for outline-xml to xml
+					let effectiveFormat = format;
+					if (outline && format === 'outline-xml') {
+						effectiveFormat = 'xml';
+					}
+
+					// Set up extract options with files
+					extractOptions = {
+						files,
+						allowTests: allow_tests,
+						contextLines: context_lines,
+						format: effectiveFormat
+					};
+				} else {
+					throw new Error('Either targets or input_content must be provided');
+				}
+
+				// Execute the extract command
+				const results = await extract(extractOptions);
+
+				// Clean up temporary file if created
+				if (tempFilePath) {
+					const { unlinkSync } = await import('fs');
+					try {
+						unlinkSync(tempFilePath);
+						if (debug) {
+							console.error(`Removed temporary file: ${tempFilePath}`);
+						}
+					} catch (cleanupError) {
+						console.error(`Warning: Failed to remove temporary file: ${cleanupError.message}`);
+					}
+				}
+
+				return results;
+			} catch (error) {
+				console.error('Error executing extract command:', error);
+				return `Error executing extract command: ${error.message}`;
+			}
+		}
+	});
+};
+
+/**
+ * Delegate tool generator
+ * 
+ * @param {Object} [options] - Configuration options
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @param {number} [options.timeout=300] - Default timeout in seconds
+ * @returns {Object} Configured delegate tool
+ */
+export const delegateTool = (options = {}) => {
+	const { debug = false, timeout = 300 } = options;
+
+	return tool({
+		name: 'delegate',
+		description: delegateDescription,
+		inputSchema: delegateSchema,
+		execute: async ({ task }) => {
+			try {
+				if (debug) {
+					console.error(`Executing delegate with task: "${task}"`);
+				}
+
+				const result = await delegate({
+					task,
+					timeout,
+					debug
+				});
+
+				return result;
+			} catch (error) {
+				console.error('Error executing delegate command:', error);
+				return `Error executing delegate command: ${error.message}`;
+			}
+		}
+	});
+};

package/build/utils/file-lister.js

@@ -0,0 +1,193 @@
+/**
+ * File listing utility for the probe package
+ * @module utils/file-lister
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+
+const execAsync = promisify(exec);
+
+/**
+ * List files in a directory by nesting level, respecting .gitignore
+ * 
+ * @param {Object} options - Options for listing files
+ * @param {string} options.directory - Directory to list files from
+ * @param {number} [options.maxFiles=100] - Maximum number of files to return
+ * @param {boolean} [options.respectGitignore=true] - Whether to respect .gitignore
+ * @returns {Promise<string[]>} - Array of file paths
+ */
+export async function listFilesByLevel(options) {
+	const {
+		directory,
+		maxFiles = 100,
+		respectGitignore = true
+	} = options;
+
+	// Check if directory exists
+	if (!fs.existsSync(directory)) {
+		throw new Error(`Directory does not exist: ${directory}`);
+	}
+
+	// Use git ls-files if .git directory exists and respectGitignore is true
+	const gitDirExists = fs.existsSync(path.join(directory, '.git'));
+	if (gitDirExists && respectGitignore) {
+		try {
+			return await listFilesUsingGit(directory, maxFiles);
+		} catch (error) {
+			console.error(`Warning: Failed to use git ls-files: ${error.message}`);
+			console.error('Falling back to manual file listing');
+		}
+	}
+
+	// Fall back to manual file listing
+	return await listFilesByLevelManually(directory, maxFiles, respectGitignore);
+}
+
+/**
+ * List files using git ls-files (respects .gitignore by default)
+ * 
+ * @param {string} directory - Directory to list files from
+ * @param {number} maxFiles - Maximum number of files to return
+ * @returns {Promise<string[]>} - Array of file paths
+ */
+async function listFilesUsingGit(directory, maxFiles) {
+	// Use git ls-files to get tracked files (respects .gitignore)
+	const { stdout } = await execAsync('git ls-files', { cwd: directory });
+
+	// Split output into lines and filter out empty lines
+	const files = stdout.split('\n').filter(Boolean);
+
+	// Sort files by directory depth (breadth-first)
+	const sortedFiles = files.sort((a, b) => {
+		const depthA = a.split(path.sep).length;
+		const depthB = b.split(path.sep).length;
+		return depthA - depthB;
+	});
+
+	// Limit to maxFiles
+	return sortedFiles.slice(0, maxFiles);
+}
+
+/**
+ * List files manually by nesting level
+ * 
+ * @param {string} directory - Directory to list files from
+ * @param {number} maxFiles - Maximum number of files to return
+ * @param {boolean} respectGitignore - Whether to respect .gitignore
+ * @returns {Promise<string[]>} - Array of file paths
+ */
+async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
+	// Load .gitignore patterns if needed
+	let ignorePatterns = [];
+	if (respectGitignore) {
+		ignorePatterns = loadGitignorePatterns(directory);
+	}
+
+	// Initialize result array
+	const result = [];
+
+	// Initialize queue with root directory
+	const queue = [{ dir: directory, level: 0 }];
+
+	// Process queue (breadth-first)
+	while (queue.length > 0 && result.length < maxFiles) {
+		const { dir, level } = queue.shift();
+
+		try {
+			// Read directory contents
+			const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+			// Process files first (at current level)
+			const files = entries.filter(entry => entry.isFile());
+			for (const file of files) {
+				if (result.length >= maxFiles) break;
+
+				const filePath = path.join(dir, file.name);
+				const relativePath = path.relative(directory, filePath);
+
+				// Skip if file matches any ignore pattern
+				if (shouldIgnore(relativePath, ignorePatterns)) continue;
+
+				result.push(relativePath);
+			}
+
+			// Then add directories to queue for next level
+			const dirs = entries.filter(entry => entry.isDirectory());
+			for (const subdir of dirs) {
+				const subdirPath = path.join(dir, subdir.name);
+				const relativeSubdirPath = path.relative(directory, subdirPath);
+
+				// Skip if directory matches any ignore pattern
+				if (shouldIgnore(relativeSubdirPath, ignorePatterns)) continue;
+
+				// Skip node_modules and .git directories
+				if (subdir.name === 'node_modules' || subdir.name === '.git') continue;
+
+				queue.push({ dir: subdirPath, level: level + 1 });
+			}
+		} catch (error) {
+			console.error(`Warning: Could not read directory ${dir}: ${error.message}`);
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Load .gitignore patterns from a directory
+ * 
+ * @param {string} directory - Directory to load .gitignore from
+ * @returns {string[]} - Array of ignore patterns
+ */
+function loadGitignorePatterns(directory) {
+	const gitignorePath = path.join(directory, '.gitignore');
+
+	if (!fs.existsSync(gitignorePath)) {
+		return [];
+	}
+
+	try {
+		const content = fs.readFileSync(gitignorePath, 'utf8');
+		return content
+			.split('\n')
+			.map(line => line.trim())
+			.filter(line => line && !line.startsWith('#'));
+	} catch (error) {
+		console.error(`Warning: Could not read .gitignore: ${error.message}`);
+		return [];
+	}
+}
+
+/**
+ * Check if a file path should be ignored based on ignore patterns
+ * 
+ * @param {string} filePath - File path to check
+ * @param {string[]} ignorePatterns - Array of ignore patterns
+ * @returns {boolean} - Whether the file should be ignored
+ */
+function shouldIgnore(filePath, ignorePatterns) {
+	if (!ignorePatterns.length) return false;
+
+	// Simple pattern matching (could be improved with minimatch or similar)
+	for (const pattern of ignorePatterns) {
+		// Exact match
+		if (pattern === filePath) return true;
+
+		// Directory match (pattern ends with /)
+		if (pattern.endsWith('/') && filePath.startsWith(pattern)) return true;
+
+		// File extension match (pattern starts with *.)
+		if (pattern.startsWith('*.') && filePath.endsWith(pattern.substring(1))) return true;
+
+		// Wildcard at start (pattern starts with *)
+		if (pattern.startsWith('*') && filePath.endsWith(pattern.substring(1))) return true;
+
+		// Wildcard at end (pattern ends with *)
+		if (pattern.endsWith('*') && filePath.startsWith(pattern.substring(0, pattern.length - 1))) return true;
+	}
+
+	return false;
+}

package/build/utils.js

@@ -0,0 +1,128 @@
+/**
+ * Utility functions for the probe package
+ * @module utils
+ */
+
+import path from 'path';
+import fs from 'fs-extra';
+import { fileURLToPath } from 'url';
+import { downloadProbeBinary } from './downloader.js';
+import { getPackageBinDir } from './directory-resolver.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Note: binDir is now resolved dynamically using getPackageBinDir()
+
+// Store the binary path
+let probeBinaryPath = '';
+
+/**
+ * Get the path to the probe binary, downloading it if necessary
+ * @param {Object} options - Options for getting the binary
+ * @param {boolean} [options.forceDownload=false] - Force download even if binary exists
+ * @param {string} [options.version] - Specific version to download
+ * @returns {Promise<string>} - Path to the binary
+ */
+export async function getBinaryPath(options = {}) {
+	const { forceDownload = false, version } = options;
+
+	// Return cached path if available and not forcing download
+	if (probeBinaryPath && !forceDownload && fs.existsSync(probeBinaryPath)) {
+		return probeBinaryPath;
+	}
+
+	// Check environment variable
+	if (process.env.PROBE_PATH && fs.existsSync(process.env.PROBE_PATH) && !forceDownload) {
+		probeBinaryPath = process.env.PROBE_PATH;
+		return probeBinaryPath;
+	}
+
+	// Get dynamic bin directory (handles CI, npx, Docker scenarios)
+	const binDir = await getPackageBinDir();
+	
+	// Check bin directory
+	const isWindows = process.platform === 'win32';
+	const binaryName = isWindows ? 'probe.exe' : 'probe';
+	const binaryPath = path.join(binDir, binaryName);
+
+	if (fs.existsSync(binaryPath) && !forceDownload) {
+		probeBinaryPath = binaryPath;
+		return probeBinaryPath;
+	}
+
+	// Download if not found or force download
+	console.log(`${forceDownload ? 'Force downloading' : 'Binary not found. Downloading'} probe binary...`);
+	probeBinaryPath = await downloadProbeBinary(version);
+	return probeBinaryPath;
+}
+
+/**
+ * Manually set the path to the probe binary
+ * @param {string} binaryPath - Path to the probe binary
+ * @throws {Error} If the binary doesn't exist at the specified path
+ */
+export function setBinaryPath(binaryPath) {
+	if (!fs.existsSync(binaryPath)) {
+		throw new Error(`No binary found at path: ${binaryPath}`);
+	}
+
+	probeBinaryPath = binaryPath;
+}
+
+/**
+ * Ensure the bin directory exists
+ * @returns {Promise<void>}
+ */
+export async function ensureBinDirectory() {
+	// This function is now handled by getPackageBinDir() which ensures directory exists
+	// Keeping for backward compatibility but it's no longer needed
+	const binDir = await getPackageBinDir();
+	await fs.ensureDir(binDir);
+}
+
+/**
+ * Build command-line arguments from an options object
+ * @param {Object} options - Options object
+ * @param {Array<string>} flagMap - Map of option keys to command-line flags
+ * @returns {Array<string>} - Array of command-line arguments
+ */
+export function buildCliArgs(options, flagMap) {
+	const cliArgs = [];
+
+	for (const [key, flag] of Object.entries(flagMap)) {
+		if (key in options) {
+			const value = options[key];
+
+			if (typeof value === 'boolean') {
+				if (value) {
+					cliArgs.push(flag);
+				}
+			} else if (Array.isArray(value)) {
+				for (const item of value) {
+					cliArgs.push(flag, item);
+				}
+			} else if (value !== undefined && value !== null) {
+				cliArgs.push(flag, value.toString());
+			}
+		}
+	}
+
+	return cliArgs;
+}
+
+/**
+ * Escape a string for use in a command line
+ * @param {string} str - String to escape
+ * @returns {string} - Escaped string
+ */
+export function escapeString(str) {
+  if (process.platform === 'win32') {
+    // For Windows PowerShell, escape double quotes and wrap with double quotes
+    return `"${str.replace(/"/g, '\\"')}"`;
+  } else {
+    // Use single quotes for POSIX shells
+    // Escape single quotes in the string by replacing ' with '\''
+    return `'${str.replace(/'/g, "'\\''")}'`;
+  }
+}