@probelabs/probe 0.6.0-rc100

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/index.d.ts

@@ -0,0 +1,401 @@
+// TypeScript definitions for ProbeAgent SDK
+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;
+
+  /**
+   * 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;
+}
+
+/**
+ * Search tool configuration options
+ */
+export interface SearchOptions {
+  /** Session identifier */
+  sessionId?: string;
+  /** Debug mode */
+  debug?: boolean;
+  /** Default search path */
+  defaultPath?: string;
+  /** Allowed search folders */
+  allowedFolders?: string[];
+}
+
+/**
+ * Search parameters
+ */
+export interface SearchParams {
+  /** Search query */
+  query: string;
+  /** Path to search in */
+  path?: string;
+  /** Maximum number of results */
+  maxResults?: number;
+  /** Search timeout in seconds */
+  timeout?: number;
+  /** Allow test files in results */
+  allowTests?: boolean;
+  /** Session ID */
+  sessionId?: string;
+}
+
+/**
+ * Query tool parameters for structural code search
+ */
+export interface QueryParams {
+  /** AST-grep pattern */
+  pattern: string;
+  /** Path to search in */
+  path?: string;
+  /** Programming language */
+  language?: string;
+  /** Maximum number of results */
+  maxResults?: number;
+  /** Session ID */
+  sessionId?: string;
+}
+
+/**
+ * Extract tool parameters
+ */
+export interface ExtractParams {
+  /** Files and line numbers or symbols to extract */
+  files: string[];
+  /** Path to search in */
+  path?: string;
+  /** Number of context lines */
+  contextLines?: number;
+  /** Output format */
+  format?: 'markdown' | 'plain' | 'json';
+  /** Session ID */
+  sessionId?: string;
+}
+
+/**
+ * Tool execution result
+ */
+export interface ToolResult {
+  /** Whether the operation was successful */
+  success: boolean;
+  /** Result data */
+  result?: any;
+  /** Error message if failed */
+  error?: string;
+  /** Execution metadata */
+  metadata?: any;
+}
+
+/**
+ * Search tool function type
+ */
+export type SearchTool = (options?: SearchOptions) => {
+  execute(params: SearchParams): Promise<ToolResult>;
+};
+
+/**
+ * Query tool function type
+ */
+export type QueryTool = (options?: SearchOptions) => {
+  execute(params: QueryParams): Promise<ToolResult>;
+};
+
+/**
+ * Extract tool function type
+ */
+export type ExtractTool = (options?: SearchOptions) => {
+  execute(params: ExtractParams): Promise<ToolResult>;
+};
+
+/**
+ * Main probe search function
+ */
+export declare function search(
+  query: string,
+  path?: string,
+  options?: {
+    maxResults?: number;
+    timeout?: number;
+    allowTests?: boolean;
+  }
+): Promise<any>;
+
+/**
+ * Structural code query using ast-grep
+ */
+export declare function query(
+  pattern: string,
+  path?: string,
+  options?: {
+    language?: string;
+    maxResults?: number;
+  }
+): Promise<any>;
+
+/**
+ * Extract code blocks from files
+ */
+export declare function extract(
+  files: string[],
+  path?: string,
+  options?: {
+    contextLines?: number;
+    format?: 'markdown' | 'plain' | 'json';
+  }
+): Promise<any>;
+
+/**
+ * Create search tool instance
+ */
+export declare function searchTool(options?: SearchOptions): ReturnType<SearchTool>;
+
+/**
+ * Create query tool instance
+ */
+export declare function queryTool(options?: SearchOptions): ReturnType<QueryTool>;
+
+/**
+ * Create extract tool instance
+ */
+export declare function extractTool(options?: SearchOptions): ReturnType<ExtractTool>;
+
+/**
+ * Get the path to the probe binary
+ */
+export declare function getBinaryPath(): string;
+
+/**
+ * Set the path to the probe binary
+ */
+export declare function setBinaryPath(path: string): void;
+
+/**
+ * List files by directory level
+ */
+export declare function listFilesByLevel(
+  path?: string,
+  options?: {
+    maxLevel?: number;
+    includeHidden?: boolean;
+  }
+): Promise<any>;
+
+/**
+ * Default system message for AI interactions
+ */
+export declare const DEFAULT_SYSTEM_MESSAGE: string;
+
+/**
+ * Schema definitions
+ */
+export declare const searchSchema: any;
+export declare const querySchema: any;
+export declare const extractSchema: any;
+export declare const attemptCompletionSchema: any;
+
+/**
+ * Tool definitions for AI frameworks
+ */
+export declare const searchToolDefinition: any;
+export declare const queryToolDefinition: any;
+export declare const extractToolDefinition: any;
+export declare const attemptCompletionToolDefinition: any;
+
+/**
+ * Parse XML tool calls
+ */
+export declare function parseXmlToolCall(xmlString: string): any;
+
+/**
+ * Legacy tools object (deprecated - use individual tool functions instead)
+ * @deprecated Use searchTool, queryTool, extractTool functions instead
+ */
+export declare const tools: {
+  search: ReturnType<SearchTool>;
+  query: ReturnType<QueryTool>;
+  extract: ReturnType<ExtractTool>;
+};
+
+/**
+ * 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 for ES modules
+export { ProbeAgent as default };

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "@probelabs/probe",
+  "version": "0.6.0-rc100",
+  "description": "Node.js wrapper for the probe code search tool",
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./src/index.js",
+      "require": "./cjs/index.cjs"
+    },
+    "./agent": {
+      "types": "./src/agent/ProbeAgent.d.ts",
+      "import": "./src/agent/ProbeAgent.js",
+      "require": "./cjs/agent/ProbeAgent.cjs"
+    },
+    "./telemetry": {
+      "import": "./src/agent/simpleTelemetry.js",
+      "require": "./cjs/agent/simpleTelemetry.cjs"
+    },
+    "./agent/mcp": {
+      "import": "./src/agent/mcp/index.js"
+    }
+  },
+  "bin": {
+    "probe": "bin/probe"
+  },
+  "files": [
+    "src/**/*",
+    "cjs/**/*",
+    "*.d.ts",
+    "src/**/*.d.ts",
+    "bin/probe",
+    "bin/probe-binary",
+    "bin/probe.exe",
+    "bin/.gitkeep",
+    "scripts/postinstall.js",
+    "build/**/*",
+    "MERMAID_SUPPORT_SUMMARY.md",
+    "GITHUB_MERMAID_COMPATIBILITY.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "build:mcp": "node scripts/build-mcp.cjs",
+    "build:agent": "node scripts/build-agent.cjs",
+    "build:types": "echo 'TypeScript definitions already manually created'",
+    "build:cjs": "node scripts/build-cjs.js",
+    "build": "npm run build:types && npm run build:cjs && npm run build:mcp && npm run build:agent",
+    "prepack": "npm run build",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --watch",
+    "test:coverage": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+    "test:verbose": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --verbose"
+  },
+  "keywords": [
+    "probe",
+    "code-search",
+    "search",
+    "ast",
+    "code-analysis",
+    "ai",
+    "llm",
+    "tools"
+  ],
+  "author": "probelabs",
+  "license": "ISC",
+  "dependencies": {
+    "@ai-sdk/anthropic": "^2.0.8",
+    "@ai-sdk/google": "^2.0.14",
+    "@ai-sdk/openai": "^2.0.10",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^1.30.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.203.0",
+    "@opentelemetry/resources": "^2.0.1",
+    "@opentelemetry/sdk-node": "^0.203.0",
+    "@opentelemetry/sdk-trace-base": "^1.30.0",
+    "@opentelemetry/semantic-conventions": "^1.36.0",
+    "ai": "^5.0.0",
+    "axios": "^1.8.3",
+    "fs-extra": "^11.1.1",
+    "dotenv": "^16.4.7",
+    "glob": "^10.3.10",
+    "tar": "^6.2.0",
+    "tiktoken": "^1.0.20",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.17.19",
+    "cross-env": "^7.0.3",
+    "esbuild": "^0.25.9",
+    "jest": "^29.7.0",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "ai": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=14.16.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/probelabs/probe.git"
+  },
+  "bugs": {
+    "url": "https://github.com/probelabs/probe/issues"
+  },
+  "homepage": "https://github.com/probelabs/probe#readme"
+}

package/scripts/postinstall.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script for the probe package
+ * 
+ * This script is executed after the package is installed.
+ * It downloads the probe binary and replaces the placeholder binary with the actual one.
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { downloadProbeBinary } from '../src/downloader.js';
+
+// Get the directory of the current module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Path to the bin directory (relative to this script)
+const binDir = path.resolve(__dirname, '..', 'bin');
+
+/**
+ * Main function
+ */
+async function main() {
+	try {
+		// Skip postinstall if binary already exists (for CI or development)
+		const isWindows = process.platform === 'win32';
+		const targetBinaryName = isWindows ? 'probe.exe' : 'probe-binary';
+		const targetBinaryPath = path.join(binDir, targetBinaryName);
+		
+		if (await fs.pathExists(targetBinaryPath)) {
+			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+				console.log(`Probe binary already exists at ${targetBinaryPath}, skipping download`);
+			}
+			return;
+		}
+
+		// Create the bin directory if it doesn't exist
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log(`Creating bin directory at: ${binDir}`);
+		}
+		await fs.ensureDir(binDir);
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log('Bin directory created successfully');
+		}
+
+		// Create a README file in the bin directory
+		const readmePath = path.join(binDir, 'README.md');
+		const readmeContent = `# Probe Binary Directory
+
+This directory is used to store the downloaded probe binary.
+
+The binary is automatically downloaded during package installation.
+If you encounter any issues with the download, you can manually place the probe binary in this directory.
+
+Binary name should be:
+- \`probe\` (on Linux/macOS)
+- \`probe.exe\` (on Windows)
+
+You can download the binary from: https://github.com/probelabs/probe/releases
+`;
+
+		await fs.writeFile(readmePath, readmeContent);
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log('Created README file in bin directory');
+		}
+
+		// Create a .gitignore file to ignore binaries but keep the directory
+		const gitignorePath = path.join(binDir, '.gitignore');
+		const gitignoreContent = `# Ignore all files in this directory
+*
+# Except these files
+!.gitignore
+!.gitkeep
+!README.md
+!probe
+`;
+
+		await fs.writeFile(gitignorePath, gitignoreContent);
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log('Created .gitignore file in bin directory');
+		}
+
+		// Download the probe binary
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log('Downloading probe binary...');
+		}
+		try {
+			// Try to get the package version
+			let packageVersion = '0.0.0';
+			const possiblePaths = [
+				path.resolve(__dirname, '..', 'package.json'),      // When installed from npm: scripts/../package.json
+				path.resolve(__dirname, '..', '..', 'package.json') // In development: scripts/../../package.json
+			];
+
+			for (const packageJsonPath of possiblePaths) {
+				try {
+					if (fs.existsSync(packageJsonPath)) {
+						if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+							console.log(`Found package.json at: ${packageJsonPath}`);
+						}
+						const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+						if (packageJson.version) {
+							packageVersion = packageJson.version;
+							if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+								console.log(`Using version from package.json: ${packageVersion}`);
+							}
+							break;
+						}
+					}
+				} catch (err) {
+					console.error(`Error reading package.json at ${packageJsonPath}:`, err);
+				}
+			}
+
+			// Download the binary (it will be placed at the correct location automatically)
+			const binaryPath = await downloadProbeBinary(packageVersion);
+			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+				console.log(`Successfully downloaded probe binary to: ${binaryPath}`);
+			}
+
+			// Get the path to the target binary (preserve the Node.js wrapper script)
+			// (variables already declared at the beginning of main function)
+
+			// Copy the downloaded binary to the correct location
+			if (binaryPath !== targetBinaryPath) {
+				if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+					console.log(`Copying binary to ${targetBinaryPath} from ${binaryPath}`);
+				}
+				await fs.copyFile(binaryPath, targetBinaryPath);
+				await fs.chmod(targetBinaryPath, 0o755); // Make it executable
+			}
+
+			// On macOS, try to remove quarantine attributes that might prevent execution
+			if (process.platform === 'darwin') {
+				try {
+					await exec(`xattr -d com.apple.quarantine "${targetBinaryPath}" 2>/dev/null || true`);
+					if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+						console.log('Removed quarantine attributes from binary');
+					}
+				} catch (error) {
+					// Ignore errors - this is just a precaution
+					if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+						console.log('Note: Could not remove quarantine attributes (this is usually fine)');
+					}
+				}
+			}
+
+			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+				console.log('\nProbe binary was successfully downloaded and installed during installation.');
+				console.log('You can now use the probe command directly from the command line.');
+			}
+		} catch (error) {
+			console.error('Error downloading probe binary:', error);
+			console.error('\nNote: The probe binary will need to be downloaded when you first use the package.');
+			console.error('If you encounter any issues, you can manually place the binary in the bin directory.');
+			console.error('You can download it from: https://github.com/probelabs/probe/releases');
+
+			// Don't fail the installation, just warn the user
+			return;
+		}
+	} catch (error) {
+		console.error(`Error in postinstall script: ${error.message}`);
+		console.error('You may need to manually create the bin directory or run with elevated privileges.');
+	}
+}
+
+// Execute the main function
+main().catch(error => {
+	console.error('Unexpected error during postinstall:', error);
+});