vibeman 0.0.2 → 0.0.5

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

@@ -16,17 +16,67 @@ const CLAUDE_ALLOWED_MODELS = [
     'claude-opus-4-1-20250805',
     'claude-3-5-haiku-20241022',
 ];
-const MODEL_ENUM = [...CLAUDE_ALLOWED_MODELS, 'gpt-5'];
+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_REASONING_SUFFIXES = ['low', 'medium', 'high', 'extra-high'];
+const CODEX_ALLOWED_MODELS = [
+    ...CODEX_BASE_MODELS,
+    ...CODEX_BASE_MODELS.flatMap((base) => CODEX_REASONING_SUFFIXES.map((suffix) => `${base}-${suffix}`)),
+];
+const GEMINI_ALLOWED_MODELS = [
+    'gemini-3-pro-preview',
+    'gemini-3-flash-preview',
+    'gemini-2.5-pro',
+    'gemini-2.5-flash',
+    'gemini-2.5-flash-lite',
+];
+const AUTO_ALLOWED_MODELS = ['auto'];
+const MODEL_ENUM = [
+    ...CLAUDE_ALLOWED_MODELS,
+    ...CODEX_ALLOWED_MODELS,
+    ...GEMINI_ALLOWED_MODELS,
+    ...AUTO_ALLOWED_MODELS,
+];
+const ROUTABLE_OPERATIONS = [
+    'execute_task',
+    'quality_checks',
+    'ai_codereview',
+    'ai_merge',
+    'improve_task',
+];
+const RoutingOperationSchema = z.object({
+    provider: z.string(),
+    model: z.string().optional(),
+    options: z
+        .object({
+        temperature: z.number().min(0).max(2).optional(),
+        maxTokens: z.number().positive().optional(),
+        tools: z.array(z.string()).optional(),
+    })
+        .optional(),
+    fallback: z.array(z.string()).optional(),
+});
+const RoutingPolicySettingsSchema = z
+    .object({
+    defaultProvider: z.enum(['claude-code', 'codex', 'gemini', 'amp']).optional(),
+    operations: z.record(z.enum(ROUTABLE_OPERATIONS), RoutingOperationSchema).optional(),
+})
+    .optional();
 const VibemanSettingsSchema = z.object({
     agents: z.object({
-        defaultProvider: z.enum(['claude-code', 'codex']),
+        defaultProvider: z.enum(['claude-code', 'codex', 'gemini', 'amp']),
         codingAgent: z.object({
-            provider: z.enum(['claude-code', 'codex']),
+            provider: z.enum(['claude-code', 'codex', 'gemini', 'amp']),
             model: z.enum(MODEL_ENUM),
             maxTokens: z.number().min(256).max(10000000000000).optional(),
         }),
         judgeAgent: z.object({
-            provider: z.enum(['claude-code', 'codex']),
+            provider: z.enum(['claude-code', 'codex', 'gemini', 'amp']),
             model: z.enum(MODEL_ENUM),
             maxTokens: z.number().min(256).max(10000000000000).optional(),
             reviewThresholdScore: z.number().min(0).max(100),
@@ -41,8 +91,11 @@ const VibemanSettingsSchema = z.object({
             .object({
             claudeCode: z.object({ binPath: z.string().min(1).optional() }).optional(),
             codex: z.object({ binPath: z.string().min(1).optional() }).optional(),
+            gemini: z.object({ binPath: z.string().min(1).optional() }).optional(),
+            amp: z.object({ binPath: z.string().min(1).optional() }).optional(),
         })
             .optional(),
+        routingPolicy: RoutingPolicySettingsSchema,
     }),
     defaultWorkflow: z.object({
         autoQualityChecks: z.boolean(),
@@ -116,6 +169,10 @@ const DEFAULT_SETTINGS = {
             taskPrompt: 'Please implement the following task with attention to quality and testing.',
         },
         providers: {},
+        routingPolicy: {
+            defaultProvider: 'claude-code',
+            operations: {},
+        },
     },
     defaultWorkflow: {
         autoQualityChecks: true,
@@ -170,7 +227,7 @@ export class SettingsService extends EventEmitter {
         super();
         this.settings = { ...DEFAULT_SETTINGS };
         this.initialized = false;
-        const settingsDir = config.settingsDir ?? '.vibeman';
+        const settingsDir = config.settingsDir ?? '.vibeman/.local';
         const settingsFileName = config.settingsFileName ?? 'settings.json';
         // Resolve settings path relative to the repo project root (not package CWD)
         const projectRoot = getProjectRoot();
@@ -558,6 +615,14 @@ export class SettingsService extends EventEmitter {
                     ...DEFAULT_SETTINGS.agents.defaultPrompts,
                     ...settings.agents?.defaultPrompts,
                 },
+                routingPolicy: {
+                    ...DEFAULT_SETTINGS.agents.routingPolicy,
+                    ...settings.agents?.routingPolicy,
+                    operations: {
+                        ...(DEFAULT_SETTINGS.agents.routingPolicy?.operations ?? {}),
+                        ...(settings.agents?.routingPolicy?.operations ?? {}),
+                    },
+                },
             },
             defaultWorkflow: {
                 ...DEFAULT_SETTINGS.defaultWorkflow,

package/dist/runtime/api/tasks/task-file-parser.d.ts

@@ -6,6 +6,7 @@ export declare class TaskFileParser {
     parseDirectory(dirPath?: string): Promise<Task[]>;
     parseContent(content: string, filePath?: string): Promise<Task | null>;
     private getFileStats;
+    private normalizeStatus;
     writeTask(task: Task): Promise<void>;
     deleteTask(taskId: string): Promise<void>;
     generateFilePath(task: Task): string;

package/dist/runtime/api/tasks/task-file-parser.js

@@ -41,6 +41,10 @@ export class TaskFileParser {
         try {
             const parsed = matter(content);
             const metadata = parsed.data;
+            const normalizedStatus = this.normalizeStatus(metadata.status);
+            if (normalizedStatus !== null) {
+                metadata.status = normalizedStatus;
+            }
             // Validate required fields
             if (!metadata.id || !metadata.title || !metadata.type || !metadata.status) {
                 log.error(`Invalid task metadata in ${filePath}`, { metadata, filePath }, 'task-file-parser:parseContent');
@@ -56,7 +60,7 @@ export class TaskFileParser {
             }
             if (!validStatuses.includes(metadata.status)) {
                 log.error(`Invalid task status '${metadata.status}' in ${filePath}`, { status: metadata.status, filePath, validStatuses }, 'task-file-parser:parseContent');
-                return null;
+                metadata.status = 'backlog';
             }
             if (metadata.priority && !validPriorities.includes(metadata.priority)) {
                 log.error(`Invalid task priority '${metadata.priority}' in ${filePath}`, { priority: metadata.priority, filePath, validPriorities }, 'task-file-parser:parseContent');
@@ -108,6 +112,21 @@ export class TaskFileParser {
             return null;
         }
     }
+    normalizeStatus(status) {
+        if (typeof status !== 'string') {
+            return null;
+        }
+        const normalized = status
+            .trim()
+            .toLowerCase()
+            .replace(/[_\s]+/g, '-')
+            .replace(/-+/g, '-');
+        const validStatuses = ['backlog', 'in-progress', 'review', 'done'];
+        if (validStatuses.includes(normalized)) {
+            return normalized;
+        }
+        return null;
+    }
     async writeTask(task) {
         const filePath = this.generateFilePath(task);
         const frontMatter = {

package/dist/runtime/api/tasks/task-updater.d.ts

@@ -0,0 +1,62 @@
+export interface TaskUpdateContext {
+    filesModified?: string[];
+    keyChanges?: string[];
+    testsAdded?: boolean;
+    testsPassed?: boolean;
+    buildPassed?: boolean;
+    qualityChecksPassed?: boolean;
+    aiReviewScore?: number;
+    workflowId?: string;
+    phase?: string;
+}
+export interface TaskUpdateSummary {
+    filesChanged: string[];
+    keyLogic: string[];
+    testsInfo: string;
+    qualityNotes: string;
+    remainingRisks: string[];
+}
+/**
+ * Updates task markdown files when workflows reach review readiness.
+ * Handles status updates, todo marking, and implementation summary generation.
+ */
+export declare class TaskUpdater {
+    private tasksDir;
+    constructor(vibeDir?: string);
+    /**
+     * Main entry point: Update task for review readiness
+     */
+    updateTaskForReviewReadiness(taskId: string, context?: TaskUpdateContext): Promise<void>;
+    /**
+     * Update YAML front-matter to set status to 'review'
+     */
+    private updateStatusToReview;
+    /**
+     * Process markdown content: mark todos and add/update implementation summary
+     */
+    private processMarkdownContent;
+    /**
+     * Mark implementation-related todos as completed
+     */
+    private markImplementationTodos;
+    /**
+     * Check if a section is eligible for todo marking
+     */
+    private isEligibleTodoSection;
+    /**
+     * Add or update the implementation summary section
+     */
+    private upsertImplementationSummary;
+    /**
+     * Generate implementation summary from context
+     */
+    private generateImplementationSummary;
+    /**
+     * Build the implementation summary markdown section
+     */
+    private buildImplementationSummarySection;
+    /**
+     * Write task file atomically using temporary file
+     */
+    private writeTaskFileAtomically;
+}

package/dist/runtime/api/tasks/task-updater.js

@@ -0,0 +1,260 @@
+import fs from 'fs/promises';
+import path from 'path';
+import matter from 'gray-matter';
+import { log } from '../lib/logger.js';
+import { getVibeDir } from '../lib/server/project-root.js';
+/**
+ * Updates task markdown files when workflows reach review readiness.
+ * Handles status updates, todo marking, and implementation summary generation.
+ */
+export class TaskUpdater {
+    constructor(vibeDir) {
+        this.tasksDir = path.join(vibeDir || getVibeDir(), 'tasks');
+    }
+    /**
+     * Main entry point: Update task for review readiness
+     */
+    async updateTaskForReviewReadiness(taskId, context = {}) {
+        try {
+            const taskFilePath = path.join(this.tasksDir, `${taskId}.md`);
+            // Check if task file exists
+            try {
+                await fs.access(taskFilePath);
+            }
+            catch (error) {
+                log.error('Task file not found', { taskId, taskFilePath }, 'task-updater');
+                throw new Error(`Task file not found: ${taskId}`);
+            }
+            // Read and parse the task file
+            const fileContent = await fs.readFile(taskFilePath, 'utf-8');
+            const parsed = matter(fileContent);
+            // Update YAML front-matter status
+            const updatedFrontMatter = this.updateStatusToReview(parsed.data);
+            // Process markdown content
+            const updatedContent = this.processMarkdownContent(parsed.content, context);
+            // Write back atomically
+            await this.writeTaskFileAtomically(taskFilePath, updatedFrontMatter, updatedContent);
+            log.info('Task updated for review readiness', { taskId }, 'task-updater');
+        }
+        catch (error) {
+            log.error('Failed to update task for review readiness', error, 'task-updater');
+            throw error;
+        }
+    }
+    /**
+     * Update YAML front-matter to set status to 'review'
+     */
+    updateStatusToReview(frontMatter) {
+        const updated = { ...frontMatter };
+        // Only update if not already 'done' (preserve completed tasks) - case insensitive
+        if (updated.status?.toLowerCase() !== 'done') {
+            updated.status = 'Review';
+        }
+        return updated;
+    }
+    /**
+     * Process markdown content: mark todos and add/update implementation summary
+     */
+    processMarkdownContent(content, context) {
+        let processedContent = content;
+        // Step 1: Mark implementation todos as completed
+        processedContent = this.markImplementationTodos(processedContent);
+        // Step 2: Add or update implementation summary
+        processedContent = this.upsertImplementationSummary(processedContent, context);
+        return processedContent;
+    }
+    /**
+     * Mark implementation-related todos as completed
+     */
+    markImplementationTodos(content) {
+        const lines = content.split('\n');
+        let inEligibleSection = false;
+        let currentSection = '';
+        const processedLines = lines.map((line) => {
+            // Track current section
+            const headerMatch = line.match(/^##\s+(.+)$/i);
+            if (headerMatch) {
+                currentSection = headerMatch[1].toLowerCase().trim();
+                inEligibleSection = this.isEligibleTodoSection(currentSection);
+                return line;
+            }
+            // Reset section tracking on other headers
+            if (line.match(/^#\s+/)) {
+                inEligibleSection = false;
+                currentSection = '';
+                return line;
+            }
+            // Mark todos in eligible sections
+            if (inEligibleSection && line.match(/^[\s]*-\s+\[\s*\]\s+/)) {
+                return line.replace(/^([\s]*-\s+)\[\s*\](\s+.*)$/, '$1[x]$2');
+            }
+            return line;
+        });
+        return processedLines.join('\n');
+    }
+    /**
+     * Check if a section is eligible for todo marking
+     */
+    isEligibleTodoSection(sectionName) {
+        const eligibleSections = [
+            'implementation',
+            'implementation tasks',
+            'tasks',
+            'todo',
+            'implementation notes',
+        ];
+        // Check for exact matches or partial matches
+        return eligibleSections.some((eligible) => sectionName.includes(eligible) || eligible.includes(sectionName));
+    }
+    /**
+     * Add or update the implementation summary section
+     */
+    upsertImplementationSummary(content, context) {
+        const summary = this.generateImplementationSummary(context);
+        const summarySection = this.buildImplementationSummarySection(summary);
+        // Check if implementation summary already exists
+        const startMarker = '<!-- IMPLEMENTATION_SUMMARY_START -->';
+        const endMarker = '<!-- IMPLEMENTATION_SUMMARY_END -->';
+        const startIndex = content.indexOf(startMarker);
+        const endIndex = content.indexOf(endMarker);
+        if (startIndex !== -1 && endIndex !== -1) {
+            // Replace existing summary
+            const before = content.substring(0, startIndex);
+            const after = content.substring(endIndex + endMarker.length);
+            return before + summarySection + after;
+        }
+        else {
+            // Add new summary at the beginning of content (after first header if any)
+            const lines = content.split('\n');
+            let insertIndex = 0;
+            // Find insertion point after description or first header
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].match(/^##\s+/)) {
+                    insertIndex = i;
+                    break;
+                }
+            }
+            const before = lines.slice(0, insertIndex).join('\n');
+            const after = lines.slice(insertIndex).join('\n');
+            const separator = insertIndex > 0 && before.trim() ? '\n\n' : '';
+            return before + separator + summarySection + '\n\n' + after;
+        }
+    }
+    /**
+     * Generate implementation summary from context
+     */
+    generateImplementationSummary(context) {
+        const filesChanged = context.filesModified || [];
+        const keyLogic = context.keyChanges || [];
+        // Generate tests info
+        let testsInfo = 'No test information available';
+        if (context.testsAdded) {
+            testsInfo = context.testsPassed
+                ? 'New tests added and passing'
+                : 'New tests added (status unknown)';
+        }
+        else if (context.testsPassed !== undefined) {
+            testsInfo = context.testsPassed ? 'Existing tests passing' : 'Test failures detected';
+        }
+        // Generate quality notes
+        let qualityNotes = 'Quality checks not run';
+        if (context.qualityChecksPassed !== undefined) {
+            qualityNotes = context.qualityChecksPassed
+                ? 'All quality checks passed'
+                : 'Quality check failures';
+        }
+        if (context.buildPassed !== undefined) {
+            qualityNotes += context.buildPassed ? ', build successful' : ', build failures detected';
+        }
+        if (context.aiReviewScore !== undefined) {
+            qualityNotes += `, AI review score: ${context.aiReviewScore}`;
+        }
+        // Identify remaining risks (only for actual failures, not missing data)
+        const remainingRisks = [];
+        if (context.testsPassed === false)
+            remainingRisks.push('Test failures need investigation');
+        if (context.qualityChecksPassed === false)
+            remainingRisks.push('Quality check issues need resolution');
+        if (context.buildPassed === false)
+            remainingRisks.push('Build issues need fixing');
+        if (context.aiReviewScore !== undefined && context.aiReviewScore < 70) {
+            remainingRisks.push('AI review score below threshold');
+        }
+        return {
+            filesChanged: filesChanged.slice(0, 10), // Limit to 10 files for readability
+            keyLogic,
+            testsInfo,
+            qualityNotes,
+            remainingRisks,
+        };
+    }
+    /**
+     * Build the implementation summary markdown section
+     */
+    buildImplementationSummarySection(summary) {
+        const sections = [];
+        sections.push('<!-- IMPLEMENTATION_SUMMARY_START -->');
+        sections.push('## Implementation Summary');
+        sections.push('');
+        // Files changed
+        if (summary.filesChanged.length > 0) {
+            sections.push(`- **Files Modified:** ${summary.filesChanged.length} files updated`);
+            sections.push('- **Key Files:**');
+            summary.filesChanged.forEach((file) => {
+                sections.push(`  - \`${file}\``);
+            });
+        }
+        else {
+            sections.push('- **Files Modified:** No file changes tracked');
+        }
+        // Key logic changes
+        if (summary.keyLogic.length > 0) {
+            sections.push('- **Key Changes:**');
+            summary.keyLogic.forEach((change) => {
+                sections.push(`  - ${change}`);
+            });
+        }
+        // Tests and quality
+        sections.push(`- **Tests:** ${summary.testsInfo}`);
+        sections.push(`- **Quality Checks:** ${summary.qualityNotes}`);
+        // Remaining risks
+        if (summary.remainingRisks.length > 0) {
+            sections.push('- **Review Notes:** Issues requiring attention:');
+            summary.remainingRisks.forEach((risk) => {
+                sections.push(`  - ⚠️ ${risk}`);
+            });
+        }
+        else {
+            sections.push('- **Review Notes:** Ready for manual review and approval');
+        }
+        sections.push('');
+        sections.push('<!-- IMPLEMENTATION_SUMMARY_END -->');
+        return sections.join('\n');
+    }
+    /**
+     * Write task file atomically using temporary file
+     */
+    async writeTaskFileAtomically(filePath, frontMatter, content) {
+        const tempPath = filePath + '.tmp';
+        try {
+            // Normalize content to ensure clean formatting
+            const normalizedContent = content.replace(/^[\r\n]+/, '').replace(/[\r\n]*$/, '\n');
+            // Build complete file content
+            const fileContent = matter.stringify(normalizedContent, frontMatter);
+            // Write to temporary file first
+            await fs.writeFile(tempPath, fileContent, 'utf-8');
+            // Atomic rename
+            await fs.rename(tempPath, filePath);
+        }
+        catch (error) {
+            // Clean up temp file if it exists
+            try {
+                await fs.unlink(tempPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            throw error;
+        }
+    }
+}

package/dist/runtime/api/tasks/task-updater.test.d.ts

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