vibeman 0.0.0 → 0.0.1

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

@@ -0,0 +1,281 @@
+/**
+ * Codex CLI Provider
+ * Headless wrapper around the Codex CLI `codex exec` command.
+ */
+import { spawn } from 'child_process';
+import { getSettingsService } from '../../settings-service.js';
+import { logger } from '../../lib/logger.js';
+export class CodexCliProvider {
+    constructor(config = {}) {
+        this.config = config;
+        this.name = 'codex';
+        this.displayName = 'Codex CLI';
+    }
+    resolveExecutable() {
+        if (this.config.codexBinPath)
+            return this.config.codexBinPath;
+        // Check settings first
+        const settingsBinPath = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.agents?.providers?.codex?.binPath;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        if (settingsBinPath?.trim())
+            return settingsBinPath.trim();
+        // Default to binary name (resolve via PATH)
+        return 'codex';
+    }
+    async *execute(prompt, options) {
+        // Effective options
+        const cwd = options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd();
+        const mapModel = (m) => {
+            if (!m)
+                return m;
+            // Normalize reasoning-effort variants to the canonical model id
+            // Users reported only `gpt-5` is selectable; variants are effort levels in the TUI.
+            const lower = m.toLowerCase();
+            if (lower === 'gpt-5-minimal' ||
+                lower === 'gpt-5-low' ||
+                lower === 'gpt-5-medium' ||
+                lower === 'gpt-5-high') {
+                return 'gpt-5';
+            }
+            return m;
+        };
+        const model = mapModel(options?.model || this.config.defaultModel);
+        const images = (options?.images || []).filter(Boolean);
+        const effort = options?.effort;
+        const timeoutMs = options?.timeout ?? this.config.defaultTimeoutMs ?? 10 * 60 * 1000; // 10m
+        // Build argv for `codex exec` (non-interactive automation mode)
+        const argv = ['exec', prompt];
+        if (model) {
+            argv.push('--model', model);
+        }
+        // Prefer spawning with cwd, but also set --cd to make Codex aware of root
+        if (cwd) {
+            argv.push('--cd', cwd);
+        }
+        if (images.length) {
+            argv.push('--image', images.join(','));
+        }
+        const cmd = this.resolveExecutable();
+        const child = spawn(cmd, argv, {
+            cwd,
+            env: { ...process.env },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        // Emit an init/system message with effective command
+        const init = {
+            type: 'init',
+            timestamp: new Date().toISOString(),
+            sessionId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            model: model || 'default',
+            provider: this.name,
+        };
+        yield init;
+        yield {
+            type: 'system',
+            timestamp: new Date().toISOString(),
+            content: `Running: ${cmd} ${argv.map((a) => (a.includes(' ') ? '"' + a + '"' : a)).join(' ')} (cwd=${cwd})`,
+            metadata: { provider: this.name, images, effort },
+        };
+        let stdoutBuf = '';
+        // let stderrBuf = '';
+        let finished = false;
+        let lastFlushedIndex = 0;
+        let lineCarry = '';
+        // Helper to push incremental stdout as assistant log lines
+        const flushNewOutput = () => {
+            const newChunk = stdoutBuf.slice(lastFlushedIndex);
+            if (!newChunk)
+                return;
+            lastFlushedIndex = stdoutBuf.length;
+            // Accumulate and split by line breaks, keep trailing partial
+            lineCarry += newChunk;
+            const parts = lineCarry.split(/\r?\n/);
+            lineCarry = parts.pop() || '';
+            return parts.map((l) => l.trimEnd()).filter(Boolean);
+        };
+        // Provider stays generic: it streams lines and returns raw stdout.
+        // Forward parent termination via abortSignal
+        // const abortController = new AbortController();
+        const onAbort = () => {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                /* ignore */
+            }
+            // Fallback kill after short grace
+            setTimeout(() => {
+                if (!finished) {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }, 3000);
+        };
+        if (options?.abortSignal) {
+            if (options.abortSignal.aborted)
+                onAbort();
+            else
+                options.abortSignal.addEventListener('abort', onAbort, { once: true });
+        }
+        // Local timeout guard
+        const guard = setTimeout(() => {
+            onAbort();
+        }, timeoutMs);
+        // Capture data into buffers
+        child.stdout?.on('data', (data) => {
+            stdoutBuf += data.toString('utf8');
+        });
+        // child.stderr?.on('data', (data: Buffer) => {
+        //   stderrBuf += data.toString('utf8');
+        // });
+        // Wait for process to finish
+        // Stream logs while the process runs by polling for new output
+        const exitPromise = new Promise((resolve) => {
+            child.on('exit', (code, signal) => resolve({ code, signal }));
+        });
+        // Poll for output until the process exits
+        let exitStatus;
+        while (!finished) {
+            const tick = new Promise((r) => setTimeout(r, 150));
+            const exit = await Promise.race([exitPromise, tick]);
+            if (exit && typeof exit.code !== 'undefined') {
+                // Process exited; flush any remaining output before breaking
+                const lines = flushNewOutput();
+                if (lines && lines.length) {
+                    for (const text of lines) {
+                        yield {
+                            type: 'assistant',
+                            timestamp: new Date().toISOString(),
+                            content: text,
+                        };
+                    }
+                }
+                finished = true;
+                // Record exit info for finalization
+                exitStatus = exit;
+                break;
+            }
+            // Flush incremental lines during run
+            const lines = flushNewOutput();
+            if (lines && lines.length) {
+                for (const text of lines) {
+                    yield {
+                        type: 'assistant',
+                        timestamp: new Date().toISOString(),
+                        content: text,
+                    };
+                }
+            }
+        }
+        // If loop ended without capturing exit status (unlikely), await it now
+        const exit = exitStatus ?? (await exitPromise);
+        finished = true;
+        clearTimeout(guard);
+        // Flush any final carry line as a log
+        if (lineCarry.trim()) {
+            yield {
+                type: 'assistant',
+                timestamp: new Date().toISOString(),
+                content: lineCarry.trimEnd(),
+            };
+            lineCarry = '';
+        }
+        // Compose final message
+        const success = (exit.code ?? 1) === 0 && !exit.signal;
+        const remainingStdout = stdoutBuf.trim();
+        const resultMsg = {
+            type: 'result',
+            timestamp: new Date().toISOString(),
+            success,
+            // Return raw stdout as result; higher layers decide how to parse it
+            result: success ? (remainingStdout || '').toString() : undefined,
+            error: success
+                ? undefined
+                : `codex exited ${exit.signal ? 'by ' + exit.signal : 'with code ' + exit.code}`,
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        };
+        yield resultMsg;
+    }
+    async executeSync(prompt, options) {
+        // Convenience: collect from execute()
+        let content = '';
+        const start = Date.now();
+        for await (const msg of this.execute(prompt, options)) {
+            if (msg.type === 'assistant' && typeof msg.content === 'string') {
+                content += (content ? '\n' : '') + msg.content;
+            }
+        }
+        return {
+            id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            provider: this.name,
+            model: options?.model || this.config.defaultModel || 'default',
+            content,
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+            duration: Date.now() - start,
+        };
+    }
+    async detectAvailableModels() {
+        // Current public CLI exposes `--model gpt-5`; effort levels are chosen in-CLI.
+        return [
+            {
+                id: 'gpt-5',
+                name: 'gpt-5',
+                displayName: 'gpt‑5',
+                provider: this.name,
+                contextWindow: 256000,
+                maxOutputTokens: 16384,
+                // Capabilities per Codex docs: supports images via --image and advanced reasoning
+                capabilities: ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'],
+            },
+        ];
+    }
+    async validateSetup() {
+        try {
+            const bin = this.resolveExecutable();
+            // Try to spawn `codex --help` quickly to validate presence
+            const child = spawn(bin, ['--help'], { stdio: 'ignore' });
+            await new Promise((resolve, reject) => {
+                child.once('error', reject);
+                child.once('close', () => resolve());
+            });
+            return {
+                available: true,
+                models: await this.detectAvailableModels(),
+                capabilities: this.getCapabilities(),
+            };
+        }
+        catch (error) {
+            logger.error(error);
+            return {
+                available: false,
+                error: 'Codex CLI not found. Install from https://github.com/openai/codex (see Getting Started: CLI usage).',
+                models: [],
+                capabilities: this.getCapabilities(),
+            };
+        }
+    }
+    // Note: persistence of detected binary paths is handled by onboarding workflow.
+    getCapabilities() {
+        return {
+            streaming: true,
+            tools: true,
+            functionCalling: false,
+            vision: true,
+            codeExecution: true,
+            maxContextWindow: 128000,
+            maxOutputTokens: 8192,
+        };
+    }
+}

package/dist/runtime/api/agent/ai-providers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AI Providers Module
+ * Export all provider types and implementations
+ */
+export * from './types.js';
+export { ClaudeCodeAdapter } from './claude-code-adapter.js';
+export type { ClaudeCodeConfig } from './claude-code-adapter.js';
+export { CodexCliProvider } from './codex-cli-provider.js';
+export type { CodexCliConfig } from './codex-cli-provider.js';

package/dist/runtime/api/agent/ai-providers/index.js

@@ -0,0 +1,7 @@
+/**
+ * AI Providers Module
+ * Export all provider types and implementations
+ */
+export * from './types.js';
+export { ClaudeCodeAdapter } from './claude-code-adapter.js';
+export { CodexCliProvider } from './codex-cli-provider.js';

package/dist/runtime/api/agent/ai-providers/types.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Core AI Provider Abstraction
+ * Defines the contract for AI execution providers (Claude, OpenAI, Local LLMs, etc.)
+ */
+/**
+ * Model information for available AI models
+ */
+export interface ModelInfo {
+    id: string;
+    name: string;
+    displayName: string;
+    provider: string;
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    costPerInputToken?: number;
+    costPerOutputToken?: number;
+    capabilities?: string[];
+}
+/**
+ * Tool permissions for AI execution
+ * Source: https://docs.anthropic.com/en/docs/claude-code/settings#tools-available-to-claude
+ */
+export type ToolPermission = 'Bash' | 'Edit' | 'Glob' | 'Grep' | 'MultiEdit' | 'NotebookEdit' | 'NotebookRead' | 'Read' | 'Task' | 'TodoWrite' | 'WebSearch' | 'WebFetch' | 'Write';
+/**
+ * Execution options for AI providers
+ */
+export interface ExecutionOptions {
+    workingDirectory?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: ToolPermission[];
+    timeout?: number;
+    abortSignal?: AbortSignal;
+    systemPrompt?: string;
+    appendSystemPrompt?: string;
+    /**
+     * Permission mode for Claude Code SDK (provider-specific hint).
+     * - default: standard prompts/permissions
+     * - acceptEdits: auto-approve file edits and common FS ops
+     * - bypassPermissions: auto-approve all tool uses (dangerous; headless automation)
+     */
+    permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions';
+    /** Optional list of image file paths to attach (Codex CLI: --image) */
+    images?: string[];
+    /** Optional effort hint for reasoning presets (e.g., 'minimal'|'low'|'medium'|'high'); informational only */
+    effort?: string;
+}
+/**
+ * Message types for streaming execution
+ */
+export interface ExecutionMessage {
+    type: 'init' | 'assistant' | 'tool_use' | 'result' | 'error' | 'system';
+    timestamp: string;
+    content?: string | any;
+    metadata?: Record<string, any>;
+}
+/**
+ * Initialization message
+ */
+export interface InitMessage extends ExecutionMessage {
+    type: 'init';
+    sessionId: string;
+    model: string;
+    provider: string;
+}
+/**
+ * Assistant message (AI response)
+ */
+export interface AssistantMessage extends ExecutionMessage {
+    type: 'assistant';
+    content: string;
+    toolCalls?: ToolCall[];
+}
+/**
+ * Tool call information
+ */
+export interface ToolCall {
+    id: string;
+    name: string;
+    input?: any;
+    output?: any;
+}
+/**
+ * Tool use message
+ */
+export interface ToolUseMessage extends ExecutionMessage {
+    type: 'tool_use';
+    tool: string;
+    input: any;
+    output?: any;
+}
+/**
+ * Result message (final output)
+ */
+export interface ResultMessage extends ExecutionMessage {
+    type: 'result';
+    success: boolean;
+    result?: string;
+    error?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        cost?: number;
+    };
+    duration?: number;
+}
+/**
+ * Execution result for synchronous execution
+ */
+export interface ExecutionResult {
+    id: string;
+    provider: string;
+    model: string;
+    content: string;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        cost?: number;
+    };
+    duration: number;
+    error?: string;
+}
+/**
+ * Provider capabilities
+ */
+export interface ProviderCapabilities {
+    streaming: boolean;
+    tools: boolean;
+    functionCalling: boolean;
+    vision: boolean;
+    codeExecution: boolean;
+    maxContextWindow: number;
+    maxOutputTokens: number;
+}
+/**
+ * Provider status
+ */
+export interface ProviderStatus {
+    available: boolean;
+    error?: string;
+    models: ModelInfo[];
+    capabilities: ProviderCapabilities;
+}
+/**
+ * Core AI Provider interface
+ * All AI providers must implement this interface
+ */
+export interface AIProvider {
+    /**
+     * Provider identifier
+     */
+    readonly name: string;
+    /**
+     * Provider display name
+     */
+    readonly displayName: string;
+    /**
+     * Execute a prompt and return streaming messages
+     */
+    execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
+    /**
+     * Execute a prompt and return the final result (convenience method)
+     */
+    executeSync?(prompt: string, options?: ExecutionOptions): Promise<ExecutionResult>;
+    /**
+     * Detect available models for this provider
+     */
+    detectAvailableModels(): Promise<ModelInfo[]>;
+    /**
+     * Validate provider setup and configuration
+     */
+    validateSetup(): Promise<ProviderStatus>;
+    /**
+     * Get provider capabilities
+     */
+    getCapabilities(): ProviderCapabilities;
+}

package/dist/runtime/api/agent/ai-providers/types.js

@@ -0,0 +1,5 @@
+/**
+ * Core AI Provider Abstraction
+ * Defines the contract for AI execution providers (Claude, OpenAI, Local LLMs, etc.)
+ */
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/runtime/api/agent/codex-cli-provider.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+// Toggle real CLI integration via env
+const USE_REAL = process.env.VITEST_USE_REAL_CODEX === 'true';
+// Note: we dynamically import the provider after (un)mocking per test block
+describe('CodexCliProvider (mocked)', () => {
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('streams stdout, passes images flag, and returns result', async () => {
+        vi.resetModules();
+        vi.doMock('child_process', () => {
+            let captured = [];
+            return {
+                __captured: () => captured,
+                spawn: (cmd, args, opts) => {
+                    captured = [cmd, args, opts];
+                    const { EventEmitter } = require('events');
+                    const stdout = new EventEmitter();
+                    const stderr = new EventEmitter();
+                    const proc = new EventEmitter();
+                    proc.stdout = stdout;
+                    proc.stderr = stderr;
+                    setTimeout(() => stdout.emit('data', Buffer.from('Hello from Codex\n')), 10);
+                    setTimeout(() => proc.emit('exit', 0, null), 20);
+                    return proc;
+                },
+            };
+        });
+        const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
+        const provider = new CodexCliProvider({ defaultTimeoutMs: 1000 });
+        const messages = [];
+        const iter = provider.execute('What is this project about?', {
+            workingDirectory: process.cwd(),
+            images: ['a.png', 'b.jpg'],
+            effort: 'minimal',
+            model: 'gpt-5',
+        });
+        for await (const m of iter)
+            messages.push(m);
+        const resultMsg = messages.find((m) => m.type === 'result');
+        expect(!!resultMsg).toBe(true);
+        const assistantMsg = messages.find((m) => m.type === 'assistant');
+        if (assistantMsg && typeof assistantMsg.content === 'string') {
+            expect(assistantMsg.content.length).toBeGreaterThan(0);
+        }
+        else if (resultMsg && typeof resultMsg.result === 'string') {
+            expect(resultMsg.result.length).toBeGreaterThan(0);
+        }
+        const mockSpawn = await import('child_process');
+        const captured = mockSpawn.__captured();
+        expect(Array.isArray(captured[1])).toBe(true);
+        expect(captured[1]).toContain('--image');
+        expect(captured[1]).toContain('a.png,b.jpg');
+        const modelIdx = captured[1].indexOf('--model');
+        expect(modelIdx).toBeGreaterThan(-1);
+        expect(captured[1][modelIdx + 1]).toBe('gpt-5');
+    });
+});
+// Real integration (opt-in)
+(USE_REAL ? describe : describe.skip)('CodexCliProvider (real CLI)', () => {
+    it('answers a simple model question and prints output', { timeout: 120000 }, async () => {
+        vi.resetModules();
+        vi.doUnmock('child_process');
+        const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
+        const provider = new CodexCliProvider({
+            defaultWorkingDirectory: process.cwd(),
+            defaultTimeoutMs: 120000,
+        });
+        const prompt = 'Just answer 1 + 1 = ? for testing.';
+        let assistant = '';
+        let sawResult = false;
+        for await (const m of provider.execute(prompt, {
+            workingDirectory: process.cwd(),
+            timeout: 120000,
+        })) {
+            console.log('[CODEX]', m.type, typeof m.content === 'string' ? m.content : '');
+            if (m.type === 'assistant' && typeof m.content === 'string') {
+                if (!assistant)
+                    assistant = m.content.trim();
+            }
+            if (m.type === 'result') {
+                sawResult = true;
+            }
+        }
+        expect(sawResult).toBe(true);
+        expect(assistant.length).toBeGreaterThan(0);
+    });
+});

package/dist/runtime/api/agent/core-agent-service.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Core Agent Service - Pure AI Execution Engine
+ * Provider-agnostic AI execution service
+ */
+import { EventEmitter } from 'events';
+import { AIProvider, ExecutionOptions, ExecutionMessage, ModelInfo, ProviderStatus } from './ai-providers/index.js';
+/**
+ * Execution state tracking
+ */
+export interface ExecutionState {
+    id: string;
+    provider: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    startTime: string;
+    endTime?: string;
+    error?: string;
+    messages: ExecutionMessage[];
+    result?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        cost?: number;
+    };
+    abortController?: AbortController;
+}
+/**
+ * Execution request
+ */
+export interface ExecutionRequest {
+    prompt: string;
+    options?: ExecutionOptions;
+    provider?: string;
+    metadata?: Record<string, any>;
+    executionId?: string;
+}
+/**
+ * Execution update event
+ */
+export interface ExecutionUpdate {
+    executionId: string;
+    status: ExecutionState['status'];
+    message?: ExecutionMessage;
+    error?: string;
+}
+/**
+ * Agent Service Configuration
+ */
+export interface AgentServiceConfig {
+    defaultProvider?: string;
+    executionTimeout?: number;
+}
+/**
+ * Pure AI Execution Service
+ * Manages AI providers and executions without business logic
+ */
+export declare class CoreAgentService extends EventEmitter {
+    private providers;
+    private defaultProvider;
+    private executions;
+    private config;
+    constructor(config?: AgentServiceConfig);
+    /**
+     * Register an AI provider
+     */
+    registerProvider(name: string, provider: AIProvider): void;
+    /**
+     * Set default provider
+     */
+    setDefaultProvider(name: string): void;
+    /**
+     * Get default provider name
+     */
+    getDefaultProvider(): string | null;
+    /**
+     * Get provider by name
+     */
+    getProvider(name: string): AIProvider | null;
+    /**
+     * Get all registered providers
+     */
+    getProviders(): Map<string, AIProvider>;
+    /**
+     * Execute a prompt with streaming
+     */
+    execute(request: ExecutionRequest): Promise<string>;
+    /**
+     * Get execution status
+     */
+    getExecutionStatus(executionId: string): ExecutionState | null;
+    /**
+     * Get execution messages
+     */
+    getExecutionMessages(executionId: string): ExecutionMessage[];
+    /**
+     * Stop an execution
+     */
+    stopExecution(executionId: string): Promise<void>;
+    /**
+     * Get all executions
+     */
+    getAllExecutions(): ExecutionState[];
+    /**
+     * Clear completed executions
+     */
+    clearCompletedExecutions(): number;
+    /**
+     * Validate all providers
+     */
+    validateProviders(): Promise<Map<string, ProviderStatus>>;
+    /**
+     * Get available models from all providers
+     */
+    getAvailableModels(): Promise<ModelInfo[]>;
+    /**
+     * Generate execution ID
+     */
+    private generateExecutionId;
+}