automaker/apps/server/tests/integration/services/auto-mode-service.integration.test.ts

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { AutoModeService } from '@/services/auto-mode-service.js';
import { ProviderFactory } from '@/providers/provider-factory.js';
import { FeatureLoader } from '@/services/feature-loader.js';
import {
  createTestGitRepo,
  createTestFeature,
  listBranches,
  listWorktrees,
  branchExists,
  worktreeExists,
  type TestRepo,
} from '../helpers/git-test-repo.js';
import * as fs from 'fs/promises';
import * as path from 'path';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

vi.mock('@/providers/provider-factory.js');

describe('auto-mode-service.ts (integration)', () => {
  let service: AutoModeService;
  let testRepo: TestRepo;
  let featureLoader: FeatureLoader;
  const mockEvents = {
    subscribe: vi.fn(),
    emit: vi.fn(),
  };

  beforeEach(async () => {
    vi.clearAllMocks();
    service = new AutoModeService(mockEvents as any);
    featureLoader = new FeatureLoader();
    testRepo = await createTestGitRepo();
  });

  afterEach(async () => {
    // Stop any running auto loops
    await service.stopAutoLoop();

    // Cleanup test repo
    if (testRepo) {
      await testRepo.cleanup();
    }
  });

  describe('worktree operations', () => {
    it('should use existing git worktree for feature', async () => {
      const branchName = 'feature/test-feature-1';

      // Create a test feature with branchName set
      await createTestFeature(testRepo.path, 'test-feature-1', {
        id: 'test-feature-1',
        category: 'test',
        description: 'Test feature',
        status: 'pending',
        branchName: branchName,
      });

      // Create worktree before executing (worktrees are now created when features are added/edited)
      const worktreesDir = path.join(testRepo.path, '.worktrees');
      const worktreePath = path.join(worktreesDir, 'test-feature-1');
      await fs.mkdir(worktreesDir, { recursive: true });
      await execAsync(`git worktree add -b ${branchName} "${worktreePath}" HEAD`, {
        cwd: testRepo.path,
      });

      // Mock provider to complete quickly
      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'assistant',
            message: {
              role: 'assistant',
              content: [{ type: 'text', text: 'Feature implemented' }],
            },
          };
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      // Execute feature with worktrees enabled
      await service.executeFeature(
        testRepo.path,
        'test-feature-1',
        true, // useWorktrees
        false // isAutoMode
      );

      // Verify branch exists (was created when worktree was created)
      const branches = await listBranches(testRepo.path);
      expect(branches).toContain(branchName);

      // Verify worktree exists and is being used
      // The service should have found and used the worktree (check via logs)
      // We can verify the worktree exists by checking git worktree list
      const worktrees = await listWorktrees(testRepo.path);
      expect(worktrees.length).toBeGreaterThan(0);
      // Verify that at least one worktree path contains our feature ID
      const worktreePathsMatch = worktrees.some(
        (wt) => wt.includes('test-feature-1') || wt.includes('.worktrees')
      );
      expect(worktreePathsMatch).toBe(true);

      // Note: Worktrees are not automatically cleaned up by the service
      // This is expected behavior - manual cleanup is required
    }, 30000);

    it('should handle error gracefully', async () => {
      await createTestFeature(testRepo.path, 'test-feature-error', {
        id: 'test-feature-error',
        category: 'test',
        description: 'Test feature that errors',
        status: 'pending',
      });

      // Mock provider that throws error
      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          throw new Error('Provider error');
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      // Execute feature (should handle error)
      await service.executeFeature(testRepo.path, 'test-feature-error', true, false);

      // Verify feature status was updated to backlog (error status)
      const feature = await featureLoader.get(testRepo.path, 'test-feature-error');
      expect(feature?.status).toBe('backlog');
    }, 30000);

    it('should work without worktrees', async () => {
      await createTestFeature(testRepo.path, 'test-no-worktree', {
        id: 'test-no-worktree',
        category: 'test',
        description: 'Test without worktree',
        status: 'pending',
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      // Execute without worktrees
      await service.executeFeature(
        testRepo.path,
        'test-no-worktree',
        false, // useWorktrees = false
        false
      );

      // Feature should be updated successfully
      const feature = await featureLoader.get(testRepo.path, 'test-no-worktree');
      expect(feature?.status).toBe('waiting_approval');
    }, 30000);
  });

  describe('feature execution', () => {
    it('should execute feature and update status', async () => {
      await createTestFeature(testRepo.path, 'feature-exec-1', {
        id: 'feature-exec-1',
        category: 'ui',
        description: 'Execute this feature',
        status: 'pending',
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'assistant',
            message: {
              role: 'assistant',
              content: [{ type: 'text', text: 'Implemented the feature' }],
            },
          };
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      await service.executeFeature(
        testRepo.path,
        'feature-exec-1',
        false, // Don't use worktrees so agent output is saved to main project
        false
      );

      // Check feature status was updated
      const feature = await featureLoader.get(testRepo.path, 'feature-exec-1');
      expect(feature?.status).toBe('waiting_approval');

      // Check agent output was saved
      const agentOutput = await featureLoader.getAgentOutput(testRepo.path, 'feature-exec-1');
      expect(agentOutput).toBeTruthy();
      expect(agentOutput).toContain('Implemented the feature');
    }, 30000);

    it('should handle feature not found', async () => {
      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      // Try to execute non-existent feature
      await service.executeFeature(testRepo.path, 'nonexistent-feature', true, false);

      // Should emit error event
      expect(mockEvents.emit).toHaveBeenCalledWith(
        expect.any(String),
        expect.objectContaining({
          featureId: 'nonexistent-feature',
          error: expect.stringContaining('not found'),
        })
      );
    }, 30000);

    it('should prevent duplicate feature execution', async () => {
      await createTestFeature(testRepo.path, 'feature-dup', {
        id: 'feature-dup',
        category: 'test',
        description: 'Duplicate test',
        status: 'pending',
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          // Simulate slow execution
          await new Promise((resolve) => setTimeout(resolve, 500));
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      // Start first execution
      const promise1 = service.executeFeature(testRepo.path, 'feature-dup', false, false);

      // Try to start second execution (should throw)
      await expect(
        service.executeFeature(testRepo.path, 'feature-dup', false, false)
      ).rejects.toThrow('already running');

      await promise1;
    }, 30000);

    it('should use feature-specific model', async () => {
      await createTestFeature(testRepo.path, 'feature-model', {
        id: 'feature-model',
        category: 'test',
        description: 'Model test',
        status: 'pending',
        model: 'claude-sonnet-4-20250514',
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      await service.executeFeature(testRepo.path, 'feature-model', false, false);

      // Should have used claude-sonnet-4-20250514
      expect(ProviderFactory.getProviderForModel).toHaveBeenCalledWith('claude-sonnet-4-20250514');
    }, 30000);
  });

  describe('auto loop', () => {
    it('should start and stop auto loop', async () => {
      const startPromise = service.startAutoLoop(testRepo.path, 2);

      // Give it time to start
      await new Promise((resolve) => setTimeout(resolve, 100));

      // Stop the loop
      const runningCount = await service.stopAutoLoop();

      expect(runningCount).toBe(0);
      await startPromise.catch(() => {}); // Cleanup
    }, 10000);

    it('should process pending features in auto loop', async () => {
      // Create multiple pending features
      await createTestFeature(testRepo.path, 'auto-1', {
        id: 'auto-1',
        category: 'test',
        description: 'Auto feature 1',
        status: 'pending',
      });

      await createTestFeature(testRepo.path, 'auto-2', {
        id: 'auto-2',
        category: 'test',
        description: 'Auto feature 2',
        status: 'pending',
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      // Start auto loop
      const startPromise = service.startAutoLoop(testRepo.path, 2);

      // Wait for features to be processed
      await new Promise((resolve) => setTimeout(resolve, 3000));

      // Stop the loop
      await service.stopAutoLoop();
      await startPromise.catch(() => {});

      // Check that features were updated
      const feature1 = await featureLoader.get(testRepo.path, 'auto-1');
      const feature2 = await featureLoader.get(testRepo.path, 'auto-2');

      // At least one should have been processed
      const processedCount = [feature1, feature2].filter(
        (f) => f?.status === 'waiting_approval' || f?.status === 'in_progress'
      ).length;

      expect(processedCount).toBeGreaterThan(0);
    }, 15000);

    it('should respect max concurrency', async () => {
      // Create 5 features
      for (let i = 1; i <= 5; i++) {
        await createTestFeature(testRepo.path, `concurrent-${i}`, {
          id: `concurrent-${i}`,
          category: 'test',
          description: `Concurrent feature ${i}`,
          status: 'pending',
        });
      }

      let concurrentCount = 0;
      let maxConcurrent = 0;

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          concurrentCount++;
          maxConcurrent = Math.max(maxConcurrent, concurrentCount);

          // Simulate work
          await new Promise((resolve) => setTimeout(resolve, 500));

          concurrentCount--;

          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      // Start with max concurrency of 2
      const startPromise = service.startAutoLoop(testRepo.path, 2);

      // Wait for some features to be processed
      await new Promise((resolve) => setTimeout(resolve, 3000));

      await service.stopAutoLoop();
      await startPromise.catch(() => {});

      // Max concurrent should not exceed 2
      expect(maxConcurrent).toBeLessThanOrEqual(2);
    }, 15000);

    it('should emit auto mode events', async () => {
      const startPromise = service.startAutoLoop(testRepo.path, 1);

      // Wait for start event
      await new Promise((resolve) => setTimeout(resolve, 100));

      // Check start event was emitted
      const startEvent = mockEvents.emit.mock.calls.find((call) =>
        call[1]?.message?.includes('Auto mode started')
      );
      expect(startEvent).toBeTruthy();

      await service.stopAutoLoop();
      await startPromise.catch(() => {});

      // Check stop event was emitted (emitted immediately by stopAutoLoop)
      const stopEvent = mockEvents.emit.mock.calls.find(
        (call) =>
          call[1]?.type === 'auto_mode_stopped' || call[1]?.message?.includes('Auto mode stopped')
      );
      expect(stopEvent).toBeTruthy();
    }, 10000);
  });

  describe('error handling', () => {
    it('should handle provider errors gracefully', async () => {
      await createTestFeature(testRepo.path, 'error-feature', {
        id: 'error-feature',
        category: 'test',
        description: 'Error test',
        status: 'pending',
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          throw new Error('Provider execution failed');
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      // Should not throw
      await service.executeFeature(testRepo.path, 'error-feature', true, false);

      // Feature should be marked as backlog (error status)
      const feature = await featureLoader.get(testRepo.path, 'error-feature');
      expect(feature?.status).toBe('backlog');
    }, 30000);

    it('should continue auto loop after feature error', async () => {
      await createTestFeature(testRepo.path, 'fail-1', {
        id: 'fail-1',
        category: 'test',
        description: 'Will fail',
        status: 'pending',
      });

      await createTestFeature(testRepo.path, 'success-1', {
        id: 'success-1',
        category: 'test',
        description: 'Will succeed',
        status: 'pending',
      });

      let callCount = 0;
      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          callCount++;
          if (callCount === 1) {
            throw new Error('First feature fails');
          }
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      const startPromise = service.startAutoLoop(testRepo.path, 1);

      // Wait for both features to be attempted
      await new Promise((resolve) => setTimeout(resolve, 5000));

      await service.stopAutoLoop();
      await startPromise.catch(() => {});

      // Both features should have been attempted
      expect(callCount).toBeGreaterThanOrEqual(1);
    }, 15000);
  });

  describe('planning mode', () => {
    it('should execute feature with skip planning mode', async () => {
      await createTestFeature(testRepo.path, 'skip-plan-feature', {
        id: 'skip-plan-feature',
        category: 'test',
        description: 'Feature with skip planning',
        status: 'pending',
        planningMode: 'skip',
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'assistant',
            message: {
              role: 'assistant',
              content: [{ type: 'text', text: 'Feature implemented' }],
            },
          };
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      await service.executeFeature(testRepo.path, 'skip-plan-feature', false, false);

      const feature = await featureLoader.get(testRepo.path, 'skip-plan-feature');
      expect(feature?.status).toBe('waiting_approval');
    }, 30000);

    it('should execute feature with lite planning mode without approval', async () => {
      await createTestFeature(testRepo.path, 'lite-plan-feature', {
        id: 'lite-plan-feature',
        category: 'test',
        description: 'Feature with lite planning',
        status: 'pending',
        planningMode: 'lite',
        requirePlanApproval: false,
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'assistant',
            message: {
              role: 'assistant',
              content: [
                {
                  type: 'text',
                  text: '[PLAN_GENERATED] Planning outline complete.\n\nFeature implemented',
                },
              ],
            },
          };
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      await service.executeFeature(testRepo.path, 'lite-plan-feature', false, false);

      const feature = await featureLoader.get(testRepo.path, 'lite-plan-feature');
      expect(feature?.status).toBe('waiting_approval');
    }, 30000);

    it('should emit planning_started event for spec mode', async () => {
      await createTestFeature(testRepo.path, 'spec-plan-feature', {
        id: 'spec-plan-feature',
        category: 'test',
        description: 'Feature with spec planning',
        status: 'pending',
        planningMode: 'spec',
        requirePlanApproval: false,
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'assistant',
            message: {
              role: 'assistant',
              content: [
                { type: 'text', text: 'Spec generated\n\n[SPEC_GENERATED] Review the spec.' },
              ],
            },
          };
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      await service.executeFeature(testRepo.path, 'spec-plan-feature', false, false);

      // Check planning_started event was emitted
      const planningEvent = mockEvents.emit.mock.calls.find((call) => call[1]?.mode === 'spec');
      expect(planningEvent).toBeTruthy();
    }, 30000);

    it('should handle feature with full planning mode', async () => {
      await createTestFeature(testRepo.path, 'full-plan-feature', {
        id: 'full-plan-feature',
        category: 'test',
        description: 'Feature with full planning',
        status: 'pending',
        planningMode: 'full',
        requirePlanApproval: false,
      });

      const mockProvider = {
        getName: () => 'claude',
        executeQuery: async function* () {
          yield {
            type: 'assistant',
            message: {
              role: 'assistant',
              content: [
                { type: 'text', text: 'Full spec with phases\n\n[SPEC_GENERATED] Review.' },
              ],
            },
          };
          yield {
            type: 'result',
            subtype: 'success',
          };
        },
      };

      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);

      await service.executeFeature(testRepo.path, 'full-plan-feature', false, false);

      // Check planning_started event was emitted with full mode
      const planningEvent = mockEvents.emit.mock.calls.find((call) => call[1]?.mode === 'full');
      expect(planningEvent).toBeTruthy();
    }, 30000);

    it('should track pending approval correctly', async () => {
      // Initially no pending approvals
      expect(service.hasPendingApproval('non-existent')).toBe(false);
    });

    it('should cancel pending approval gracefully', () => {
      // Should not throw when cancelling non-existent approval
      expect(() => service.cancelPlanApproval('non-existent')).not.toThrow();
    });

    it('should resolve approval with error for non-existent feature', async () => {
      const result = await service.resolvePlanApproval(
        'non-existent',
        true,
        undefined,
        undefined,
        undefined
      );
      expect(result.success).toBe(false);
      expect(result.error).toContain('No pending approval');
    });
  });
});