vibeman 0.0.3 → 0.0.6

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

@@ -1,61 +0,0 @@
-/**
- * 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 using enhanced detection
-     */
-    validateSetup(): Promise<ProviderStatus>;
-    /**
-     * Get provider capabilities
-     */
-    getCapabilities(): ProviderCapabilities;
-    /**
-     * Map ExecutionOptions to Claude Code Options
-     */
-    private mapToClaudeOptions;
-    /**
-     * Resolve Claude CLI executable path using enhanced detection
-     */
-    private getClaudeExecutablePath;
-}

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

@@ -1,362 +0,0 @@
-/**
- * Claude Code Adapter
- * Implements AIProvider interface for Claude Code SDK
- */
-import { query } from '@anthropic-ai/claude-code';
-import { generateId } from '../../lib/id-generator.js';
-import { getSettingsService } from '../../settings-service.js';
-import { getProviderDetectionService } from '../../lib/provider-detection.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 = await 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 using enhanced detection
-     */
-    async validateSetup() {
-        try {
-            const detectionService = getProviderDetectionService();
-            const result = await detectionService.detectProvider('claude-code');
-            if (!result.found) {
-                return {
-                    available: false,
-                    error: result.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
-     */
-    async mapToClaudeOptions(options) {
-        const claudeOptions = {
-            cwd: options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd(),
-            model: options?.model || this.config.defaultModel,
-            pathToClaudeCodeExecutable: await 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 using enhanced detection
-     */
-    async getClaudeExecutablePath() {
-        // Highest precedence: explicit config option
-        if (this.config.claudeBinPath) {
-            return this.config.claudeBinPath;
-        }
-        // Use enhanced detection service
-        const detectionService = getProviderDetectionService();
-        const result = await detectionService.detectProvider('claude-code');
-        if (result.found && result.path) {
-            return result.path;
-        }
-        // Fallback: try old settings-based approach for backwards compatibility
-        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();
-        }
-        return 'claude';
-    }
-}

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

@@ -1,36 +0,0 @@
-/**
- * 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;
-    private normalizeReasoningEffort;
-    private resolveModelSpec;
-    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;
-}