vibeman 0.0.0 → 0.0.1

package/dist/runtime/api/agent/ai-providers/claude-code-adapter.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Claude Code Adapter
+ * Implements AIProvider interface for Claude Code SDK
+ */
+import { AIProvider, ExecutionOptions, ExecutionMessage, ExecutionResult, ModelInfo, ProviderStatus, ProviderCapabilities } from './types.js';
+/**
+ * Configuration for Claude Code Adapter
+ */
+export interface ClaudeCodeConfig {
+    /**
+     * Path to Claude CLI executable
+     * If not provided, will use default resolution
+     */
+    claudeBinPath?: string;
+    /**
+     * Default working directory
+     */
+    defaultWorkingDirectory?: string;
+    /**
+     * Default model to use
+     */
+    defaultModel?: string;
+}
+/**
+ * Claude Code Adapter
+ * Wraps the Claude Code SDK to implement the AIProvider interface
+ */
+export declare class ClaudeCodeAdapter implements AIProvider {
+    readonly name = "claude-code";
+    readonly displayName = "Claude Code";
+    private config;
+    constructor(config?: ClaudeCodeConfig);
+    /**
+     * Execute a prompt using Claude Code SDK
+     */
+    execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
+    /**
+     * Execute synchronously and return the final result
+     */
+    executeSync(prompt: string, options?: ExecutionOptions): Promise<ExecutionResult>;
+    /**
+     * Detect available Claude models
+     */
+    detectAvailableModels(): Promise<ModelInfo[]>;
+    /**
+     * Validate Claude Code setup
+     */
+    validateSetup(): Promise<ProviderStatus>;
+    /**
+     * Get provider capabilities
+     */
+    getCapabilities(): ProviderCapabilities;
+    /**
+     * Map ExecutionOptions to Claude Code Options
+     */
+    private mapToClaudeOptions;
+    /**
+     * Resolve Claude CLI executable path
+     */
+    private getClaudeExecutablePath;
+}

package/dist/runtime/api/agent/ai-providers/claude-code-adapter.js

@@ -0,0 +1,373 @@
+/**
+ * Claude Code Adapter
+ * Implements AIProvider interface for Claude Code SDK
+ */
+import { query } from '@anthropic-ai/claude-code';
+import path from 'path';
+import os from 'os';
+import { generateId } from '../../lib/id-generator.js';
+import { getSettingsService } from '../../settings-service.js';
+/**
+ * Claude Code Adapter
+ * Wraps the Claude Code SDK to implement the AIProvider interface
+ */
+export class ClaudeCodeAdapter {
+    constructor(config = {}) {
+        this.name = 'claude-code';
+        this.displayName = 'Claude Code';
+        this.config = config;
+    }
+    /**
+     * Execute a prompt using Claude Code SDK
+     */
+    async *execute(prompt, options) {
+        const claudeOptions = this.mapToClaudeOptions(options);
+        const co = claudeOptions;
+        const startTime = Date.now();
+        let sessionId;
+        // let totalCost = 0;
+        let promptTokens = 0;
+        let completionTokens = 0;
+        try {
+            // Emit a synthetic system message with the effective prompt we send to the provider
+            const sysParts = [];
+            if (co.systemPrompt) {
+                sysParts.push('--- System Prompt ---');
+                sysParts.push(String(co.systemPrompt));
+                sysParts.push('--- End System Prompt ---');
+            }
+            if (co.appendSystemPrompt) {
+                sysParts.push('--- Append System Prompt ---');
+                sysParts.push(String(co.appendSystemPrompt));
+                sysParts.push('--- End Append System Prompt ---');
+            }
+            sysParts.push('--- User Prompt ---');
+            sysParts.push(String(prompt));
+            sysParts.push('--- End User Prompt ---');
+            yield {
+                type: 'system',
+                timestamp: new Date().toISOString(),
+                content: `Effective prompt sent to ${this.displayName} (model: ${co.model || this.config.defaultModel || 'claude-sonnet-4-20250514'}):\n${sysParts.join('\n')}`,
+                metadata: {
+                    provider: this.name,
+                    model: co.model || this.config.defaultModel || 'claude-sonnet-4-20250514',
+                    workingDirectory: co?.cwd || this.config.defaultWorkingDirectory || process.cwd(),
+                    tools: co?.allowedTools,
+                },
+            };
+            for await (const message of query({ prompt, options: claudeOptions })) {
+                // Handle init message
+                if (message.type === 'system' && message.subtype === 'init') {
+                    sessionId = message.session_id;
+                    const initMsg = {
+                        type: 'init',
+                        timestamp: new Date().toISOString(),
+                        sessionId,
+                        model: claudeOptions.model ||
+                            this.config.defaultModel ||
+                            'claude-sonnet-4-20250514',
+                        provider: this.name,
+                    };
+                    yield initMsg;
+                }
+                // Handle assistant messages
+                else if (message.type === 'assistant') {
+                    const content = message.message.content;
+                    if (typeof content === 'string') {
+                        const assistantMsg = {
+                            type: 'assistant',
+                            timestamp: new Date().toISOString(),
+                            content,
+                            metadata: { sessionId },
+                        };
+                        yield assistantMsg;
+                    }
+                    else if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === 'text') {
+                                const assistantMsg = {
+                                    type: 'assistant',
+                                    timestamp: new Date().toISOString(),
+                                    content: block.text,
+                                    metadata: { sessionId },
+                                };
+                                yield assistantMsg;
+                            }
+                            else if (block.type === 'tool_use') {
+                                const toolMsg = {
+                                    type: 'tool_use',
+                                    timestamp: new Date().toISOString(),
+                                    tool: block.name,
+                                    input: block.input,
+                                    metadata: { sessionId, toolId: block.id },
+                                };
+                                yield toolMsg;
+                            }
+                        }
+                    }
+                }
+                // Handle result message
+                else if (message.type === 'result') {
+                    const resultMsg = {
+                        type: 'result',
+                        timestamp: new Date().toISOString(),
+                        success: message.subtype === 'success',
+                        result: message.subtype === 'success' ? message.result : undefined,
+                        error: message.subtype !== 'success' ? message.subtype : undefined,
+                        usage: {
+                            promptTokens: message.usage?.input_tokens || promptTokens,
+                            completionTokens: message.usage?.output_tokens || completionTokens,
+                            totalTokens: (message.usage?.input_tokens || 0) + (message.usage?.output_tokens || 0),
+                            cost: message.total_cost_usd,
+                        },
+                        duration: Date.now() - startTime,
+                        metadata: { sessionId },
+                    };
+                    yield resultMsg;
+                    // Track metrics
+                    // if (message.total_cost_usd) totalCost = message.total_cost_usd;
+                    if (message.usage?.input_tokens)
+                        promptTokens = message.usage.input_tokens;
+                    if (message.usage?.output_tokens)
+                        completionTokens = message.usage.output_tokens;
+                }
+                // Handle other message types (errors, etc.)
+                else {
+                    // Check if this is an error message
+                    const msgType = message.type;
+                    if (msgType === 'error') {
+                        const errorMsg = {
+                            type: 'error',
+                            timestamp: new Date().toISOString(),
+                            content: message.message || 'Unknown error',
+                            metadata: { sessionId, errorType: message.subtype },
+                        };
+                        yield errorMsg;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Yield error message
+            yield {
+                type: 'error',
+                timestamp: new Date().toISOString(),
+                content: error instanceof Error ? error.message : String(error),
+                metadata: { sessionId },
+            };
+            throw error;
+        }
+    }
+    /**
+     * Execute synchronously and return the final result
+     */
+    async executeSync(prompt, options) {
+        const executionId = generateId('claude');
+        const result = {
+            id: executionId,
+            provider: this.name,
+            model: options?.model || this.config.defaultModel || 'claude-sonnet-4-20250514',
+            content: '',
+            usage: {
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+                cost: 0,
+            },
+            duration: 0,
+        };
+        const startTime = Date.now();
+        const messages = [];
+        try {
+            for await (const message of this.execute(prompt, options)) {
+                if (message.type === 'assistant') {
+                    const assistantMsg = message;
+                    messages.push(assistantMsg.content);
+                }
+                else if (message.type === 'result') {
+                    const resultMsg = message;
+                    if (resultMsg.success) {
+                        result.content = resultMsg.result || messages.join('\n');
+                        result.usage = resultMsg.usage || result.usage;
+                        result.duration = Date.now() - startTime;
+                    }
+                    else {
+                        result.error = resultMsg.error;
+                        throw new Error(resultMsg.error || 'Execution failed');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            result.error = error instanceof Error ? error.message : String(error);
+            result.duration = Date.now() - startTime;
+            throw error;
+        }
+        return result;
+    }
+    /**
+     * Detect available Claude models
+     */
+    async detectAvailableModels() {
+        // For now, return known Claude models
+        // In the future, could query the API for available models
+        return [
+            {
+                id: 'claude-sonnet-4-20250514',
+                name: 'claude-sonnet-4-20250514',
+                displayName: 'Claude Sonnet 4',
+                provider: this.name,
+                contextWindow: 200000,
+                maxOutputTokens: 64000,
+                capabilities: ['code', 'analysis', 'tools', 'vision', 'extended-thinking'],
+            },
+            {
+                id: 'claude-opus-4-1-20250805',
+                name: 'claude-opus-4-1-20250805',
+                displayName: 'Claude Opus 4.1',
+                provider: this.name,
+                contextWindow: 200000,
+                maxOutputTokens: 32000,
+                capabilities: [
+                    'code',
+                    'analysis',
+                    'tools',
+                    'deep-reasoning',
+                    'vision',
+                    'extended-thinking',
+                ],
+            },
+            {
+                id: 'claude-3-5-haiku-20241022',
+                name: 'claude-3-5-haiku-20241022',
+                displayName: 'Claude 3.5 Haiku',
+                provider: this.name,
+                contextWindow: 200000,
+                maxOutputTokens: 8000,
+                capabilities: ['code', 'analysis', 'tools', 'vision'],
+            },
+        ];
+    }
+    /**
+     * Validate Claude Code setup
+     */
+    async validateSetup() {
+        try {
+            const claudePath = this.getClaudeExecutablePath();
+            const fs = await import('fs/promises');
+            // Check if Claude executable exists
+            try {
+                await fs.access(claudePath);
+            }
+            catch {
+                // Try to execute claude directly (might be in PATH)
+                const { execSync } = await import('child_process');
+                try {
+                    execSync('claude --version', { stdio: 'ignore' });
+                }
+                catch {
+                    return {
+                        available: false,
+                        error: 'Claude CLI not found. Please install Claude Code CLI.',
+                        models: [],
+                        capabilities: this.getCapabilities(),
+                    };
+                }
+            }
+            const models = await this.detectAvailableModels();
+            return {
+                available: true,
+                models,
+                capabilities: this.getCapabilities(),
+            };
+        }
+        catch (error) {
+            return {
+                available: false,
+                error: error instanceof Error ? error.message : String(error),
+                models: [],
+                capabilities: this.getCapabilities(),
+            };
+        }
+    }
+    /**
+     * Get provider capabilities
+     */
+    getCapabilities() {
+        return {
+            streaming: true,
+            tools: true,
+            functionCalling: false, // Claude Code uses tool format
+            vision: true,
+            codeExecution: true,
+            maxContextWindow: 200000,
+            maxOutputTokens: 8192,
+        };
+    }
+    /**
+     * Map ExecutionOptions to Claude Code Options
+     */
+    mapToClaudeOptions(options) {
+        const claudeOptions = {
+            cwd: options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd(),
+            model: options?.model || this.config.defaultModel,
+            pathToClaudeCodeExecutable: this.getClaudeExecutablePath(),
+        };
+        // Map temperature
+        if (options?.temperature !== undefined) {
+            claudeOptions.temperature = options.temperature;
+        }
+        // Map max tokens
+        if (options?.maxTokens !== undefined) {
+            claudeOptions.maxTokens = options.maxTokens;
+        }
+        // Map abort signal
+        if (options?.abortSignal) {
+            claudeOptions.abortController = new AbortController();
+            options.abortSignal.addEventListener('abort', () => {
+                claudeOptions.abortController?.abort();
+            });
+        }
+        // Map system prompt
+        if (options?.systemPrompt) {
+            claudeOptions.systemPrompt = options.systemPrompt;
+        }
+        if (options?.appendSystemPrompt) {
+            claudeOptions.appendSystemPrompt = options.appendSystemPrompt;
+        }
+        // Map tools
+        if (options?.tools) {
+            claudeOptions.allowedTools = options.tools;
+        }
+        return claudeOptions;
+    }
+    /**
+     * Resolve Claude CLI executable path
+     */
+    getClaudeExecutablePath() {
+        // Highest precedence: explicit env var (documented in README)
+        const envPath = process.env.VIBEMAN_CLAUDE_BIN;
+        if (envPath && envPath.trim()) {
+            return envPath.trim();
+        }
+        if (this.config.claudeBinPath) {
+            return this.config.claudeBinPath;
+        }
+        // Check settings first
+        const settingsBinPath = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.agents?.providers?.claudeCode?.binPath;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        if (settingsBinPath?.trim()) {
+            return settingsBinPath.trim();
+        }
+        // Default to local installation
+        return path.join(os.homedir(), '.claude', 'local', 'claude');
+    }
+}

package/dist/runtime/api/agent/ai-providers/codex-cli-provider.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Codex CLI Provider
+ * Headless wrapper around the Codex CLI `codex exec` command.
+ */
+import { AIProvider, ExecutionMessage, ExecutionOptions, ModelInfo, ProviderCapabilities, ProviderStatus } from './types.js';
+export interface CodexCliConfig {
+    codexBinPath?: string;
+    defaultWorkingDirectory?: string;
+    defaultModel?: string;
+    defaultTimeoutMs?: number;
+}
+export declare class CodexCliProvider implements AIProvider {
+    private config;
+    readonly name = "codex";
+    readonly displayName = "Codex CLI";
+    constructor(config?: CodexCliConfig);
+    private resolveExecutable;
+    execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
+    executeSync(prompt: string, options?: ExecutionOptions): Promise<{
+        id: string;
+        provider: string;
+        model: string;
+        content: string;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+        duration: number;
+    }>;
+    detectAvailableModels(): Promise<ModelInfo[]>;
+    validateSetup(): Promise<ProviderStatus>;
+    getCapabilities(): ProviderCapabilities;
+}