vibeman 0.0.2 → 0.0.5

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

@@ -0,0 +1,303 @@
+import { describe, beforeEach, afterEach, test, expect, vi } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import { TaskUpdater } from './task-updater.js';
+// Mock fs and path
+vi.mock('fs/promises');
+vi.mock('../lib/logger.js', () => ({
+    log: {
+        info: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+vi.mock('../lib/server/project-root.js', () => ({
+    getVibeDir: vi.fn(() => '/test/vibe'),
+}));
+const mockFs = fs;
+describe('TaskUpdater', () => {
+    let taskUpdater;
+    const testTasksDir = '/test/vibe/tasks';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        taskUpdater = new TaskUpdater('/test/vibe');
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('updateTaskForReviewReadiness', () => {
+        const sampleTaskContent = `---
+id: TEST-TASK-123
+title: Test Task
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Description
+This is a test task.
+
+## Implementation Tasks
+- [ ] Implement feature A
+- [ ] Add tests for feature A
+- [x] Already completed task
+
+## Acceptance Criteria
+- [ ] Feature works correctly
+- [ ] Tests pass
+`;
+        beforeEach(() => {
+            mockFs.access = vi.fn().mockResolvedValue(undefined);
+            mockFs.readFile = vi.fn().mockResolvedValue(sampleTaskContent);
+            mockFs.writeFile = vi.fn().mockResolvedValue(undefined);
+            mockFs.rename = vi.fn().mockResolvedValue(undefined);
+            mockFs.unlink = vi.fn().mockResolvedValue(undefined);
+        });
+        test('should update task status to review', async () => {
+            const context = {
+                filesModified: ['src/feature.ts', 'tests/feature.test.ts'],
+                keyChanges: ['Added new feature A', 'Implemented core logic'],
+                testsPassed: true,
+                qualityChecksPassed: true,
+            };
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', context);
+            expect(mockFs.access).toHaveBeenCalledWith(path.join(testTasksDir, 'TEST-TASK-123.md'));
+            expect(mockFs.readFile).toHaveBeenCalledWith(path.join(testTasksDir, 'TEST-TASK-123.md'), 'utf-8');
+            expect(mockFs.writeFile).toHaveBeenCalled();
+            expect(mockFs.rename).toHaveBeenCalled();
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Verify status changed to Review
+            expect(writtenContent).toContain('status: Review');
+            // Verify todos are marked as completed
+            expect(writtenContent).toContain('- [x] Implement feature A');
+            expect(writtenContent).toContain('- [x] Add tests for feature A');
+            // Verify acceptance criteria unchanged
+            expect(writtenContent).toContain('- [ ] Feature works correctly');
+            expect(writtenContent).toContain('- [ ] Tests pass');
+            // Verify implementation summary added
+            expect(writtenContent).toContain('## Implementation Summary');
+            expect(writtenContent).toContain('IMPLEMENTATION_SUMMARY_START');
+            expect(writtenContent).toContain('IMPLEMENTATION_SUMMARY_END');
+        });
+        test('should not change status if already done', async () => {
+            const doneTaskContent = sampleTaskContent.replace('status: in-progress', 'status: done');
+            mockFs.readFile = vi.fn().mockResolvedValue(doneTaskContent);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            expect(writtenContent).toContain('status: done');
+            expect(writtenContent).not.toContain('status: Review');
+        });
+        test('should not change status if already Done (case insensitive)', async () => {
+            const doneTaskContent = sampleTaskContent.replace('status: in-progress', 'status: Done');
+            mockFs.readFile = vi.fn().mockResolvedValue(doneTaskContent);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            expect(writtenContent).toContain('status: Done');
+            expect(writtenContent).not.toContain('status: Review');
+        });
+        test('should handle missing task file', async () => {
+            mockFs.access = vi.fn().mockRejectedValue(new Error('File not found'));
+            await expect(taskUpdater.updateTaskForReviewReadiness('NONEXISTENT-TASK', {})).rejects.toThrow('Task file not found: NONEXISTENT-TASK');
+        });
+        test('should mark only implementation todos, not acceptance criteria', async () => {
+            const taskWithMixedTodos = `---
+id: TEST-TASK-456
+title: Mixed Todos Task
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Implementation
+- [ ] Task 1
+- [ ] Task 2
+
+## Implementation Tasks
+- [ ] Task 3
+- [ ] Task 4
+
+## Acceptance Criteria
+- [ ] AC 1
+- [ ] AC 2
+
+## Random Section
+- [ ] Should not be marked
+`;
+            mockFs.readFile = vi.fn().mockResolvedValue(taskWithMixedTodos);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-456', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Implementation todos should be marked
+            expect(writtenContent).toContain('- [x] Task 1');
+            expect(writtenContent).toContain('- [x] Task 2');
+            expect(writtenContent).toContain('- [x] Task 3');
+            expect(writtenContent).toContain('- [x] Task 4');
+            // Acceptance criteria should remain unchanged
+            expect(writtenContent).toContain('- [ ] AC 1');
+            expect(writtenContent).toContain('- [ ] AC 2');
+            // Random section should remain unchanged
+            expect(writtenContent).toContain('- [ ] Should not be marked');
+        });
+        test('should update existing implementation summary', async () => {
+            const taskWithExistingSummary = `---
+id: TEST-TASK-789
+title: Task with Existing Summary
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Description
+Task description
+
+<!-- IMPLEMENTATION_SUMMARY_START -->
+## Implementation Summary
+Old summary content
+<!-- IMPLEMENTATION_SUMMARY_END -->
+
+## Implementation
+- [ ] Task 1
+`;
+            mockFs.readFile = vi.fn().mockResolvedValue(taskWithExistingSummary);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-789', {
+                filesModified: ['newfile.ts'],
+                keyChanges: ['New implementation'],
+            });
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Should have new summary, not old
+            expect(writtenContent).not.toContain('Old summary content');
+            expect(writtenContent).toContain('**Files Modified:** 1 files updated');
+            expect(writtenContent).toContain('newfile.ts');
+            expect(writtenContent).toContain('New implementation');
+        });
+        test('should handle atomic write failure by cleaning up temp file', async () => {
+            mockFs.writeFile = vi.fn().mockRejectedValue(new Error('Write failed'));
+            mockFs.unlink = vi.fn().mockResolvedValue(undefined);
+            await expect(taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', {})).rejects.toThrow('Write failed');
+            expect(mockFs.unlink).toHaveBeenCalledWith(path.join(testTasksDir, 'TEST-TASK-123.md.tmp'));
+        });
+        test('should generate comprehensive implementation summary', async () => {
+            const context = {
+                filesModified: ['src/feature.ts', 'tests/feature.test.ts', 'docs/feature.md'],
+                keyChanges: ['Added feature A', 'Improved performance', 'Fixed edge case'],
+                testsAdded: true,
+                testsPassed: true,
+                buildPassed: true,
+                qualityChecksPassed: true,
+                aiReviewScore: 85,
+                workflowId: 'workflow-123',
+            };
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', context);
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Verify summary content
+            expect(writtenContent).toContain('**Files Modified:** 3 files updated');
+            expect(writtenContent).toContain('src/feature.ts');
+            expect(writtenContent).toContain('tests/feature.test.ts');
+            expect(writtenContent).toContain('docs/feature.md');
+            expect(writtenContent).toContain('**Key Changes:**');
+            expect(writtenContent).toContain('Added feature A');
+            expect(writtenContent).toContain('Improved performance');
+            expect(writtenContent).toContain('Fixed edge case');
+            expect(writtenContent).toContain('**Tests:** New tests added and passing');
+            expect(writtenContent).toContain('**Quality Checks:** All quality checks passed');
+            expect(writtenContent).toContain('AI review score: 85');
+            expect(writtenContent).toContain('Ready for manual review and approval');
+        });
+        test('should identify review risks when quality checks fail', async () => {
+            const context = {
+                filesModified: ['src/feature.ts'],
+                testsPassed: false,
+                buildPassed: false,
+                qualityChecksPassed: false,
+                aiReviewScore: 45,
+            };
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', context);
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            expect(writtenContent).toContain('**Review Notes:** Issues requiring attention:');
+            expect(writtenContent).toContain('⚠️ Test failures need investigation');
+            expect(writtenContent).toContain('⚠️ Quality check issues need resolution');
+            expect(writtenContent).toContain('⚠️ Build issues need fixing');
+            expect(writtenContent).toContain('⚠️ AI review score below threshold');
+        });
+        test('should identify AI review score of 0 as risk', async () => {
+            const context = {
+                filesModified: ['src/feature.ts'],
+                testsPassed: true,
+                buildPassed: true,
+                qualityChecksPassed: true,
+                aiReviewScore: 0,
+            };
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', context);
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            expect(writtenContent).toContain('**Review Notes:** Issues requiring attention:');
+            expect(writtenContent).toContain('⚠️ AI review score below threshold');
+        });
+        test('should handle edge case with no eligible todo sections', async () => {
+            const taskWithoutTodos = `---
+id: TEST-TASK-NO-TODOS
+title: Task Without Implementation Todos
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Description
+This task has no implementation todos.
+
+## Acceptance Criteria
+- [ ] Should work
+- [ ] Should be tested
+`;
+            mockFs.readFile = vi.fn().mockResolvedValue(taskWithoutTodos);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-NO-TODOS', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Status should still be updated
+            expect(writtenContent).toContain('status: Review');
+            // Implementation summary should still be added
+            expect(writtenContent).toContain('## Implementation Summary');
+            // Acceptance criteria should remain unchanged
+            expect(writtenContent).toContain('- [ ] Should work');
+            expect(writtenContent).toContain('- [ ] Should be tested');
+        });
+        test('should handle nested todo lists in implementation sections', async () => {
+            const taskWithNestedTodos = `---
+id: TEST-NESTED
+title: Task with Nested Todos
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Implementation Tasks
+- [ ] Main task 1
+  - [ ] Subtask 1.1
+  - [ ] Subtask 1.2
+- [ ] Main task 2
+    - [ ] Subtask 2.1
+`;
+            mockFs.readFile = vi.fn().mockResolvedValue(taskWithNestedTodos);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-NESTED', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // All todos should be marked, preserving indentation
+            expect(writtenContent).toContain('- [x] Main task 1');
+            expect(writtenContent).toContain('  - [x] Subtask 1.1');
+            expect(writtenContent).toContain('  - [x] Subtask 1.2');
+            expect(writtenContent).toContain('- [x] Main task 2');
+            expect(writtenContent).toContain('    - [x] Subtask 2.1');
+        });
+    });
+});

package/dist/runtime/api/types/index.d.ts

@@ -109,6 +109,13 @@ export interface VibingExecution {
         previousExecutionId?: string;
     }>;
     qualityResults?: QualityResults;
+    aiReviewResult?: {
+        executionId: string;
+        reviewSummary: string;
+        recommendations: string[];
+        qualityScore: number;
+        timestamp?: string;
+    };
     links?: {
         prUrl?: string;
         prNumber?: number;
@@ -164,7 +171,7 @@ export interface VibingConfig {
         timeout?: number;
         enabled?: boolean;
     }>;
-    aiRoutingOverrides?: Partial<Record<'execute_task' | 'improve_task' | 'ai_codereview' | 'ai_merge', {
+    aiRoutingOverrides?: Partial<Record<'execute_task' | 'quality_checks' | 'ai_codereview' | 'ai_merge' | 'improve_task', {
         provider?: string;
         model?: string;
     }>>;
@@ -176,4 +183,4 @@ export interface VibingConfig {
         timestamp?: string;
     };
 }
-export type { VibingStage, VibingStatus, LegacyVibingPhase, VibingWorkflowV2, StageToStatusMapping, } from '@vibeman/types';
+export type { VibingStage, VibingStatus, VibingWorkflowV2, StageToStatusMapping, } from '@vibeman/types';

package/dist/runtime/api/types/settings.d.ts

@@ -1,14 +1,18 @@
+type ClaudeModel = 'claude-sonnet-4-20250514' | 'claude-opus-4-1-20250805' | 'claude-3-5-haiku-20241022';
+type CodexModel = 'gpt-5.1-codex-max' | 'gpt-5.1-codex-max-low' | 'gpt-5.1-codex-max-medium' | 'gpt-5.1-codex-max-high' | 'gpt-5.1-codex-max-extra-high' | 'gpt-5.1-codex' | 'gpt-5.1-codex-low' | 'gpt-5.1-codex-medium' | 'gpt-5.1-codex-high' | 'gpt-5.1-codex-extra-high' | 'gpt-5.1-codex-mini' | 'gpt-5.1-codex-mini-low' | 'gpt-5.1-codex-mini-medium' | 'gpt-5.1-codex-mini-high' | 'gpt-5.1-codex-mini-extra-high' | 'gpt-5.2' | 'gpt-5.2-low' | 'gpt-5.2-medium' | 'gpt-5.2-high' | 'gpt-5.2-extra-high' | 'gpt-5.1' | 'gpt-5.1-low' | 'gpt-5.1-medium' | 'gpt-5.1-high' | 'gpt-5.1-extra-high';
+type GeminiModel = 'gemini-3-pro-preview' | 'gemini-3-flash-preview' | 'gemini-2.5-pro' | 'gemini-2.5-flash' | 'gemini-2.5-flash-lite';
+type AllowedModel = ClaudeModel | CodexModel | GeminiModel | 'auto';
 export interface VibemanSettings {
     agents: {
-        defaultProvider: 'claude-code' | 'codex';
+        defaultProvider: 'claude-code' | 'codex' | 'gemini' | 'amp';
         codingAgent: {
-            provider: 'claude-code' | 'codex';
-            model: 'claude-sonnet-4-20250514' | 'claude-opus-4-1-20250805' | 'claude-3-5-haiku-20241022' | 'gpt-5';
+            provider: 'claude-code' | 'codex' | 'gemini' | 'amp';
+            model: AllowedModel;
             maxTokens?: number;
         };
         judgeAgent: {
-            provider: 'claude-code' | 'codex';
-            model: 'claude-sonnet-4-20250514' | 'claude-opus-4-1-20250805' | 'claude-3-5-haiku-20241022' | 'gpt-5';
+            provider: 'claude-code' | 'codex' | 'gemini' | 'amp';
+            model: AllowedModel;
             maxTokens?: number;
             reviewThresholdScore: number;
         };
@@ -23,6 +27,25 @@ export interface VibemanSettings {
             codex?: {
                 binPath?: string;
             };
+            gemini?: {
+                binPath?: string;
+            };
+            amp?: {
+                binPath?: string;
+            };
+        };
+        routingPolicy?: {
+            defaultProvider?: 'claude-code' | 'codex' | 'gemini' | 'amp';
+            operations?: Partial<Record<'execute_task' | 'quality_checks' | 'ai_codereview' | 'ai_merge' | 'improve_task', {
+                provider: string;
+                model?: string;
+                options?: {
+                    temperature?: number;
+                    maxTokens?: number;
+                    tools?: string[];
+                };
+                fallback?: string[];
+            }>>;
         };
     };
     defaultWorkflow: {
@@ -79,3 +102,4 @@ export interface SettingsValidationError {
     expected?: string;
     received?: string;
 }
+export {};

package/dist/runtime/api/vcs/git-service.d.ts

@@ -25,6 +25,7 @@ export declare class GitService {
     private config;
     private projectRoot;
     constructor(projectRoot?: string, config?: GitConfig);
+    getProjectRoot(): string;
     /**
      * Validate Git repository exists and is properly configured
      */
@@ -64,6 +65,14 @@ export declare class GitService {
      * Get Git version information
      */
     getGitVersion(): Promise<VersionResult>;
+    /**
+     * Check whether a path is ignored by git.
+     */
+    isIgnored(relativePath: string): Promise<boolean>;
+    /**
+     * Get the current HEAD commit hash
+     */
+    getHeadCommitHash(short?: boolean): Promise<string>;
     /**
      * List all worktrees in the repository
      */

package/dist/runtime/api/vcs/git-service.js

@@ -7,6 +7,9 @@ export class GitService {
         this.config = config;
         this.git = simpleGit(projectRoot);
     }
+    getProjectRoot() {
+        return this.projectRoot;
+    }
     /**
      * Validate Git repository exists and is properly configured
      */
@@ -145,6 +148,26 @@ export class GitService {
     async getGitVersion() {
         return await this.git.version();
     }
+    /**
+     * Check whether a path is ignored by git.
+     */
+    async isIgnored(relativePath) {
+        try {
+            await this.git.raw(['check-ignore', '-q', relativePath]);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get the current HEAD commit hash
+     */
+    async getHeadCommitHash(short = true) {
+        const args = short ? ['--short', 'HEAD'] : ['HEAD'];
+        const hash = await this.git.revparse(args);
+        return hash.trim();
+    }
     /**
      * List all worktrees in the repository
      */

package/dist/runtime/api/vcs/worktree-service.d.ts

@@ -45,7 +45,7 @@ export declare class WorktreeService extends EventEmitter {
         isConnectedToTask: boolean;
     }>>;
     /**
-     * Unified cleanup: remove branch first, then worktree
+     * Unified cleanup: remove worktree first, then branch
      * For connected worktrees, use taskId; for unconnected, use worktreePath and branchName
      */
     cleanupWorktree(params: {

package/dist/runtime/api/vcs/worktree-service.js

@@ -252,6 +252,11 @@ export class WorktreeService extends EventEmitter {
             entries = [];
         }
         for (const name of entries) {
+            const isIgnored = await this.gitService.isIgnored(name);
+            if (!isIgnored) {
+                log.debug('Skipped non-ignored env file', { name }, 'worktree-service');
+                continue;
+            }
             const sourcePath = path.join(this.projectRoot, name);
             const targetPath = path.join(worktreePath, name);
             try {
@@ -269,8 +274,11 @@ export class WorktreeService extends EventEmitter {
                         }
                     }
                 }
-                catch {
-                    // target missing, proceed
+                catch (error) {
+                    const err = error;
+                    if (err?.code !== 'ENOENT') {
+                        log.debug('Failed to inspect existing worktree env link', { name, error }, 'worktree-service');
+                    }
                 }
                 if (shouldCreate) {
                     // Remove any existing file/dir and create a symlink
@@ -280,8 +288,8 @@ export class WorktreeService extends EventEmitter {
                     log.debug('Symlinked to worktree', { name }, 'worktree-service');
                 }
             }
-            catch {
-                // Ignore missing source or failures
+            catch (error) {
+                log.debug('Failed to symlink env file', { name, error }, 'worktree-service');
             }
         }
     }
@@ -323,7 +331,7 @@ export class WorktreeService extends EventEmitter {
         }
     }
     /**
-     * Unified cleanup: remove branch first, then worktree
+     * Unified cleanup: remove worktree first, then branch
      * For connected worktrees, use taskId; for unconnected, use worktreePath and branchName
      */
     async cleanupWorktree(params) {
@@ -355,7 +363,11 @@ export class WorktreeService extends EventEmitter {
                 actualWorktreePath = worktreePath;
                 actualBranchName = branchName;
             }
-            // Step 1: Try to remove the branch first (if it's not main/master)
+            // Step 1: Remove the worktree
+            await this.gitService.removeWorktree(actualWorktreePath, force);
+            // Step 2: Prune worktrees to ensure git state is clean before branch deletion
+            await this.gitService.pruneWorktrees();
+            // Step 3: Try to remove the branch (if it's not main/master)
             if (actualBranchName !== 'main' && actualBranchName !== 'master') {
                 try {
                     await this.gitService.deleteLocalBranch(actualBranchName, true);
@@ -363,15 +375,13 @@ export class WorktreeService extends EventEmitter {
                 }
                 catch (error) {
                     // Log but continue - branch might not exist or already deleted
-                    log.warn('Could not delete branch, continuing with worktree removal', {
+                    log.warn('Could not delete branch after worktree removal', {
                         branchName: actualBranchName,
                         error: error instanceof Error ? error.message : String(error),
                     }, 'worktree-service');
                 }
             }
-            // Step 2: Remove the worktree
-            await this.gitService.removeWorktree(actualWorktreePath, force);
-            // Step 3: Clean up tracking if it was a connected worktree
+            // Step 4: Clean up tracking if it was a connected worktree
             if (isConnectedToTask && taskId) {
                 this.worktrees.delete(taskId);
                 this.emit('worktreeDeleted', taskId);
@@ -406,6 +416,8 @@ export class WorktreeService extends EventEmitter {
             }
             // Remove worktree using git service
             await this.gitService.removeWorktree(worktree.path, force);
+            // Prune worktrees to ensure git state is clean before branch deletion
+            await this.gitService.pruneWorktrees();
             // Delete local branch if it exists and is not merged
             try {
                 await this.gitService.deleteLocalBranch(worktree.branchName, force);

package/dist/runtime/api/workflows/quality-pipeline.js

@@ -3,7 +3,7 @@ import { stripNextInjectedEnv } from '../utils/stripNextEnv.js';
 import { log } from '../lib/logger.js';
 import { getSettingsService } from '../settings-service.js';
 import { CoreAgentService } from '../agent/core-agent-service.js';
-import { ClaudeCodeAdapter, CodexCliProvider } from '../agent/ai-providers/index.js';
+import { ClaudeCodeAdapter, CodexCliProvider, GeminiCliProvider, } from '../agent/ai-providers/index.js';
 import { getQualityChecksDetectionPrompt } from '../agent/prompt-service.js';
 export class QualityPipeline {
     // Expose configured checks for external orchestration/streaming
@@ -48,6 +48,7 @@ export class QualityPipeline {
             defaultModel: 'claude-sonnet-4-20250514',
         }));
         core.registerProvider('codex', new CodexCliProvider({ defaultWorkingDirectory: cwd }));
+        core.registerProvider('gemini', new GeminiCliProvider({ defaultWorkingDirectory: cwd }));
         const tools = ['Read', 'Grep', 'Glob'];
         const result = await core.execute({
             prompt,