@probelabs/probe-chat 0.6.0-rc100

package/auth.js

@@ -0,0 +1,76 @@
+import 'dotenv/config';
+
+/**
+ * Basic authentication middleware
+ * Checks for valid username and password in the Authorization header
+ * Can be enabled/disabled via environment variables
+ */
+export function authMiddleware(req, res, next) {
+	// Check if authentication is enabled
+	const AUTH_ENABLED = process.env.AUTH_ENABLED === '1';
+
+	// If authentication is not enabled, skip authentication check
+	if (!AUTH_ENABLED) {
+		return next(req, res);
+	}
+
+	// Get configured username and password from environment variables
+	const AUTH_USERNAME = process.env.AUTH_USERNAME || 'admin';
+	const AUTH_PASSWORD = process.env.AUTH_PASSWORD || 'password';
+
+	// Check if request has Authorization header
+	const authHeader = req.headers.authorization;
+
+	if (!authHeader) {
+		// No Authorization header, return 401 Unauthorized
+		res.writeHead(401, {
+			'Content-Type': 'text/plain',
+			'WWW-Authenticate': 'Basic realm="Probe Code Search"'
+		});
+		res.end('Authentication required');
+		return;
+	}
+
+	// Parse Authorization header
+	try {
+		// Basic auth format: "Basic base64(username:password)"
+		const authParts = authHeader.split(' ');
+		if (authParts.length !== 2 || authParts[0] !== 'Basic') {
+			throw new Error('Invalid Authorization header format');
+		}
+
+		// Decode base64 credentials
+		const credentials = Buffer.from(authParts[1], 'base64').toString('utf-8');
+		const [username, password] = credentials.split(':');
+
+		// Check if credentials match
+		if (username === AUTH_USERNAME && password === AUTH_PASSWORD) {
+			// Authentication successful, proceed to next middleware
+			return next(req, res);
+		} else {
+			// Invalid credentials, return 401 Unauthorized
+			res.writeHead(401, {
+				'Content-Type': 'text/plain',
+				'WWW-Authenticate': 'Basic realm="Probe Code Search"'
+			});
+			res.end('Invalid credentials');
+			return;
+		}
+	} catch (error) {
+		// Error parsing Authorization header, return 400 Bad Request
+		res.writeHead(400, { 'Content-Type': 'text/plain' });
+		res.end('Invalid Authorization header');
+		return;
+	}
+}
+
+/**
+ * Apply authentication middleware to a request handler
+ * @param {Function} handler - The request handler function
+ * @returns {Function} - A new handler function with authentication
+ */
+export function withAuth(handler) {
+	return (req, res) => {
+		authMiddleware(req, res, () => handler(req, res));
+	};
+}

package/bin/probe-chat.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+/**
+ * @probelabs/probe-chat CLI
+ * Command-line interface for Probe code search chat
+ *
+ * This is a thin wrapper around the main functionality in index.js
+ */
+
+import { main } from '../index.js';
+
+// Execute the main function
+main();

package/cancelRequest.js

@@ -0,0 +1,84 @@
+// Map to store active requests by session ID
+const activeRequests = new Map();
+
+/**
+ * Register a request as active
+ * @param {string} sessionId - The session ID
+ * @param {Object} requestData - Data about the request (can include abort functions, etc.)
+ */
+export function registerRequest(sessionId, requestData) {
+	if (!sessionId) {
+		console.warn('Attempted to register request without session ID');
+		return;
+	}
+
+	console.log(`Registering request for session: ${sessionId}`);
+	activeRequests.set(sessionId, requestData);
+}
+
+/**
+ * Cancel a request by session ID
+ * @param {string} sessionId - The session ID
+ * @returns {boolean} - Whether the cancellation was successful
+ */
+export function cancelRequest(sessionId) {
+	if (!sessionId) {
+		console.warn('Attempted to cancel request without session ID');
+		return false;
+	}
+
+	const requestData = activeRequests.get(sessionId);
+	if (!requestData) {
+		console.warn(`No active request found for session: ${sessionId}`);
+		return false;
+	}
+
+	console.log(`Cancelling request for session: ${sessionId}`);
+
+	// Call the abort function if it exists
+	if (typeof requestData.abort === 'function') {
+		try {
+			requestData.abort();
+			console.log(`Successfully aborted request for session: ${sessionId}`);
+		} catch (error) {
+			console.error(`Error aborting request for session ${sessionId}:`, error);
+		}
+	}
+
+	// Remove the request from the active requests map
+	activeRequests.delete(sessionId);
+	return true;
+}
+
+/**
+ * Check if a request is active
+ * @param {string} sessionId - The session ID
+ * @returns {boolean} - Whether the request is active
+ */
+export function isRequestActive(sessionId) {
+	return activeRequests.has(sessionId);
+}
+
+/**
+ * Get all active requests
+ * @returns {Map} - Map of all active requests
+ */
+export function getActiveRequests() {
+	return activeRequests;
+}
+
+/**
+ * Clear a request from the active requests map
+ * @param {string} sessionId - The session ID
+ */
+export function clearRequest(sessionId) {
+	if (!sessionId) {
+		console.warn('Attempted to clear request without session ID');
+		return;
+	}
+
+	if (activeRequests.has(sessionId)) {
+		console.log(`Clearing request for session: ${sessionId}`);
+		activeRequests.delete(sessionId);
+	}
+}

package/fileSpanExporter.js

@@ -0,0 +1,183 @@
+import { createWriteStream } from 'fs';
+import corePkg from '@opentelemetry/core';
+
+const { ExportResultCode } = corePkg;
+
+/**
+ * File exporter for OpenTelemetry spans
+ * Exports spans to a file in JSON Lines format (one JSON object per line)
+ * Following the OTLP JSON format specification
+ */
+export class FileSpanExporter {
+  constructor(filePath = './traces.jsonl') {
+    this.filePath = filePath;
+    this.stream = createWriteStream(filePath, { flags: 'a' });
+    this.stream.on('error', (error) => {
+      console.error(`[FileSpanExporter] Stream error: ${error.message}`);
+    });
+  }
+
+  /**
+   * Export spans to file
+   * @param {ReadableSpan[]} spans - Array of spans to export
+   * @param {function} resultCallback - Callback to call with the export result
+   */
+  export(spans, resultCallback) {
+    if (!spans || spans.length === 0) {
+      resultCallback({ code: ExportResultCode.SUCCESS });
+      return;
+    }
+
+    try {
+      const timestamp = Date.now();
+      
+      spans.forEach((span, index) => {
+        // Debug: Log first span's properties to understand structure
+        if (index === 0 && process.env.DEBUG_CHAT === '1') {
+          console.log('[FileSpanExporter] First span properties:');
+          const keys = Object.getOwnPropertyNames(span);
+          keys.forEach(key => {
+            if (key.toLowerCase().includes('parent') || key === '_spanContext' || key === 'parentContext') {
+              console.log(`  ${key}:`, span[key]);
+            }
+          });
+        }
+        
+        // Extract parent span ID - check various possible properties
+        let parentSpanId = undefined;
+        
+        // Check if there's a parent span context in the span
+        if (span.parentSpanContext) {
+          parentSpanId = span.parentSpanContext.spanId;
+        } else if (span._parentSpanContext) {
+          parentSpanId = span._parentSpanContext.spanId;
+        } else if (span.parent) {
+          parentSpanId = span.parent.spanId;
+        } else if (span._parent) {
+          parentSpanId = span._parent.spanId;
+        } else if (span._parentId) {
+          parentSpanId = span._parentId;
+        } else if (span.parentSpanId) {
+          parentSpanId = span.parentSpanId;
+        }
+        
+        // Convert span to OTLP JSON format
+        const spanData = {
+          traceId: span.spanContext().traceId,
+          spanId: span.spanContext().spanId,
+          parentSpanId: parentSpanId,
+          name: span.name,
+          kind: span.kind,
+          startTimeUnixNano: span.startTime[0] * 1_000_000_000 + span.startTime[1],
+          endTimeUnixNano: span.endTime[0] * 1_000_000_000 + span.endTime[1],
+          attributes: this.convertAttributes(span.attributes),
+          status: span.status,
+          events: span.events?.map(event => ({
+            timeUnixNano: event.time[0] * 1_000_000_000 + event.time[1],
+            name: event.name,
+            attributes: this.convertAttributes(event.attributes),
+          })) || [],
+          links: span.links?.map(link => ({
+            traceId: link.context.traceId,
+            spanId: link.context.spanId,
+            attributes: this.convertAttributes(link.attributes),
+          })) || [],
+          resource: {
+            attributes: this.convertAttributes(span.resource?.attributes || {}),
+          },
+          instrumentationLibrary: {
+            name: span.instrumentationLibrary?.name || 'unknown',
+            version: span.instrumentationLibrary?.version || 'unknown',
+          },
+          timestamp,
+        };
+
+        // Write as JSON Lines format (one JSON object per line)
+        this.stream.write(JSON.stringify(spanData) + '\n');
+      });
+
+      resultCallback({ code: ExportResultCode.SUCCESS });
+    } catch (error) {
+      console.error(`[FileSpanExporter] Export error: ${error.message}`);
+      resultCallback({ 
+        code: ExportResultCode.FAILED, 
+        error: error 
+      });
+    }
+  }
+
+  /**
+   * Convert OpenTelemetry attributes to plain object
+   * @param {Object} attributes - OpenTelemetry attributes
+   * @returns {Object} Plain object with string values
+   */
+  convertAttributes(attributes) {
+    if (!attributes) return {};
+    
+    const result = {};
+    for (const [key, value] of Object.entries(attributes)) {
+      // Convert all values to strings for JSON compatibility
+      if (typeof value === 'object' && value !== null) {
+        result[key] = JSON.stringify(value);
+      } else {
+        result[key] = String(value);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Shutdown the exporter
+   * @returns {Promise<void>}
+   */
+  async shutdown() {
+    return new Promise((resolve) => {
+      if (this.stream) {
+        this.stream.end(() => {
+          console.log(`[FileSpanExporter] File stream closed: ${this.filePath}`);
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  /**
+   * Force flush any pending spans
+   * @returns {Promise<void>}
+   */
+  async forceFlush() {
+    return new Promise((resolve, reject) => {
+      if (this.stream) {
+        // CRITICAL FIX: Force the stream to flush all buffered data
+        // Use both drain event and explicit cork/uncork to ensure data is written
+        const flushTimeout = setTimeout(() => {
+          console.warn('[FileSpanExporter] Flush timeout after 5 seconds');
+          resolve();
+        }, 5000);
+        
+        // Uncork the stream to force buffered writes
+        if (this.stream.writableCorked) {
+          this.stream.uncork();
+        }
+        
+        // If there's buffered data, wait for drain event
+        if (this.stream.writableNeedDrain) {
+          this.stream.once('drain', () => {
+            clearTimeout(flushTimeout);
+            resolve();
+          });
+        } else {
+          // No buffered data, but still give it a moment to ensure writes complete
+          setImmediate(() => {
+            clearTimeout(flushTimeout);
+            resolve();
+          });
+        }
+      } else {
+        resolve();
+      }
+    });
+  }
+}

package/implement/README.md

@@ -0,0 +1,228 @@
+# Probe Chat Implementation Tool - Pluggable Backend System
+
+The Probe Chat Implementation Tool now supports multiple AI-powered code implementation backends through a flexible, pluggable architecture. This allows you to choose between different AI coding assistants based on your needs, API availability, and preferences.
+
+## 🚀 Quick Start
+
+### Using Different Backends
+
+```bash
+# Use the default backend (aider)
+probe-chat --allow-edit
+
+# Use Claude Code backend
+probe-chat --allow-edit --implement-tool-backend claude-code
+
+# Configure fallback backends
+probe-chat --allow-edit --implement-tool-backend claude-code --implement-tool-fallbacks aider
+
+# List available backends
+probe-chat --implement-tool-list-backends
+
+# Get detailed info about a backend
+probe-chat --implement-tool-backend-info claude-code
+```
+
+## 📋 Available Backends
+
+### Aider Backend (Default)
+- **Description**: AI pair programming in your terminal
+- **Strengths**: Battle-tested, supports many models, git integration
+- **Requirements**: Python 3.8+, `pip install aider-chat`
+- **API Keys**: Requires one of: ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY
+
+### Claude Code Backend
+- **Description**: Advanced AI coding assistant powered by Claude
+- **Strengths**: Latest Claude models, sophisticated code understanding, MCP tools
+- **Requirements**: Node.js 18+, `npm install -g @anthropic-ai/claude-code`
+- **API Keys**: Requires ANTHROPIC_API_KEY
+- **Cross-Platform**: Full support for Windows, macOS, Linux, and WSL
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+```bash
+# Backend Selection
+export IMPLEMENT_TOOL_BACKEND=claude-code              # Choose primary backend
+export IMPLEMENT_TOOL_FALLBACKS=aider,claude-code  # Comma-separated fallbacks
+export IMPLEMENT_TOOL_TIMEOUT=1200                      # Timeout in seconds (min: 60, max: 3600, default: 1200)
+
+# Aider Configuration
+export AIDER_MODEL=gpt-4                          # Model for aider
+export AIDER_AUTO_COMMIT=false                    # Auto-commit changes
+export AIDER_TIMEOUT=300000                       # Aider-specific timeout (deprecated - use IMPLEMENT_TOOL_TIMEOUT)
+
+# Claude Code Configuration  
+export CLAUDE_CODE_MODEL=claude-3-5-sonnet-20241022  # Claude model
+export CLAUDE_CODE_MAX_TOKENS=8000                # Max tokens
+export CLAUDE_CODE_TEMPERATURE=0.3                # Temperature (0-2)
+export CLAUDE_CODE_MAX_TURNS=10                   # Max conversation turns
+```
+
+### Configuration File
+
+Create `implement-config.json` in your project root:
+
+```json
+{
+  "implement": {
+    "defaultBackend": "claude-code",
+    "fallbackBackends": ["aider"],
+    "selectionStrategy": "auto",
+    "timeout": 300000
+  },
+  "backends": {
+    "aider": {
+      "model": "gpt-4",
+      "autoCommit": false,
+      "additionalArgs": ["--no-auto-commits"]
+    },
+    "claude-code": {
+      "model": "claude-3-5-sonnet-20241022",
+      "maxTokens": 8000,
+      "temperature": 0.3,
+      "tools": ["edit", "search", "bash"]
+    }
+  }
+}
+```
+
+## 🔄 Backend Selection Strategies
+
+The system supports three selection strategies:
+
+1. **auto** (default): Tries backends in order of availability
+2. **preference**: Uses only the specified backend, fails if unavailable
+3. **capability**: Selects backend based on language and feature support
+
+## 🛠️ CLI Options
+
+```bash
+# Backend selection
+--implement-tool-backend <name>      # Choose backend (aider, claude-code)
+--implement-tool-fallbacks <names>   # Comma-separated fallback backends
+--implement-tool-timeout <ms>        # Implementation timeout
+--implement-tool-config <path>       # Path to config file
+
+# Information
+--implement-tool-list-backends       # List all available backends
+--implement-tool-backend-info <name> # Show backend details
+```
+
+## 📊 Backend Comparison
+
+| Feature | Aider | Claude Code |
+|---------|-------|-------------|
+| **Languages** | Python, JS, TS, Go, Rust, Java, C/C++, C#, Ruby, PHP | JS, TS, Python, Rust, Go, Java, C++, C#, Ruby, PHP, Swift |
+| **Streaming Output** | ✅ | ✅ |
+| **Direct File Edit** | ✅ | ✅ |
+| **Test Generation** | ❌ | ✅ |
+| **Plan Generation** | ❌ | ✅ |
+| **Rollback Support** | ✅ | ❌ |
+| **Max Sessions** | 3 | 5 |
+
+## 🔧 Advanced Usage
+
+### Custom Backend Configuration
+
+```javascript
+// In your code
+const implementTool = createImplementTool({
+  enabled: true,
+  backendConfig: {
+    defaultBackend: 'claude-code',
+    fallbackBackends: ['aider'],
+    backends: {
+      'claude-code': {
+        apiKey: process.env.MY_CLAUDE_KEY,
+        model: 'claude-3-5-sonnet-20241022',
+        systemPrompt: 'You are an expert TypeScript developer...'
+      }
+    }
+  }
+});
+```
+
+### Programmatic Backend Selection
+
+```javascript
+// Execute with specific backend
+const result = await implementTool.execute({
+  task: 'Refactor this function to use async/await',
+  backend: 'claude-code',  // Force specific backend
+  generateTests: true,     // Backend-specific option
+  sessionId: 'my-session-123'
+});
+```
+
+## 🚨 Troubleshooting
+
+### Common Issues
+
+1. **Backend not available**
+   - Check if required dependencies are installed
+   - Verify API keys are set correctly
+   - Run `probe-chat --implement-tool-backend-info <name>` for diagnostics
+   - On Windows: Claude Code may be installed in WSL, which is automatically detected
+
+2. **Timeout errors**
+   - Increase timeout: `--implement-tool-timeout 600000` (10 minutes)
+   - Check network connectivity
+   - Consider using a different backend
+
+3. **API key issues**
+   - Ensure keys are exported in your environment
+   - Check key validity with the provider
+   - Verify key permissions
+
+### Debug Mode
+
+Enable debug logging to troubleshoot issues:
+
+```bash
+DEBUG_CHAT=1 probe-chat --allow-edit --implement-tool-backend claude-code
+```
+
+## 🔐 Security Considerations
+
+- API keys are never logged or exposed
+- File access is restricted to the working directory
+- All changes are made locally until explicitly committed
+- Review all AI-generated changes before committing
+
+## 🤝 Contributing
+
+To add a new backend:
+
+1. Extend the `BaseBackend` class
+2. Implement required methods
+3. Register in `backends/registry.js`
+4. Add configuration schema
+5. Update documentation
+
+See `implement/backends/BaseBackend.js` for the interface definition.
+
+## 📝 Migration from Legacy System
+
+The new system is backward compatible. Your existing workflows will continue to work:
+
+```bash
+# Old way (still works, uses aider backend)
+probe-chat --allow-edit
+
+# New way (explicit backend selection)
+probe-chat --allow-edit --implement-tool-backend aider
+```
+
+No changes are required to existing scripts or workflows. The system defaults to aider backend for compatibility.
+
+## 🔗 Related Documentation
+
+- [Probe Chat Documentation](../../README.md)
+- [Aider Documentation](https://aider.chat/)
+- [Claude Code SDK](https://docs.anthropic.com/en/docs/claude-code)
+
+## 📄 License
+
+This pluggable backend system is part of Probe Chat and follows the same Apache-2.0 license.