vibeman 0.0.3 → 0.0.5

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

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

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

@@ -2,8 +2,8 @@
  * 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';
+export { GeminiCliProvider } from './gemini-cli-provider.js';
+export { AmpCliProvider } from './amp-cli-provider.js';
+export * from './types.js';

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

@@ -2,6 +2,8 @@
  * 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';
+export { GeminiCliProvider } from './gemini-cli-provider.js';
+export { AmpCliProvider } from './amp-cli-provider.js';
+export * from './types.js';

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

@@ -43,9 +43,12 @@ export interface ExecutionOptions {
     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 */
+    /** Optional effort hint for reasoning presets (e.g., 'minimal'|'low'|'medium'|'high'|'extra_high'); informational only */
     effort?: string;
-    /** Enable Codex CLI sandbox bypass flag when running automation that must edit files */
+    /**
+     * Enable Codex CLI full-auto + danger-full-access sandbox mode (>= v0.73) so automation
+     * can edit files and run privileged commands.
+     */
     dangerouslyBypassApprovalsAndSandbox?: boolean;
 }
 /**

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

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

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

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+// Toggle real CLI integration via env
+const USE_REAL = process.env.VITEST_USE_REAL_AMP === 'true';
+describe('AmpCliProvider (mocked)', () => {
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('streams stdout, passes flags, 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 Amp\n')), 10);
+                    setTimeout(() => proc.emit('exit', 0, null), 20);
+                    return proc;
+                },
+                exec: vi.fn(),
+                execFile: vi.fn(),
+            };
+        });
+        const { AmpCliProvider } = await import('./ai-providers/amp-cli-provider.js');
+        const provider = new AmpCliProvider({ defaultTimeoutMs: 1000, ampBinPath: 'amp' });
+        const messages = [];
+        const iter = provider.execute('What is this project about?', {
+            workingDirectory: process.cwd(),
+            model: 'auto',
+            dangerouslyBypassApprovalsAndSandbox: true,
+        });
+        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(captured[0]).toBe('amp');
+        expect(Array.isArray(captured[1])).toBe(true);
+        expect(captured[1]).toContain('-x');
+        // Amp integration runs in auto mode (no explicit model flag)
+        expect(captured[1]).not.toContain('--use-sonnet');
+        // Check bypass
+        expect(captured[1]).toContain('--dangerously-allow-all');
+        // Check prompt passed as arg
+        const promptArg = captured[1][1];
+        expect(promptArg).toContain('What is this project about?');
+    });
+    it('prepends system prompts', 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 proc = new EventEmitter();
+                    proc.stdout = stdout;
+                    setTimeout(() => stdout.emit('data', Buffer.from('Done\n')), 5);
+                    setTimeout(() => proc.emit('exit', 0, null), 10);
+                    return proc;
+                },
+                exec: vi.fn(),
+                execFile: vi.fn(),
+            };
+        });
+        const { AmpCliProvider } = await import('./ai-providers/amp-cli-provider.js');
+        const provider = new AmpCliProvider({ ampBinPath: 'amp' });
+        const iter = provider.execute('Implement feature', {
+            workingDirectory: '/tmp/project',
+            systemPrompt: 'Base system prompt',
+            appendSystemPrompt: 'Additional guidance',
+        });
+        for await (const _ of iter) {
+            // drain iterator
+        }
+        const mockSpawn = await import('child_process');
+        const captured = mockSpawn.__captured();
+        const promptArg = captured[1][1];
+        expect(promptArg).toContain('Base system prompt');
+        expect(promptArg).toContain('Additional guidance');
+        expect(promptArg).toContain('Implement feature');
+    });
+});

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

@@ -35,7 +35,7 @@ describe('CodexCliProvider (mocked)', () => {
             workingDirectory: process.cwd(),
             images: ['a.png', 'b.jpg'],
             effort: 'minimal',
-            model: 'gpt-5',
+            model: 'gpt-5.2',
         });
         for await (const m of iter)
             messages.push(m);
@@ -55,7 +55,7 @@ describe('CodexCliProvider (mocked)', () => {
         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');
+        expect(captured[1][modelIdx + 1]).toBe('gpt-5.2');
         const configIdx = captured[1].indexOf('-c');
         expect(configIdx).toBeGreaterThan(-1);
         expect(captured[1][configIdx + 1]).toBe('model_reasoning_effort=low');
@@ -85,7 +85,7 @@ describe('CodexCliProvider (mocked)', () => {
         const messages = [];
         const iter = provider.execute('Solve with depth', {
             workingDirectory: process.cwd(),
-            model: 'gpt-5-codex-high',
+            model: 'gpt-5.1-codex-max-extra-high',
         });
         for await (const m of iter)
             messages.push(m);
@@ -93,10 +93,10 @@ describe('CodexCliProvider (mocked)', () => {
         const captured = mockSpawn.__captured();
         const modelIdx = captured[1].indexOf('--model');
         expect(modelIdx).toBeGreaterThan(-1);
-        expect(captured[1][modelIdx + 1]).toBe('gpt-5-codex');
+        expect(captured[1][modelIdx + 1]).toBe('gpt-5.1-codex-max');
         const configIdx = captured[1].indexOf('-c');
         expect(configIdx).toBeGreaterThan(-1);
-        expect(captured[1][configIdx + 1]).toBe('model_reasoning_effort=high');
+        expect(captured[1][configIdx + 1]).toBe('model_reasoning_effort=extra_high');
     });
     it('prepends system prompts and toggles sandbox bypass flag', async () => {
         vi.resetModules();
@@ -133,9 +133,11 @@ describe('CodexCliProvider (mocked)', () => {
         const captured = mockSpawn.__captured();
         expect(captured[1][1]).toContain('Base system prompt');
         expect(captured[1][1]).toContain('Additional guidance');
-        const bypassIdx = captured[1].indexOf('--dangerously-bypass-approvals-and-sandbox');
-        expect(bypassIdx).toBeGreaterThan(-1);
-        expect(captured[1][bypassIdx + 1]).toBeUndefined();
+        const fullAutoIdx = captured[1].indexOf('--full-auto');
+        expect(fullAutoIdx).toBeGreaterThan(-1);
+        const sandboxIdx = captured[1].indexOf('--sandbox');
+        expect(sandboxIdx).toBeGreaterThan(-1);
+        expect(captured[1][sandboxIdx + 1]).toBe('danger-full-access');
     });
 });
 // Real integration (opt-in)