vibeman 0.0.3 → 0.0.5

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

@@ -20,6 +20,7 @@ export declare class AgentService extends EventEmitter {
     private initialized;
     private routingPolicyManager;
     private genericStates;
+    private completionInterceptors;
     private readonly defaultTools;
     private readonly systemPrompts;
     constructor(taskService: TaskService, projectRoot?: string, worktreeService?: WorktreeService);
@@ -38,6 +39,9 @@ export declare class AgentService extends EventEmitter {
     private getAgentConfig;
     private initialize;
     private setupEventForwarding;
+    registerCompletionInterceptor(executionId: string, handler: (data: any) => Promise<boolean>): void;
+    clearCompletionInterceptor(executionId: string): void;
+    finalizeExecution(executionId: string, status: AgentExecution['status'], error?: string, logs?: string[]): Promise<void>;
     /**
      * Create a concise, human-readable line from a structured execution message
      */

package/dist/runtime/api/agent/agent-service.js

@@ -5,7 +5,7 @@ import { log } from '../lib/logger.js';
 import { generateId } from '../lib/id-generator.js';
 import { getProjectRoot } from '../lib/server/project-root.js';
 import { CoreAgentService } from './core-agent-service.js';
-import { ClaudeCodeAdapter, CodexCliProvider } from './ai-providers/index.js';
+import { ClaudeCodeAdapter, CodexCliProvider, GeminiCliProvider, AmpCliProvider, } from './ai-providers/index.js';
 import { PromptService } from './prompt-service.js';
 import { RoutingPolicyManager, } from './routing-policy.js';
 import { isTestEnv } from '../utils/env.js';
@@ -36,6 +36,7 @@ export class AgentService extends EventEmitter {
         this.initialized = false;
         // Track lightweight status for generic (non-core) executions
         this.genericStates = new Map();
+        this.completionInterceptors = new Map();
         // Centralized default tool sets per operation
         // TODO: need to be more granular, based on the task type and the toolset available for the AI provider
         this.defaultTools = {
@@ -51,7 +52,7 @@ export class AgentService extends EventEmitter {
                 base: 'You are an expert software engineer. Follow best practices, write clean maintainable code, and ensure your implementation is robust and well-tested.',
                 rerun: 'You are continuing a rerun of this task. Use prior context and focus on fixes.',
             },
-            improve_task: 'You are an expert at improving task specifications. Respond with ONLY a valid JSON object containing type, priority, and content fields. No additional text or formatting.',
+            improve_task: 'You are an expert at improving task specifications. Detect the language of the input task content and respond in that SAME language for all markdown sections. Keep enum fields (type, priority) in English. Respond with ONLY a valid JSON object containing type, priority, and content fields. No additional text or formatting.',
             ai_codereview: 'You are a senior developer performing thorough code review. Focus on quality, security, and best practices. Respond with ONLY a valid JSON object. Ultrathink.',
             ai_merge: 'You are an expert at resolving merge conflicts and integrating code changes. Ensure clean merges that maintain code consistency and functionality.',
         };
@@ -151,6 +152,16 @@ export class AgentService extends EventEmitter {
             defaultWorkingDirectory: this.projectRoot,
         });
         this.coreAgentService.registerProvider('codex', codexProvider);
+        // Register Gemini CLI provider (not default)
+        const geminiProvider = new GeminiCliProvider({
+            defaultWorkingDirectory: this.projectRoot,
+        });
+        this.coreAgentService.registerProvider('gemini', geminiProvider);
+        // Register Amp CLI provider (not default)
+        const ampProvider = new AmpCliProvider({
+            defaultWorkingDirectory: this.projectRoot,
+        });
+        this.coreAgentService.registerProvider('amp', ampProvider);
         // Initialize prompt service
         this.promptService = new PromptService(this.projectRoot, this.taskService);
         // Initialize routing policy manager
@@ -176,6 +187,26 @@ export class AgentService extends EventEmitter {
             });
         });
         this.coreAgentService.on('executionCompleted', (data) => {
+            const interceptor = this.completionInterceptors.get(data.executionId);
+            if (interceptor) {
+                this.completionInterceptors.delete(data.executionId);
+                Promise.resolve(interceptor(data))
+                    .then((handled) => {
+                    if (handled)
+                        return;
+                    void this.logPersistence.completeExecution(data.executionId, 'completed');
+                    const logs = this.coreAgentService
+                        .getExecutionMessages(data.executionId)
+                        .map((m) => this.summarizeMessage(m));
+                    this.emit('executionUpdated', {
+                        executionId: data.executionId,
+                        status: 'completed',
+                        logs,
+                    });
+                })
+                    .catch((error) => log.error('Completion interceptor failed', error, 'agent-service'));
+                return;
+            }
             void this.logPersistence.completeExecution(data.executionId, 'completed');
             const logs = this.coreAgentService
                 .getExecutionMessages(data.executionId)
@@ -187,6 +218,7 @@ export class AgentService extends EventEmitter {
             });
         });
         this.coreAgentService.on('executionFailed', (data) => {
+            this.completionInterceptors.delete(data.executionId);
             void this.logPersistence.completeExecution(data.executionId, 'failed', data.error);
             const logs = this.coreAgentService
                 .getExecutionMessages(data.executionId)
@@ -199,6 +231,7 @@ export class AgentService extends EventEmitter {
             });
         });
         this.coreAgentService.on('executionCancelled', (data) => {
+            this.completionInterceptors.delete(data.executionId);
             void this.logPersistence.completeExecution(data.executionId, 'cancelled');
             const logs = this.coreAgentService
                 .getExecutionMessages(data.executionId)
@@ -210,6 +243,28 @@ export class AgentService extends EventEmitter {
             });
         });
     }
+    registerCompletionInterceptor(executionId, handler) {
+        this.completionInterceptors.set(executionId, handler);
+    }
+    clearCompletionInterceptor(executionId) {
+        this.completionInterceptors.delete(executionId);
+    }
+    async finalizeExecution(executionId, status, error, logs) {
+        this.completionInterceptors.delete(executionId);
+        if (status === 'completed') {
+            await this.logPersistence.completeExecution(executionId, 'completed');
+        }
+        else {
+            await this.logPersistence.completeExecution(executionId, status, error);
+        }
+        const finalLogs = logs ?? this.getExecutionLogs(executionId);
+        this.emit('executionUpdated', {
+            executionId,
+            status,
+            logs: finalLogs,
+            error,
+        });
+    }
     /**
      * Create a concise, human-readable line from a structured execution message
      */
@@ -297,7 +352,11 @@ export class AgentService extends EventEmitter {
             }
         }
         catch (error) {
-            log.error('Failed to create worktree, using main directory', error, 'agent-service');
+            const msg = `Failed to create worktree for task ${taskId}: ${error instanceof Error ? error.message : String(error)}`;
+            log.error(msg, error, 'agent-service');
+            await this.logPersistence.logMessage(executionId, msg, 'error', { taskId, workflowId });
+            await this.completeGenericExecution(executionId, 'failed', msg);
+            throw new Error(msg);
         }
         // Generate task prompt with workflow configuration for dynamic instructions
         const prompt = await this.promptService.generateTaskPrompt(task, options?.workflowConfig);

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

@@ -0,0 +1,38 @@
+/**
+ * Amp CLI Provider
+ * Headless wrapper around the Amp CLI `amp -x` command.
+ */
+import { AIProvider, ExecutionMessage, ExecutionOptions, ModelInfo, ProviderCapabilities, ProviderStatus } from './types.js';
+export interface AmpCliConfig {
+    ampBinPath?: string;
+    defaultWorkingDirectory?: string;
+    /**
+     * Amp CLI does not support explicit model selection in this integration.
+     * Kept for backwards compatibility but ignored.
+     */
+    defaultModel?: string;
+    defaultTimeoutMs?: number;
+}
+export declare class AmpCliProvider implements AIProvider {
+    private config;
+    readonly name = "amp";
+    readonly displayName = "Amp CLI";
+    constructor(config?: AmpCliConfig);
+    private resolveExecutable;
+    execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
+    executeSync(prompt: string, options?: ExecutionOptions): Promise<{
+        id: string;
+        provider: string;
+        model: string;
+        content: string;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+        duration: number;
+    }>;
+    detectAvailableModels(): Promise<ModelInfo[]>;
+    validateSetup(): Promise<ProviderStatus>;
+    getCapabilities(): ProviderCapabilities;
+}

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

@@ -0,0 +1,268 @@
+/**
+ * Amp CLI Provider
+ * Headless wrapper around the Amp CLI `amp -x` 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 AmpCliProvider {
+    constructor(config = {}) {
+        this.config = config;
+        this.name = 'amp';
+        this.displayName = 'Amp CLI';
+    }
+    async resolveExecutable() {
+        if (this.config.ampBinPath)
+            return this.config.ampBinPath;
+        // Use enhanced detection service
+        const detectionService = getProviderDetectionService();
+        const result = await detectionService.detectProvider('amp');
+        if (result.found && result.path) {
+            return result.path;
+        }
+        // Fallback: try old settings-based approach (though new for Amp, following pattern)
+        const settingsBinPath = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.agents?.providers?.amp?.binPath;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        if (settingsBinPath?.trim())
+            return settingsBinPath.trim();
+        // Default to binary name (resolve via PATH)
+        return 'amp';
+    }
+    async *execute(prompt, options) {
+        // Effective options
+        const cwd = options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd();
+        // Amp CLI runs in an automatic mode for model/tool selection in this integration.
+        // We intentionally ignore any requested model.
+        const requestedModel = options?.model || this.config.defaultModel;
+        const model = 'auto';
+        const timeoutMs = options?.timeout ?? this.config.defaultTimeoutMs ?? 10 * 60 * 1000; // 10m
+        const systemPrompt = options?.systemPrompt?.trim();
+        const appendSystemPrompt = options?.appendSystemPrompt?.trim();
+        // Construct effective prompt
+        const promptSegments = [];
+        if (systemPrompt) {
+            promptSegments.push(systemPrompt);
+        }
+        if (appendSystemPrompt) {
+            promptSegments.push(appendSystemPrompt);
+        }
+        promptSegments.push(prompt);
+        const effectivePrompt = promptSegments.join('\n\n');
+        // Build argv for `amp -x`
+        const argv = ['-x', effectivePrompt];
+        if (options?.dangerouslyBypassApprovalsAndSandbox) {
+            argv.push('--dangerously-allow-all');
+        }
+        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,
+            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,
+                requestedModel,
+                systemPrompt,
+                appendSystemPrompt,
+                dangerouslyBypassApprovalsAndSandbox: !!options?.dangerouslyBypassApprovalsAndSandbox,
+            },
+        };
+        let stdoutBuf = '';
+        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);
+        };
+        const onAbort = () => {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                /* ignore */
+            }
+            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 });
+        }
+        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 }));
+        });
+        // 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') {
+                const lines = flushNewOutput();
+                if (lines && lines.length) {
+                    for (const text of lines) {
+                        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) {
+                    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
+                : `amp exited ${exit.signal ? 'by ' + exit.signal : 'with code ' + exit.code}`,
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        };
+        yield resultMsg;
+    }
+    async executeSync(prompt, options) {
+        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: 'auto',
+            content,
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+            duration: Date.now() - start,
+        };
+    }
+    async detectAvailableModels() {
+        const capabilities = ['code', 'analysis', 'tools', 'vision', 'reasoning'];
+        const makeModel = (id, displayName) => ({
+            id,
+            name: id,
+            displayName,
+            provider: this.name,
+            contextWindow: 128000,
+            maxOutputTokens: 16384,
+            capabilities,
+        });
+        return [makeModel('auto', 'Auto (recommended)')];
+    }
+    async validateSetup() {
+        try {
+            const detectionService = getProviderDetectionService();
+            const result = await detectionService.detectProvider('amp');
+            if (!result.found) {
+                return {
+                    available: false,
+                    error: result.error || 'Amp CLI not found. Install Amp and ensure it is in your PATH.',
+                    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(),
+            };
+        }
+    }
+    getCapabilities() {
+        return {
+            streaming: true,
+            tools: true,
+            functionCalling: false,
+            vision: true,
+            codeExecution: true,
+            maxContextWindow: 128000,
+            maxOutputTokens: 8192,
+        };
+    }
+}

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

@@ -6,6 +6,29 @@ 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;
@@ -40,9 +63,12 @@ export class CodexCliProvider {
     normalizeReasoningEffort(value) {
         if (!value)
             return undefined;
-        const normalized = value.toLowerCase();
+        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
@@ -55,7 +81,9 @@ export class CodexCliProvider {
         }
         const trimmed = model.trim();
         const normalized = trimmed.toLowerCase();
-        const match = normalized.match(/^(gpt-5(?:-codex)?)(?:-(minimal|low|medium|high))?$/);
+        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,
@@ -106,7 +134,9 @@ export class CodexCliProvider {
             argv.push('--image', images.join(','));
         }
         if (options?.dangerouslyBypassApprovalsAndSandbox) {
-            argv.push('--dangerously-bypass-approvals-and-sandbox');
+            // 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, {
@@ -292,16 +322,14 @@ export class CodexCliProvider {
             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'),
+        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 {

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

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