vibeman 0.0.2 → 0.0.5

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

@@ -2,7 +2,7 @@ import { EventEmitter } from 'events';
 import { Task, WorktreeInfo, AgentExecution, VibingPhase, QualityResults } from '../types/index.js';
 import { TaskService } from '../tasks/task-service.js';
 import { WorktreeService } from '../vcs/worktree-service.js';
-import { RoutingPolicyManager, type ResolvedProvider } from './routing-policy.js';
+import { RoutingPolicyManager, type RoutableOperation, type ResolvedProvider } from './routing-policy.js';
 export interface AgentExecutionUpdate {
     executionId: string;
     status: AgentExecution['status'];
@@ -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,11 +39,9 @@ export declare class AgentService extends EventEmitter {
     private getAgentConfig;
     private initialize;
     private setupEventForwarding;
-    /**
-     * Map core agent update to legacy format
-     * TODO: remove this later in a separate task, need to migrate the UI to handle raw message streaming
-     */
-    private mapToLegacyUpdate;
+    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
      */
@@ -62,6 +61,11 @@ export declare class AgentService extends EventEmitter {
             qualityResults?: QualityResults;
             lastLogs?: string[];
             attempt?: number;
+            aiReview?: {
+                summary?: string;
+                recommendations?: string[];
+                score?: number;
+            };
         };
         providerOverride?: Partial<ResolvedProvider>;
         workflowConfig?: import('../types/index.js').VibingConfig;
@@ -213,6 +217,7 @@ export declare class AgentService extends EventEmitter {
      * Resolve provider for specific operation with failover support
      */
     private resolveProviderForOperation;
+    previewProviderForOperation(operation: RoutableOperation, overrides?: Partial<ResolvedProvider>): Promise<ResolvedProvider>;
     /**
      * Execute with provider resolution and failover
      */

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,10 +36,12 @@ 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 = {
             execute_task: fullTools,
+            quality_checks: fullTools,
             improve_task: fullTools,
             code_review: fullTools,
             ai_merge: fullTools,
@@ -50,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.',
         };
@@ -150,20 +152,20 @@ 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
         this.routingPolicyManager = new RoutingPolicyManager();
-        // Create example policy file if needed (guarded for mocked environments)
-        try {
-            const maybePromise = this.routingPolicyManager.createExamplePolicy?.();
-            if (maybePromise && typeof maybePromise.catch === 'function') {
-                maybePromise.catch((err) => log.warn('Failed to create example policy', err, 'agent-service'));
-            }
-        }
-        catch (err) {
-            log.warn('Failed to trigger example policy creation', err, 'agent-service');
-        }
         // Set up event forwarding
         this.setupEventForwarding();
         this.initialized = true;
@@ -185,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)
@@ -196,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)
@@ -208,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)
@@ -219,22 +243,27 @@ export class AgentService extends EventEmitter {
             });
         });
     }
-    /**
-     * Map core agent update to legacy format
-     * TODO: remove this later in a separate task, need to migrate the UI to handle raw message streaming
-     */
-    mapToLegacyUpdate(data) {
-        const messages = this.coreAgentService
-            .getExecutionMessages(data.executionId)
-            .map((m) => this.summarizeMessage(m));
-        return {
-            executionId: data.executionId,
-            status: data.status ||
-                this.coreAgentService.getExecutionStatus(data.executionId)?.status ||
-                'running',
-            logs: messages,
-            error: data.error,
-        };
+    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
@@ -323,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);
@@ -404,6 +437,28 @@ export class AgentService extends EventEmitter {
                 }
             }
         }
+        const review = rerun.aiReview;
+        if (review) {
+            parts.push('AI code review feedback from previous attempt:');
+            if (typeof review.score === 'number') {
+                parts.push(`- Quality score: ${review.score}`);
+            }
+            if (review.summary) {
+                parts.push(`- Summary: ${review.summary}`);
+            }
+            const recs = Array.isArray(review.recommendations)
+                ? review.recommendations.filter((r) => typeof r === 'string' && r.trim().length)
+                : [];
+            if (recs.length) {
+                parts.push('Recommendations:');
+                for (const item of recs.slice(0, 5)) {
+                    parts.push(`  * ${item}`);
+                }
+                if (recs.length > 5) {
+                    parts.push(`  * ...and ${recs.length - 5} more recommendations`);
+                }
+            }
+        }
         parts.push('Instruction: Address the reasons above. Avoid repeating prior mistakes. Keep changes scoped and test thoroughly. ');
         return parts.join('\n');
     }
@@ -801,6 +856,9 @@ export class AgentService extends EventEmitter {
     async resolveProviderForOperation(operation, overrides) {
         return await this.routingPolicyManager.resolveProviderForOperation(operation, overrides);
     }
+    async previewProviderForOperation(operation, overrides) {
+        return await this.resolveProviderForOperation(operation, overrides);
+    }
     /**
      * Execute with provider resolution and failover
      */
@@ -815,6 +873,16 @@ export class AgentService extends EventEmitter {
             workingDirectory: options.workingDirectory,
             timeout: options.timeout,
         };
+        // Persist a clear log line indicating chosen provider/model for this operation
+        try {
+            const execId = options?.executionId;
+            if (execId) {
+                await this.logPersistence.logMessage(execId, `Using provider: ${resolved.provider}${resolved.model ? ` (model: ${resolved.model})` : ''}`, 'info', { operation, resolved });
+            }
+        }
+        catch {
+            // best-effort logging; ignore
+        }
         // Default maxTokens from settings when not provided (unlimited if omitted)
         try {
             if (executionOptions.maxTokens === undefined) {

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.d.ts

@@ -15,6 +15,8 @@ export declare class CodexCliProvider implements AIProvider {
     readonly displayName = "Codex CLI";
     constructor(config?: CodexCliConfig);
     private resolveExecutable;
+    private normalizeReasoningEffort;
+    private resolveModelSpec;
     execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
     executeSync(prompt: string, options?: ExecutionOptions): Promise<{
         id: string;