vibeman 0.0.3 → 0.0.6

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

@@ -1,347 +0,0 @@
-/**
- * Codex CLI Provider
- * Headless wrapper around the Codex CLI `codex exec` command.
- */
-import { spawn } from 'child_process';
-import { getSettingsService } from '../../settings-service.js';
-import { getProviderDetectionService } from '../../lib/provider-detection.js';
-import { logger } from '../../lib/logger.js';
-export class CodexCliProvider {
-    constructor(config = {}) {
-        this.config = config;
-        this.name = 'codex';
-        this.displayName = 'Codex CLI';
-    }
-    async resolveExecutable() {
-        if (this.config.codexBinPath)
-            return this.config.codexBinPath;
-        // Use enhanced detection service
-        const detectionService = getProviderDetectionService();
-        const result = await detectionService.detectProvider('codex');
-        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?.codex?.binPath;
-            }
-            catch {
-                return undefined;
-            }
-        })();
-        if (settingsBinPath?.trim())
-            return settingsBinPath.trim();
-        // Default to binary name (resolve via PATH)
-        return 'codex';
-    }
-    normalizeReasoningEffort(value) {
-        if (!value)
-            return undefined;
-        const normalized = value.toLowerCase();
-        if (normalized === 'minimal')
-            return 'low';
-        const allowed = ['low', 'medium', 'high'];
-        return allowed.includes(normalized)
-            ? normalized
-            : undefined;
-    }
-    resolveModelSpec(model, fallbackEffort) {
-        const fallback = this.normalizeReasoningEffort(fallbackEffort);
-        if (!model) {
-            return { reasoning: fallback };
-        }
-        const trimmed = model.trim();
-        const normalized = trimmed.toLowerCase();
-        const match = normalized.match(/^(gpt-5(?:-codex)?)(?:-(minimal|low|medium|high))?$/);
-        if (!match) {
-            return {
-                cliModel: trimmed,
-                requestedModel: trimmed,
-                reasoning: fallback,
-            };
-        }
-        const baseModel = match[1];
-        const reasoning = this.normalizeReasoningEffort(match[2]);
-        return {
-            cliModel: baseModel,
-            requestedModel: trimmed,
-            reasoning: reasoning ?? fallback,
-        };
-    }
-    async *execute(prompt, options) {
-        // Effective options
-        const cwd = options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd();
-        const resolvedModel = this.resolveModelSpec(options?.model || this.config.defaultModel, options?.effort);
-        const model = resolvedModel.cliModel;
-        const images = (options?.images || []).filter(Boolean);
-        const reasoningEffort = resolvedModel.reasoning;
-        const timeoutMs = options?.timeout ?? this.config.defaultTimeoutMs ?? 10 * 60 * 1000; // 10m
-        const systemPrompt = options?.systemPrompt?.trim();
-        const appendSystemPrompt = options?.appendSystemPrompt?.trim();
-        const promptSegments = [];
-        if (systemPrompt) {
-            promptSegments.push(systemPrompt);
-        }
-        if (appendSystemPrompt) {
-            promptSegments.push(appendSystemPrompt);
-        }
-        promptSegments.push(prompt);
-        const effectivePrompt = promptSegments.join('\n\n');
-        // Build argv for `codex exec` (non-interactive automation mode)
-        const argv = ['exec', effectivePrompt];
-        if (model) {
-            argv.push('--model', model);
-        }
-        if (reasoningEffort) {
-            argv.push('-c', `model_reasoning_effort=${reasoningEffort}`);
-        }
-        // 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(','));
-        }
-        if (options?.dangerouslyBypassApprovalsAndSandbox) {
-            argv.push('--dangerously-bypass-approvals-and-sandbox');
-        }
-        const cmd = await 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: resolvedModel.requestedModel || 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: reasoningEffort || options?.effort,
-                systemPrompt,
-                appendSystemPrompt,
-                dangerouslyBypassApprovalsAndSandbox: !!options?.dangerouslyBypassApprovalsAndSandbox,
-            },
-        };
-        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();
-        const resolvedModel = this.resolveModelSpec(options?.model || this.config.defaultModel, options?.effort);
-        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: resolvedModel.requestedModel || resolvedModel.cliModel || 'default',
-            content,
-            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-            duration: Date.now() - start,
-        };
-    }
-    async detectAvailableModels() {
-        const capabilities = ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'];
-        const makeModel = (id, displayName) => ({
-            id,
-            name: id,
-            displayName,
-            provider: this.name,
-            contextWindow: 256000,
-            maxOutputTokens: 16384,
-            capabilities,
-        });
-        return [
-            makeModel('gpt-5', 'gpt‑5'),
-            makeModel('gpt-5-low', 'gpt‑5 · low reasoning'),
-            makeModel('gpt-5-medium', 'gpt‑5 · medium reasoning'),
-            makeModel('gpt-5-high', 'gpt‑5 · high reasoning'),
-            makeModel('gpt-5-codex', 'gpt‑5 Codex'),
-            makeModel('gpt-5-codex-low', 'gpt‑5 Codex · low reasoning'),
-            makeModel('gpt-5-codex-medium', 'gpt‑5 Codex · medium reasoning'),
-            makeModel('gpt-5-codex-high', 'gpt‑5 Codex · high reasoning'),
-        ];
-    }
-    async validateSetup() {
-        try {
-            const detectionService = getProviderDetectionService();
-            const result = await detectionService.detectProvider('codex');
-            if (!result.found) {
-                return {
-                    available: false,
-                    error: result.error ||
-                        'Codex CLI not found. Install from https://github.com/openai/codex (see Getting Started: CLI usage).',
-                    models: [],
-                    capabilities: this.getCapabilities(),
-                };
-            }
-            return {
-                available: true,
-                models: await this.detectAvailableModels(),
-                capabilities: this.getCapabilities(),
-            };
-        }
-        catch (error) {
-            logger.error(error);
-            return {
-                available: false,
-                error: error instanceof Error ? error.message : String(error),
-                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

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,182 +0,0 @@
-/**
- * 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;
-    /** Enable Codex CLI sandbox bypass flag when running automation that must edit files */
-    dangerouslyBypassApprovalsAndSandbox?: boolean;
-}
-/**
- * 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

@@ -1,5 +0,0 @@
-/**
- * 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

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