@probelabs/probe 0.6.0-rc100

package/bin/probe

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { access, constants } from 'fs';
+import { promisify } from 'util';
+
+const accessAsync = promisify(access);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Check if a file exists and is executable
+ */
+async function isExecutable(filePath) {
+  try {
+    await accessAsync(filePath, constants.F_OK | constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Attempt to download the binary if it's missing
+ */
+async function ensureBinary(binaryPath) {
+  try {
+    // Try to import the downloader and download the binary
+    const { downloadProbeBinary } = await import('../src/downloader.js');
+    console.log('Probe binary not found, downloading...');
+    await downloadProbeBinary();
+    
+    // Check if the binary now exists and is executable
+    if (await isExecutable(binaryPath)) {
+      console.log('Binary downloaded successfully.');
+      
+      // On macOS, try to remove quarantine attributes that might prevent execution
+      if (process.platform === 'darwin') {
+        try {
+          const { exec } = await import('child_process');
+          const { promisify } = await import('util');
+          const execAsync = promisify(exec);
+          await execAsync(`xattr -d com.apple.quarantine "${binaryPath}" 2>/dev/null || true`);
+        } catch {
+          // Ignore errors - this is just a precaution
+        }
+      }
+      
+      return true;
+    } else {
+      console.error('Binary downloaded but is not executable.');
+      return false;
+    }
+  } catch (error) {
+    console.error('Failed to download binary:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Spawn the probe binary with proper error handling
+ */
+async function spawnProbeBinary(binaryPath, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(binaryPath, args, { stdio: 'inherit' });
+    
+    child.on('error', async (error) => {
+      // Handle spawn errors, particularly the dreaded "spawn Unknown system error -8"
+      if (error.code === 'ENOENT') {
+        console.error(`Error: Binary not found at ${binaryPath}`);
+        process.exit(1);
+      } else if (error.code === 'EACCES' || error.message.includes('spawn') || error.errno === -8) {
+        console.error(`Error: Cannot execute binary at ${binaryPath}`);
+        console.error('This might be due to:');
+        console.error('1. Missing execute permissions');
+        console.error('2. Architecture mismatch');
+        console.error('3. Corrupted binary file');
+        console.error('');
+        console.error('Attempting to re-download the binary...');
+        
+        const downloadSuccess = await ensureBinary(binaryPath);
+        if (downloadSuccess) {
+          // Retry execution after download
+          try {
+            const retryChild = spawn(binaryPath, args, { stdio: 'inherit' });
+            retryChild.on('exit', (code) => resolve(code || 0));
+            retryChild.on('error', (retryError) => {
+              console.error('Failed to execute binary even after re-download:', retryError.message);
+              reject(retryError);
+            });
+          } catch (retryError) {
+            console.error('Failed to retry execution:', retryError.message);
+            reject(retryError);
+          }
+        } else {
+          reject(error);
+        }
+      } else {
+        console.error('Unexpected error:', error.message);
+        reject(error);
+      }
+    });
+    
+    child.on('exit', (code) => resolve(code || 0));
+  });
+}
+
+// Main execution logic
+async function main() {
+  try {
+    // Check if first argument is 'mcp'
+    if (process.argv[2] === 'mcp') {
+      // Launch MCP server instead of binary
+      const mcpPath = join(__dirname, '..', 'build', 'mcp', 'index.js');
+      const mcpArgs = process.argv.slice(3); // Remove 'node', 'probe', and 'mcp'
+      
+      const child = spawn('node', [mcpPath, ...mcpArgs], { stdio: 'inherit' });
+      child.on('exit', (code) => process.exit(code || 0));
+    } else if (process.argv[2] === 'agent') {
+      // Launch Agent server instead of binary
+      const agentPath = join(__dirname, '..', 'src', 'agent', 'index.js');
+      const agentArgs = process.argv.slice(3); // Remove 'node', 'probe', and 'agent'
+      
+      const child = spawn('node', [agentPath, ...agentArgs], { stdio: 'inherit' });
+      child.on('exit', (code) => process.exit(code || 0));
+    } else {
+      // Normal probe binary execution
+      const isWindows = process.platform === 'win32';
+      const binaryName = isWindows ? 'probe.exe' : 'probe-binary';
+      const binaryPath = join(__dirname, binaryName);
+      
+      // Check if binary exists and is executable
+      if (!(await isExecutable(binaryPath))) {
+        console.log('Probe binary not found or not executable, attempting to download...');
+        const downloadSuccess = await ensureBinary(binaryPath);
+        if (!downloadSuccess) {
+          console.error('Failed to download probe binary. Please try installing again or check your internet connection.');
+          process.exit(1);
+        }
+      }
+      
+      // Execute the binary
+      const exitCode = await spawnProbeBinary(binaryPath, process.argv.slice(2));
+      process.exit(exitCode);
+    }
+  } catch (error) {
+    console.error('Unexpected error in probe wrapper:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run the main function
+main().catch(error => {
+  console.error('Fatal error:', error.message);
+  process.exit(1);
+});

package/build/agent/ProbeAgent.d.ts

@@ -0,0 +1,199 @@
+// TypeScript definitions for ProbeAgent class
+import { EventEmitter } from 'events';
+
+/**
+ * Configuration options for creating a ProbeAgent instance
+ */
+export interface ProbeAgentOptions {
+  /** Optional session ID for the agent */
+  sessionId?: string;
+  /** Custom system prompt to replace the default system message */
+  customPrompt?: string;
+  /** Predefined prompt type (persona) */
+  promptType?: 'code-explorer' | 'engineer' | 'code-review' | 'support' | 'architect';
+  /** Allow the use of the 'implement' tool for code editing */
+  allowEdit?: boolean;
+  /** Search directory path */
+  path?: string;
+  /** Force specific AI provider */
+  provider?: 'anthropic' | 'openai' | 'google';
+  /** Override model name */
+  model?: string;
+  /** Enable debug mode */
+  debug?: boolean;
+  /** Optional telemetry tracer instance */
+  tracer?: any;
+  /** Enable MCP (Model Context Protocol) tool integration */
+  enableMcp?: boolean;
+  /** Path to MCP configuration file */
+  mcpConfigPath?: string;
+  /** MCP configuration object (overrides mcpConfigPath) */
+  mcpConfig?: any;
+  /** @deprecated Use mcpConfig instead */
+  mcpServers?: any[];
+}
+
+/**
+ * Tool execution event data
+ */
+export interface ToolCallEvent {
+  /** Unique tool call identifier */
+  id: string;
+  /** Name of the tool being called */
+  name: string;
+  /** Current execution status */
+  status: 'pending' | 'in_progress' | 'completed' | 'failed';
+  /** Tool parameters */
+  params?: any;
+  /** Tool execution result (when completed) */
+  result?: any;
+  /** Error information (when failed) */
+  error?: string;
+  /** Session ID */
+  sessionId?: string;
+  /** Execution start time */
+  startTime?: number;
+  /** Execution end time */
+  endTime?: number;
+  /** Execution duration in milliseconds */
+  duration?: number;
+}
+
+/**
+ * Token usage statistics
+ */
+export interface TokenUsage {
+  /** Size of the context window */
+  contextWindow?: number;
+  /** Request tokens used */
+  request?: number;
+  /** Response tokens generated */
+  response?: number;
+  /** Total tokens (request + response) */
+  total?: number;
+  /** Cache read tokens */
+  cacheRead?: number;
+  /** Cache write tokens */
+  cacheWrite?: number;
+  /** Total request tokens across all calls */
+  totalRequest?: number;
+  /** Total response tokens across all calls */
+  totalResponse?: number;
+  /** Total tokens across all calls */
+  totalTokens?: number;
+  /** Total cache read tokens across all calls */
+  totalCacheRead?: number;
+  /** Total cache write tokens across all calls */
+  totalCacheWrite?: number;
+}
+
+/**
+ * Chat message structure
+ */
+export interface ChatMessage {
+  /** Message role */
+  role: 'user' | 'assistant' | 'system';
+  /** Message content */
+  content: string;
+  /** Optional message metadata */
+  metadata?: any;
+}
+
+/**
+ * Answer options
+ */
+export interface AnswerOptions {
+  /** Response schema for structured output */
+  schema?: string;
+  /** Additional context or constraints */
+  context?: string;
+  /** Maximum number of tool iterations */
+  maxIterations?: number;
+}
+
+/**
+ * ProbeAgent class - AI-powered code exploration and interaction
+ */
+export declare class ProbeAgent {
+  /** Unique session identifier */
+  readonly sessionId: string;
+  
+  /** Current chat history */
+  history: ChatMessage[];
+  
+  /** Event emitter for tool execution updates */
+  readonly events: EventEmitter & ProbeAgentEvents;
+  
+  /** Whether the agent allows code editing */
+  readonly allowEdit: boolean;
+  
+  /** Allowed search folders */
+  readonly allowedFolders: string[];
+  
+  /** Debug mode status */
+  readonly debug: boolean;
+  
+  /** Whether operations have been cancelled */
+  cancelled: boolean;
+
+  /** AI provider being used */
+  readonly clientApiProvider?: string;
+  
+  /** Current AI model */
+  readonly model?: string;
+
+  /**
+   * Create a new ProbeAgent instance
+   */
+  constructor(options?: ProbeAgentOptions);
+
+  /**
+   * Answer a question with optional image attachments
+   * @param message - The question or prompt
+   * @param images - Optional array of image data or paths
+   * @param options - Additional options for the response
+   * @returns Promise resolving to the AI response
+   */
+  answer(message: string, images?: any[], options?: AnswerOptions): Promise<string>;
+
+  /**
+   * Get token usage statistics
+   * @returns Current token usage information
+   */
+  getTokenUsage(): TokenUsage;
+
+  /**
+   * Cancel any ongoing operations
+   */
+  cancel(): void;
+
+  /**
+   * Clear the conversation history
+   */
+  clearHistory(): void;
+
+  /**
+   * Add a message to the conversation history
+   * @param message - Message to add
+   */
+  addMessage(message: ChatMessage): void;
+
+  /**
+   * Set the conversation history
+   * @param messages - Array of chat messages
+   */
+  setHistory(messages: ChatMessage[]): void;
+}
+
+/**
+ * ProbeAgent Events interface
+ */
+export interface ProbeAgentEvents {
+  on(event: 'toolCall', listener: (event: ToolCallEvent) => void): this;
+  emit(event: 'toolCall', event: ToolCallEvent): boolean;
+  removeListener(event: 'toolCall', listener: (event: ToolCallEvent) => void): this;
+  removeAllListeners(event?: 'toolCall'): this;
+}
+
+// Default export
+export { ProbeAgent as default };