vibeman 0.0.5 → 0.0.6

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

@@ -1,375 +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';
-const CODEX_BASE_MODELS = [
-    'gpt-5.1-codex-max',
-    'gpt-5.1-codex',
-    'gpt-5.1-codex-mini',
-    'gpt-5.2',
-    'gpt-5.1',
-];
-const CODEX_BASE_LABELS = {
-    'gpt-5.1-codex-max': 'gpt-5.1 Codex Max (current)',
-    'gpt-5.1-codex': 'gpt-5.1 Codex',
-    'gpt-5.1-codex-mini': 'gpt-5.1 Codex Mini',
-    'gpt-5.2': 'gpt-5.2',
-    'gpt-5.1': 'gpt-5.1',
-};
-const REASONING_SUFFIXES = [
-    'minimal',
-    'low',
-    'medium',
-    'high',
-    'extra',
-    'extra-high',
-    'extra_high',
-];
-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().replace(/\s+/g, '-');
-        if (normalized === 'minimal')
-            return 'low';
-        if (normalized === 'extra-high' || normalized === 'extra_high' || normalized === 'extra') {
-            return 'extra_high';
-        }
-        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 basePattern = CODEX_BASE_MODELS.map((m) => m.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')).join('|');
-        const reasoningPattern = [...REASONING_SUFFIXES].join('|');
-        const match = normalized.match(new RegExp(`^(${basePattern})(?:-(${reasoningPattern}))?$`));
-        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) {
-            // Codex CLI >= 0.73.0 replaces the legacy bypass flag with --full-auto + sandbox selection
-            argv.push('--full-auto');
-            argv.push('--sandbox', 'danger-full-access');
-        }
-        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,
-        });
-        const addReasoningVariants = (base, label) => [
-            makeModel(base, label),
-            makeModel(`${base}-low`, `${label} · low reasoning`),
-            makeModel(`${base}-medium`, `${label} · medium reasoning`),
-            makeModel(`${base}-high`, `${label} · high reasoning`),
-            makeModel(`${base}-extra-high`, `${label} · extra-high reasoning`),
-        ];
-        return Object.entries(CODEX_BASE_LABELS).flatMap(([id, label]) => addReasoningVariants(id, label));
-    }
-    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/gemini-cli-provider.d.ts

@@ -1,24 +0,0 @@
-/**
- * Gemini CLI Provider
- * Headless wrapper around the Gemini CLI binary (default command `gemini`).
- */
-import { AIProvider, ExecutionMessage, ExecutionOptions, ModelInfo, ProviderCapabilities, ProviderStatus } from './types.js';
-export interface GeminiCliConfig {
-    geminiBinPath?: string;
-    defaultWorkingDirectory?: string;
-    defaultModel?: string;
-    defaultTimeoutMs?: number;
-}
-export declare class GeminiCliProvider implements AIProvider {
-    private config;
-    readonly name = "gemini";
-    readonly displayName = "Gemini CLI";
-    constructor(config?: GeminiCliConfig);
-    private resolveExecutable;
-    private normalizeReasoningEffort;
-    private resolveModelSpec;
-    execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
-    detectAvailableModels(): Promise<ModelInfo[]>;
-    validateSetup(): Promise<ProviderStatus>;
-    getCapabilities(): ProviderCapabilities;
-}

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

@@ -1,291 +0,0 @@
-/**
- * Gemini CLI Provider
- * Headless wrapper around the Gemini CLI binary (default command `gemini`).
- */
-import { spawn } from 'child_process';
-import { getSettingsService } from '../../settings-service.js';
-import { getProviderDetectionService } from '../../lib/provider-detection.js';
-export class GeminiCliProvider {
-    constructor(config = {}) {
-        this.config = config;
-        this.name = 'gemini';
-        this.displayName = 'Gemini CLI';
-    }
-    async resolveExecutable() {
-        if (this.config.geminiBinPath)
-            return this.config.geminiBinPath;
-        // Use enhanced detection service
-        const detectionService = getProviderDetectionService();
-        const result = await detectionService.detectProvider('gemini');
-        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?.gemini?.binPath;
-            }
-            catch {
-                return undefined;
-            }
-        })();
-        if (settingsBinPath?.trim())
-            return settingsBinPath.trim();
-        // Default to binary name (resolve via PATH)
-        return 'gemini';
-    }
-    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();
-        // Recognize a few common Gemini model aliases; keep passthrough for others
-        const knownPrefixes = [
-            'gemini-3-pro-preview',
-            'gemini-3-flash-preview',
-            'gemini-2.5-pro',
-            'gemini-2.5-flash',
-            'gemini-2.5-flash-lite',
-            'gemini-3',
-            'gemini-2.5',
-            'gemini',
-        ];
-        const isKnown = knownPrefixes.some((p) => normalized.startsWith(p));
-        return {
-            cliModel: isKnown ? trimmed : trimmed,
-            requestedModel: trimmed,
-            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 timeoutMs = options?.timeout ?? this.config.defaultTimeoutMs ?? 10 * 60 * 1000; // 10m
-        const temperature = options?.temperature;
-        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 `gemini` CLI. Use a simple subcommand 'chat' with flags; passthrough prompt as arg.
-        const argv = [];
-        // Prefer a subcommand if used by the CLI; otherwise just supply flags
-        // We keep it generic so detection/validation works even if CLI differs
-        if (model) {
-            argv.push('--model', model);
-        }
-        if (typeof temperature === 'number') {
-            argv.push('--temperature', String(temperature));
-        }
-        if (images.length) {
-            argv.push('--image', images.join(','));
-        }
-        // YOLO mode auto-approves tool calls to allow code edits without prompts
-        argv.push('--yolo');
-        // Push the prompt last (many CLIs accept final arg as the prompt)
-        argv.push(effectivePrompt);
-        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,
-                systemPrompt,
-                appendSystemPrompt,
-            },
-        };
-        let stdoutBuf = '';
-        let finished = false;
-        let lastFlushedIndex = 0;
-        let lineCarry = '';
-        const flushNewOutput = () => {
-            const newChunk = stdoutBuf.slice(lastFlushedIndex);
-            if (!newChunk)
-                return;
-            lastFlushedIndex = stdoutBuf.length;
-            lineCarry += newChunk;
-            const parts = lineCarry.split(/\r?\n/);
-            lineCarry = parts.pop() || '';
-            return parts.map((l) => l.trimEnd());
-        };
-        const onAbort = () => {
-            try {
-                child.kill('SIGTERM');
-            }
-            catch (err) {
-                void err; // ignore if process already exited
-            }
-            setTimeout(() => {
-                if (!finished) {
-                    try {
-                        child.kill('SIGKILL');
-                    }
-                    catch (err) {
-                        void err; // ignore if process already exited
-                    }
-                }
-            }, 3000);
-        };
-        if (options?.abortSignal) {
-            if (options.abortSignal.aborted)
-                onAbort();
-            else
-                options.abortSignal.addEventListener('abort', onAbort, { once: true });
-        }
-        const guard = setTimeout(() => onAbort(), timeoutMs);
-        child.stdout?.on('data', (data) => {
-            stdoutBuf += data.toString('utf8');
-        });
-        const exitPromise = new Promise((resolve) => {
-            child.on('exit', (code, signal) => resolve({ code, signal }));
-        });
-        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') {
-                const lines = flushNewOutput();
-                if (lines && lines.length) {
-                    for (const text of lines) {
-                        if (!text)
-                            continue;
-                        yield { type: 'assistant', timestamp: new Date().toISOString(), content: text };
-                    }
-                }
-                finished = true;
-                exitStatus = exit;
-                break;
-            }
-            const lines = flushNewOutput();
-            if (lines && lines.length) {
-                for (const text of lines) {
-                    if (!text)
-                        continue;
-                    yield { type: 'assistant', timestamp: new Date().toISOString(), content: text };
-                }
-            }
-        }
-        const exit = exitStatus ?? (await exitPromise);
-        finished = true;
-        clearTimeout(guard);
-        if (lineCarry.trim()) {
-            yield {
-                type: 'assistant',
-                timestamp: new Date().toISOString(),
-                content: lineCarry.trimEnd(),
-            };
-            lineCarry = '';
-        }
-        const success = (exit.code ?? 1) === 0 && !exit.signal;
-        const remainingStdout = stdoutBuf.trim();
-        const resultMsg = {
-            type: 'result',
-            timestamp: new Date().toISOString(),
-            success,
-            result: success ? (remainingStdout || '').toString() : undefined,
-            error: success
-                ? undefined
-                : `gemini exited ${exit.signal ? 'by ' + exit.signal : 'with code ' + exit.code}`,
-            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-        };
-        yield resultMsg;
-    }
-    async detectAvailableModels() {
-        const capabilities = ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'];
-        const makeModel = (id, displayName) => ({
-            id,
-            name: id,
-            displayName,
-            provider: this.name,
-            contextWindow: 128000,
-            maxOutputTokens: 8192,
-            capabilities,
-        });
-        return [
-            makeModel('gemini-3-pro-preview', 'Gemini 3 Pro Preview'),
-            makeModel('gemini-3-flash-preview', 'Gemini 3 Flash Preview'),
-            makeModel('gemini-2.5-pro', 'Gemini 2.5 Pro'),
-            makeModel('gemini-2.5-flash', 'Gemini 2.5 Flash'),
-            makeModel('gemini-2.5-flash-lite', 'Gemini 2.5 Flash Lite'),
-        ];
-    }
-    async validateSetup() {
-        try {
-            const detectionService = getProviderDetectionService();
-            const result = await detectionService.detectProvider('gemini');
-            if (!result.found) {
-                return {
-                    available: false,
-                    error: result.error ||
-                        'Gemini CLI not found. Install the Gemini CLI and ensure it is available on PATH as "gemini" or set VIBEMAN_GEMINI_BIN.',
-                    models: [],
-                    capabilities: this.getCapabilities(),
-                };
-            }
-            return {
-                available: true,
-                models: await this.detectAvailableModels(),
-                capabilities: this.getCapabilities(),
-            };
-        }
-        catch (error) {
-            return {
-                available: false,
-                error: error instanceof Error ? error.message : String(error),
-                models: [],
-                capabilities: this.getCapabilities(),
-            };
-        }
-    }
-    getCapabilities() {
-        return {
-            streaming: true,
-            tools: true,
-            functionCalling: false,
-            vision: true,
-            codeExecution: true,
-            maxContextWindow: 128000,
-            maxOutputTokens: 8192,
-        };
-    }
-}