vibeman 0.0.1 → 0.0.3

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

@@ -4,6 +4,7 @@
  */
 import { spawn } from 'child_process';
 import { getSettingsService } from '../../settings-service.js';
+import { getProviderDetectionService } from '../../lib/provider-detection.js';
 import { logger } from '../../lib/logger.js';
 export class CodexCliProvider {
     constructor(config = {}) {
@@ -11,10 +12,16 @@ export class CodexCliProvider {
         this.name = 'codex';
         this.displayName = 'Codex CLI';
     }
-    resolveExecutable() {
+    async resolveExecutable() {
         if (this.config.codexBinPath)
             return this.config.codexBinPath;
-        // Check settings first
+        // 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();
@@ -30,32 +37,67 @@ export class CodexCliProvider {
         // Default to binary name (resolve via PATH)
         return 'codex';
     }
+    normalizeReasoningEffort(value) {
+        if (!value)
+            return undefined;
+        const normalized = value.toLowerCase();
+        if (normalized === 'minimal')
+            return 'low';
+        const allowed = ['low', 'medium', 'high'];
+        return allowed.includes(normalized)
+            ? normalized
+            : undefined;
+    }
+    resolveModelSpec(model, fallbackEffort) {
+        const fallback = this.normalizeReasoningEffort(fallbackEffort);
+        if (!model) {
+            return { reasoning: fallback };
+        }
+        const trimmed = model.trim();
+        const normalized = trimmed.toLowerCase();
+        const match = normalized.match(/^(gpt-5(?:-codex)?)(?:-(minimal|low|medium|high))?$/);
+        if (!match) {
+            return {
+                cliModel: trimmed,
+                requestedModel: trimmed,
+                reasoning: fallback,
+            };
+        }
+        const baseModel = match[1];
+        const reasoning = this.normalizeReasoningEffort(match[2]);
+        return {
+            cliModel: baseModel,
+            requestedModel: trimmed,
+            reasoning: reasoning ?? fallback,
+        };
+    }
     async *execute(prompt, options) {
         // Effective options
         const cwd = options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd();
-        const mapModel = (m) => {
-            if (!m)
-                return m;
-            // Normalize reasoning-effort variants to the canonical model id
-            // Users reported only `gpt-5` is selectable; variants are effort levels in the TUI.
-            const lower = m.toLowerCase();
-            if (lower === 'gpt-5-minimal' ||
-                lower === 'gpt-5-low' ||
-                lower === 'gpt-5-medium' ||
-                lower === 'gpt-5-high') {
-                return 'gpt-5';
-            }
-            return m;
-        };
-        const model = mapModel(options?.model || this.config.defaultModel);
+        const resolvedModel = this.resolveModelSpec(options?.model || this.config.defaultModel, options?.effort);
+        const model = resolvedModel.cliModel;
         const images = (options?.images || []).filter(Boolean);
-        const effort = options?.effort;
+        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', prompt];
+        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);
@@ -63,7 +105,10 @@ export class CodexCliProvider {
         if (images.length) {
             argv.push('--image', images.join(','));
         }
-        const cmd = this.resolveExecutable();
+        if (options?.dangerouslyBypassApprovalsAndSandbox) {
+            argv.push('--dangerously-bypass-approvals-and-sandbox');
+        }
+        const cmd = await this.resolveExecutable();
         const child = spawn(cmd, argv, {
             cwd,
             env: { ...process.env },
@@ -74,15 +119,24 @@ export class CodexCliProvider {
             type: 'init',
             timestamp: new Date().toISOString(),
             sessionId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-            model: model || 'default',
+            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 },
+            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 = '';
@@ -212,6 +266,7 @@ export class CodexCliProvider {
         // 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;
@@ -220,36 +275,47 @@ export class CodexCliProvider {
         return {
             id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
             provider: this.name,
-            model: options?.model || this.config.defaultModel || 'default',
+            model: resolvedModel.requestedModel || resolvedModel.cliModel || 'default',
             content,
             usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
             duration: Date.now() - start,
         };
     }
     async detectAvailableModels() {
-        // Current public CLI exposes `--model gpt-5`; effort levels are chosen in-CLI.
+        const capabilities = ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'];
+        const makeModel = (id, displayName) => ({
+            id,
+            name: id,
+            displayName,
+            provider: this.name,
+            contextWindow: 256000,
+            maxOutputTokens: 16384,
+            capabilities,
+        });
         return [
-            {
-                id: 'gpt-5',
-                name: 'gpt-5',
-                displayName: 'gpt‑5',
-                provider: this.name,
-                contextWindow: 256000,
-                maxOutputTokens: 16384,
-                // Capabilities per Codex docs: supports images via --image and advanced reasoning
-                capabilities: ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'],
-            },
+            makeModel('gpt-5', 'gpt‑5'),
+            makeModel('gpt-5-low', 'gpt‑5 · low reasoning'),
+            makeModel('gpt-5-medium', 'gpt‑5 · medium reasoning'),
+            makeModel('gpt-5-high', 'gpt‑5 · high reasoning'),
+            makeModel('gpt-5-codex', 'gpt‑5 Codex'),
+            makeModel('gpt-5-codex-low', 'gpt‑5 Codex · low reasoning'),
+            makeModel('gpt-5-codex-medium', 'gpt‑5 Codex · medium reasoning'),
+            makeModel('gpt-5-codex-high', 'gpt‑5 Codex · high reasoning'),
         ];
     }
     async validateSetup() {
         try {
-            const bin = this.resolveExecutable();
-            // Try to spawn `codex --help` quickly to validate presence
-            const child = spawn(bin, ['--help'], { stdio: 'ignore' });
-            await new Promise((resolve, reject) => {
-                child.once('error', reject);
-                child.once('close', () => resolve());
-            });
+            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(),
@@ -260,7 +326,7 @@ export class CodexCliProvider {
             logger.error(error);
             return {
                 available: false,
-                error: 'Codex CLI not found. Install from https://github.com/openai/codex (see Getting Started: CLI usage).',
+                error: error instanceof Error ? error.message : String(error),
                 models: [],
                 capabilities: this.getCapabilities(),
             };

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

@@ -45,6 +45,8 @@ export interface ExecutionOptions {
     images?: string[];
     /** Optional effort hint for reasoning presets (e.g., 'minimal'|'low'|'medium'|'high'); informational only */
     effort?: string;
+    /** Enable Codex CLI sandbox bypass flag when running automation that must edit files */
+    dangerouslyBypassApprovalsAndSandbox?: boolean;
 }
 /**
  * Message types for streaming execution

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

@@ -24,10 +24,12 @@ describe('CodexCliProvider (mocked)', () => {
                     setTimeout(() => proc.emit('exit', 0, null), 20);
                     return proc;
                 },
+                exec: vi.fn(),
+                execFile: vi.fn(),
             };
         });
         const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
-        const provider = new CodexCliProvider({ defaultTimeoutMs: 1000 });
+        const provider = new CodexCliProvider({ defaultTimeoutMs: 1000, codexBinPath: 'codex' });
         const messages = [];
         const iter = provider.execute('What is this project about?', {
             workingDirectory: process.cwd(),
@@ -54,6 +56,86 @@ describe('CodexCliProvider (mocked)', () => {
         const modelIdx = captured[1].indexOf('--model');
         expect(modelIdx).toBeGreaterThan(-1);
         expect(captured[1][modelIdx + 1]).toBe('gpt-5');
+        const configIdx = captured[1].indexOf('-c');
+        expect(configIdx).toBeGreaterThan(-1);
+        expect(captured[1][configIdx + 1]).toBe('model_reasoning_effort=low');
+    });
+    it('maps reasoning level encoded in model name to CLI flags', 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('Reasoned\n')), 10);
+                    setTimeout(() => proc.emit('exit', 0, null), 20);
+                    return proc;
+                },
+                exec: vi.fn(),
+                execFile: vi.fn(),
+            };
+        });
+        const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
+        const provider = new CodexCliProvider({ codexBinPath: 'codex' });
+        const messages = [];
+        const iter = provider.execute('Solve with depth', {
+            workingDirectory: process.cwd(),
+            model: 'gpt-5-codex-high',
+        });
+        for await (const m of iter)
+            messages.push(m);
+        const mockSpawn = await import('child_process');
+        const captured = mockSpawn.__captured();
+        const modelIdx = captured[1].indexOf('--model');
+        expect(modelIdx).toBeGreaterThan(-1);
+        expect(captured[1][modelIdx + 1]).toBe('gpt-5-codex');
+        const configIdx = captured[1].indexOf('-c');
+        expect(configIdx).toBeGreaterThan(-1);
+        expect(captured[1][configIdx + 1]).toBe('model_reasoning_effort=high');
+    });
+    it('prepends system prompts and toggles sandbox bypass flag', 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 { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
+        const provider = new CodexCliProvider({ codexBinPath: 'codex' });
+        const iter = provider.execute('Implement feature', {
+            workingDirectory: '/tmp/project',
+            systemPrompt: 'Base system prompt',
+            appendSystemPrompt: 'Additional guidance',
+            dangerouslyBypassApprovalsAndSandbox: true,
+        });
+        for await (const _ of iter) {
+            // drain iterator
+        }
+        const mockSpawn = await import('child_process');
+        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();
     });
 });
 // Real integration (opt-in)

package/dist/runtime/api/agent/parsers.d.ts

@@ -7,6 +7,7 @@ export declare function parseImprovementResult(result: string, originalData: {
     type: string;
     priority: string;
     content: string;
+    title?: string;
 };
 export declare function parseReviewResult(result: string): {
     reviewSummary: string;

package/dist/runtime/api/agent/parsers.js

@@ -60,9 +60,10 @@ function extractLastValidJson(text) {
  */
 function parseJsonManually(jsonStr) {
     try {
-        // Extract type and priority with simple regex (these are usually well-formed)
+        // Extract type, priority and title with simple regex (these are usually well-formed)
         const typeMatch = jsonStr.match(/"type":\s*"([^"]+)"/);
         const priorityMatch = jsonStr.match(/"priority":\s*"([^"]+)"/);
+        const titleMatch = jsonStr.match(/"title":\s*"([^"]+)"/);
         // For content, find the start and extract everything until the closing brace
         const contentStart = jsonStr.indexOf('"content":');
         if (contentStart === -1)
@@ -103,11 +104,16 @@ function parseJsonManually(jsonStr) {
                 .replace(/\\t/g, '\t')
                 .replace(/\\"/g, '"')
                 .replace(/\\\\/g, '\\');
-            return {
+            const result = {
                 type: typeMatch[1],
                 priority: priorityMatch[1],
                 content: content,
             };
+            // Add title if found
+            if (titleMatch) {
+                result.title = titleMatch[1];
+            }
+            return result;
         }
         return null;
     }
@@ -117,6 +123,24 @@ function parseJsonManually(jsonStr) {
         return null;
     }
 }
+/**
+ * Extract title from markdown content and remove it from content
+ * Returns { title: string | null, cleanedContent: string }
+ */
+function extractTitleFromContent(content) {
+    if (!content || typeof content !== 'string') {
+        return { title: null, cleanedContent: content };
+    }
+    // Look for H1 heading at the start of content (with optional whitespace)
+    const h1Match = content.match(/^\s*#\s+([^\n\r]+)/);
+    if (h1Match) {
+        const title = h1Match[1].trim();
+        // Remove the H1 heading from content
+        const cleanedContent = content.replace(/^\s*#\s+[^\n\r]+\s*\n?/, '').trim();
+        return { title, cleanedContent };
+    }
+    return { title: null, cleanedContent: content };
+}
 export function parseImprovementResult(result, originalData) {
     try {
         const jsonBlock = extractLastValidJson(result);
@@ -130,13 +154,31 @@ export function parseImprovementResult(result, originalData) {
                     const validPriorities = ['high', 'medium', 'low'];
                     const normalizedType = String(parsed.type).toLowerCase();
                     const normalizedPriority = String(parsed.priority).toLowerCase();
-                    return {
+                    // Extract title from JSON if present, otherwise from content
+                    let finalTitle;
+                    let finalContent = String(parsed.content).trim();
+                    if (parsed.title && typeof parsed.title === 'string' && parsed.title.trim()) {
+                        finalTitle = parsed.title.trim();
+                    }
+                    else {
+                        // Try to extract title from content
+                        const { title, cleanedContent } = extractTitleFromContent(finalContent);
+                        if (title) {
+                            finalTitle = title;
+                            finalContent = cleanedContent;
+                        }
+                    }
+                    const result = {
                         type: validTypes.includes(normalizedType) ? normalizedType : originalData.type,
                         priority: validPriorities.includes(normalizedPriority)
                             ? normalizedPriority
                             : originalData.priority,
-                        content: String(parsed.content).trim(),
+                        content: finalContent,
                     };
+                    if (finalTitle) {
+                        result.title = finalTitle;
+                    }
+                    return result;
                 }
             }
             catch (parseError) {
@@ -151,13 +193,31 @@ export function parseImprovementResult(result, originalData) {
                         const validPriorities = ['high', 'medium', 'low'];
                         const normalizedType = String(parsed.type).toLowerCase();
                         const normalizedPriority = String(parsed.priority).toLowerCase();
-                        return {
+                        // Extract title from parsed JSON if present, otherwise from content
+                        let finalTitle;
+                        let finalContent = String(parsed.content).trim();
+                        if (parsed.title && typeof parsed.title === 'string' && parsed.title.trim()) {
+                            finalTitle = parsed.title.trim();
+                        }
+                        else {
+                            // Try to extract title from content
+                            const { title, cleanedContent } = extractTitleFromContent(finalContent);
+                            if (title) {
+                                finalTitle = title;
+                                finalContent = cleanedContent;
+                            }
+                        }
+                        const result = {
                             type: validTypes.includes(normalizedType) ? normalizedType : originalData.type,
                             priority: validPriorities.includes(normalizedPriority)
                                 ? normalizedPriority
                                 : originalData.priority,
-                            content: String(parsed.content).trim(),
+                            content: finalContent,
                         };
+                        if (finalTitle) {
+                            result.title = finalTitle;
+                        }
+                        return result;
                     }
                 }
                 catch (secondError) {
@@ -171,11 +231,18 @@ export function parseImprovementResult(result, originalData) {
         const errMsg = error instanceof Error ? error.message : String(error);
         log.error('Failed to parse improvement result', { error: errMsg, result }, 'result-parsers');
     }
-    return {
+    // Fallback: try to extract title from the raw result content
+    const fallbackContent = result.trim() || originalData.content;
+    const { title: extractedTitle, cleanedContent } = extractTitleFromContent(fallbackContent);
+    const fallbackResult = {
         type: originalData.type,
         priority: originalData.priority,
-        content: result.trim() || originalData.content,
+        content: cleanedContent,
     };
+    if (extractedTitle) {
+        fallbackResult.title = extractedTitle;
+    }
+    return fallbackResult;
 }
 export function parseReviewResult(result) {
     try {

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

@@ -4,13 +4,26 @@ export declare class PromptService {
     private projectRoot;
     private taskService;
     constructor(projectRoot: string, taskService: TaskService);
+    /**
+     * Generate absolute path to task file
+     */
+    private generateTaskFilePath;
+    /**
+     * Validate that task file exists at the given path
+     */
+    private validateTaskFile;
     generateImprovementPrompt(task: Task, taskData: {
         title: string;
         type: string;
         priority: string;
         content: string;
     }): Promise<string>;
-    generateTaskPrompt(task: Task): Promise<string>;
+    generateTaskPrompt(task: Task, workflowConfig?: import('../types/index.js').VibingConfig): Promise<string>;
+    /**
+     * Build a prominent, clearly formatted instruction section derived from workflow options.
+     * If no options are provided or none apply, returns a minimal guidance line.
+     */
+    private buildWorkflowInstructions;
     generateAIMergePrompt(task: Task, worktree: WorktreeInfo, baseBranch?: string): Promise<string>;
     generateReviewPrompt(task: Task, worktree: WorktreeInfo, reviewContext?: string): Promise<string>;
 }