popeye-cli 1.5.0 → 1.7.0

package/tests/workflow/plan-mode.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { parsePlanMilestones } from '../../src/workflow/plan-mode.js';
+import { parsePlanMilestones, parseTaskTag, tagToAppTarget } from '../../src/workflow/plan-mode.js';
 
 describe('parsePlanMilestones', () => {
   describe('with explicit task markers', () => {
@@ -195,6 +195,76 @@ Description: Build the main API endpoints
     });
   });
 
+  describe('app tag handling', () => {
+    it('should extract tasks with [WEB] tags', () => {
+      const plan = `
+## Milestone 1: Website Branding
+
+### Task 1.1 [WEB]: Update root layout with Gateco branding
+- **Description**: Replace default branding with Gateco colors and logo
+
+### Task 1.2 [WEB]: Create hero section component
+- **Description**: Build the landing page hero with CTA
+`;
+
+      const milestones = parsePlanMilestones(plan);
+      const allTasks = milestones.flatMap(m => m.tasks);
+
+      expect(allTasks.length).toBeGreaterThanOrEqual(2);
+      const taskNames = allTasks.map(t => t.name.toLowerCase());
+      expect(taskNames.some(n => n.includes('update root layout'))).toBe(true);
+      expect(taskNames.some(n => n.includes('create hero section'))).toBe(true);
+    });
+
+    it('should extract tasks with [INT] tags', () => {
+      const plan = `
+## Milestone 3: Integration
+
+### Task 3.1 [INT]: Wire frontend auth to backend API
+- **Description**: Connect the frontend login form to the backend auth endpoint
+
+### Task 3.2 [INT]: Set up end-to-end test suite
+- **Description**: Create E2E tests covering the full auth flow
+`;
+
+      const milestones = parsePlanMilestones(plan);
+      const allTasks = milestones.flatMap(m => m.tasks);
+
+      expect(allTasks.length).toBeGreaterThanOrEqual(2);
+      const taskNames = allTasks.map(t => t.name.toLowerCase());
+      expect(taskNames.some(n => n.includes('wire frontend auth'))).toBe(true);
+      expect(taskNames.some(n => n.includes('set up end-to-end'))).toBe(true);
+    });
+
+    it('should extract tasks with mixed app tags across milestones', () => {
+      const plan = `
+## Milestone 1: Setup
+
+### Task 1.1 [FE]: Create React component library
+- **Description**: Scaffold shared components
+
+### Task 1.2 [BE]: Implement REST API endpoints
+- **Description**: Build core API
+
+### Task 1.3 [WEB]: Build marketing landing page
+- **Description**: Create the public-facing website
+
+### Task 1.4 [INT]: Configure CI/CD pipeline
+- **Description**: Set up automated deployment
+`;
+
+      const milestones = parsePlanMilestones(plan);
+      const allTasks = milestones.flatMap(m => m.tasks);
+
+      expect(allTasks.length).toBeGreaterThanOrEqual(4);
+      const taskNames = allTasks.map(t => t.name.toLowerCase());
+      expect(taskNames.some(n => n.includes('create react component'))).toBe(true);
+      expect(taskNames.some(n => n.includes('implement rest api'))).toBe(true);
+      expect(taskNames.some(n => n.includes('build marketing landing'))).toBe(true);
+      expect(taskNames.some(n => n.includes('configure ci/cd'))).toBe(true);
+    });
+  });
+
   describe('fallback behavior', () => {
     it('should create a default milestone when no tasks found', () => {
       const plan = `
@@ -211,3 +281,43 @@ The project will do various things but no specific implementation steps are list
     });
   });
 });
+
+describe('parseTaskTag', () => {
+  it('should return WEB for [WEB] tagged tasks', () => {
+    expect(parseTaskTag('[WEB]: Update root layout')).toBe('WEB');
+    expect(parseTaskTag('[web]: Update root layout')).toBe('WEB');
+  });
+
+  it('should return FE, BE, INT for their respective tags', () => {
+    expect(parseTaskTag('[FE]: Create component')).toBe('FE');
+    expect(parseTaskTag('[BE]: Build API')).toBe('BE');
+    expect(parseTaskTag('[INT]: Wire frontend to backend')).toBe('INT');
+  });
+
+  it('should return undefined for untagged tasks', () => {
+    expect(parseTaskTag('Create component')).toBeUndefined();
+    expect(parseTaskTag('Build API endpoints')).toBeUndefined();
+  });
+
+  it('should return undefined for unknown tags', () => {
+    expect(parseTaskTag('[UNKNOWN]: Some task')).toBeUndefined();
+  });
+});
+
+describe('tagToAppTarget', () => {
+  it('should map WEB to website', () => {
+    expect(tagToAppTarget('WEB')).toBe('website');
+  });
+
+  it('should map FE to frontend', () => {
+    expect(tagToAppTarget('FE')).toBe('frontend');
+  });
+
+  it('should map BE to backend', () => {
+    expect(tagToAppTarget('BE')).toBe('backend');
+  });
+
+  it('should map INT to unified', () => {
+    expect(tagToAppTarget('INT')).toBe('unified');
+  });
+});

package/tests/workflow/tester.test.ts

@@ -0,0 +1,401 @@
+/**
+ * Tests for the Tester (QA) workflow module
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import {
+  discoverTestCommands,
+  getComponentPlaybook,
+  buildTestPlanPrompt,
+  buildTestRunReviewPrompt,
+  buildTestFixPlanPrompt,
+  isQaEnabled,
+} from '../../src/workflow/tester.js';
+import type { ProjectState, Task, Milestone } from '../../src/types/workflow.js';
+import type { TestRunReview } from '../../src/types/tester.js';
+import type { TestResult } from '../../src/workflow/test-runner.js';
+
+// Mock fs for discoverTestCommands
+vi.mock('node:fs', async () => {
+  const actual = await vi.importActual('node:fs');
+  return {
+    ...actual,
+    promises: {
+      ...(actual as Record<string, unknown>).promises,
+      readFile: vi.fn(),
+      mkdir: vi.fn(),
+      writeFile: vi.fn(),
+    },
+  };
+});
+
+const mockReadFile = vi.mocked(fs.readFile);
+
+function makeState(overrides?: Partial<ProjectState>): ProjectState {
+  return {
+    id: 'test-project',
+    name: 'Test Project',
+    idea: 'Test idea',
+    language: 'typescript',
+    openaiModel: 'gpt-4o',
+    phase: 'execution',
+    status: 'in-progress',
+    milestones: [],
+    currentMilestone: null,
+    currentTask: null,
+    consensusHistory: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+function makeTask(overrides?: Partial<Task>): Task {
+  return {
+    id: 'milestone-1-task-1',
+    name: 'Implement login endpoint',
+    description: 'Create POST /auth/login with JWT token generation',
+    status: 'in-progress',
+    ...overrides,
+  };
+}
+
+function makeMilestone(overrides?: Partial<Milestone>): Milestone {
+  return {
+    id: 'milestone-1',
+    name: 'Authentication',
+    description: 'Implement auth system',
+    status: 'in-progress',
+    tasks: [makeTask()],
+    ...overrides,
+  };
+}
+
+function makeTestResult(overrides?: Partial<TestResult>): TestResult {
+  return {
+    success: true,
+    total: 10,
+    passed: 10,
+    failed: 0,
+    output: 'All 10 tests passed',
+    ...overrides,
+  };
+}
+
+describe('discoverTestCommands', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should discover commands from package.json', async () => {
+    mockReadFile.mockImplementation(async (filePath: unknown) => {
+      if (String(filePath).endsWith('package.json')) {
+        return JSON.stringify({
+          scripts: { test: 'vitest run', lint: 'eslint .', build: 'tsc', typecheck: 'tsc --noEmit' },
+        });
+      }
+      throw new Error('ENOENT');
+    });
+
+    const result = await discoverTestCommands('/project', 'typescript');
+    expect(result.testCmd).toBe('npm test');
+    expect(result.lintCmd).toBe('npm run lint');
+    expect(result.buildCmd).toBe('npm run build');
+    expect(result.typecheckCmd).toBe('npm run typecheck');
+  });
+
+  it('should discover commands from pyproject.toml', async () => {
+    mockReadFile.mockImplementation(async (filePath: unknown) => {
+      if (String(filePath).endsWith('pyproject.toml')) {
+        return '[tool.pytest]\n[tool.ruff]\n[tool.mypy]\n';
+      }
+      throw new Error('ENOENT');
+    });
+
+    const result = await discoverTestCommands('/project', 'python');
+    expect(result.testCmd).toBe('pytest');
+    expect(result.lintCmd).toBe('ruff check .');
+    expect(result.typecheckCmd).toBe('mypy .');
+  });
+
+  it('should discover commands from Makefile', async () => {
+    mockReadFile.mockImplementation(async (filePath: unknown) => {
+      if (String(filePath).endsWith('Makefile')) {
+        return 'test:\n\tpytest\nlint:\n\truff\nbuild:\n\tdocker build .\n';
+      }
+      throw new Error('ENOENT');
+    });
+
+    const result = await discoverTestCommands('/project', 'python');
+    expect(result.testCmd).toBe('make test');
+    expect(result.lintCmd).toBe('make lint');
+    expect(result.buildCmd).toBe('make build');
+  });
+
+  it('should use fallback defaults when no config files exist', async () => {
+    mockReadFile.mockRejectedValue(new Error('ENOENT'));
+
+    const tsResult = await discoverTestCommands('/project', 'typescript');
+    expect(tsResult.testCmd).toBe('npx vitest run');
+    expect(tsResult.lintCmd).toBe('npx eslint .');
+    expect(tsResult.buildCmd).toBe('npm run build');
+
+    const pyResult = await discoverTestCommands('/project', 'python');
+    expect(pyResult.testCmd).toBe('pytest');
+    expect(pyResult.lintCmd).toBe('ruff check .');
+  });
+
+  it('should handle missing files gracefully', async () => {
+    mockReadFile.mockRejectedValue(new Error('ENOENT'));
+    const result = await discoverTestCommands('/project', 'website');
+    // Should not throw
+    expect(result).toBeDefined();
+    expect(result.testCmd).toBeDefined(); // Falls back to defaults
+  });
+});
+
+describe('getComponentPlaybook', () => {
+  it('should return Python-specific guidance for python language', () => {
+    const playbook = getComponentPlaybook('python');
+    expect(playbook).toContain('pytest');
+    expect(playbook).toContain('FastAPI TestClient');
+    expect(playbook).not.toContain('Vitest');
+  });
+
+  it('should return TypeScript-specific guidance for typescript language', () => {
+    const playbook = getComponentPlaybook('typescript');
+    expect(playbook).toContain('Vitest');
+    expect(playbook).toContain('React Testing Library');
+    expect(playbook).not.toContain('pytest');
+  });
+
+  it('should return combined guidance for website language', () => {
+    const playbook = getComponentPlaybook('website');
+    expect(playbook).toContain('Vitest');
+    expect(playbook).toContain('axe-core');
+    expect(playbook).toContain('SEO meta tags');
+  });
+
+  it('should return comprehensive playbook for fullstack/all', () => {
+    const playbook = getComponentPlaybook('fullstack');
+    expect(playbook).toContain('pytest');
+    expect(playbook).toContain('Vitest');
+    expect(playbook).toContain('API Contract');
+
+    const allPlaybook = getComponentPlaybook('all');
+    expect(allPlaybook).toContain('pytest');
+    expect(allPlaybook).toContain('Vitest');
+  });
+
+  it('should return non-empty content for every language', () => {
+    const languages = ['python', 'typescript', 'website', 'fullstack', 'all'] as const;
+    for (const lang of languages) {
+      const playbook = getComponentPlaybook(lang);
+      expect(playbook.length).toBeGreaterThan(50);
+    }
+  });
+});
+
+describe('buildTestPlanPrompt', () => {
+  it('should include approved code plan in the prompt', () => {
+    const prompt = buildTestPlanPrompt(
+      makeTask(), makeMilestone(), makeState(),
+      'Implement login with bcrypt hashing',
+      { testCmd: 'npm test', lintCmd: null, buildCmd: null, typecheckCmd: null },
+    );
+    expect(prompt).toContain('Implement login with bcrypt hashing');
+    expect(prompt).toContain('Approved Code Plan');
+  });
+
+  it('should include language-specific playbook', () => {
+    const prompt = buildTestPlanPrompt(
+      makeTask(), makeMilestone(), makeState({ language: 'python' }),
+      'code plan',
+      { testCmd: 'pytest', lintCmd: null, buildCmd: null, typecheckCmd: null },
+    );
+    expect(prompt).toContain('pytest');
+    expect(prompt).toContain('Python Testing Playbook');
+  });
+
+  it('should include discovered commands', () => {
+    const prompt = buildTestPlanPrompt(
+      makeTask(), makeMilestone(), makeState(),
+      'plan',
+      { testCmd: 'vitest run', lintCmd: 'eslint .', buildCmd: 'tsc', typecheckCmd: null },
+    );
+    expect(prompt).toContain('Test: vitest run');
+    expect(prompt).toContain('Lint: eslint .');
+    expect(prompt).toContain('Build: tsc');
+  });
+
+  it('should include task context', () => {
+    const prompt = buildTestPlanPrompt(
+      makeTask({ name: 'Implement OAuth' }),
+      makeMilestone(),
+      makeState({ name: 'MyApp' }),
+      'plan',
+      { testCmd: null, lintCmd: null, buildCmd: null, typecheckCmd: null },
+    );
+    expect(prompt).toContain('Implement OAuth');
+    expect(prompt).toContain('MyApp');
+  });
+
+  it('should refer to "the Tester", not "Claude"', () => {
+    const prompt = buildTestPlanPrompt(
+      makeTask(), makeMilestone(), makeState(), 'plan',
+      { testCmd: null, lintCmd: null, buildCmd: null, typecheckCmd: null },
+    );
+    expect(prompt).toContain('the Tester');
+    expect(prompt.toLowerCase()).not.toContain('claude');
+  });
+
+  it('should include completed tasks for context', () => {
+    const milestone = makeMilestone({
+      tasks: [
+        makeTask({ id: 't1', name: 'Setup DB', status: 'complete' }),
+        makeTask({ id: 't2', name: 'Current task', status: 'in-progress' }),
+      ],
+    });
+    const prompt = buildTestPlanPrompt(
+      makeTask(), milestone, makeState(), 'plan',
+      { testCmd: null, lintCmd: null, buildCmd: null, typecheckCmd: null },
+    );
+    expect(prompt).toContain('Setup DB');
+  });
+
+  it('should handle empty task description', () => {
+    const task = makeTask({ description: '' });
+    const prompt = buildTestPlanPrompt(
+      task, makeMilestone(), makeState(), 'plan',
+      { testCmd: null, lintCmd: null, buildCmd: null, typecheckCmd: null },
+    );
+    // Should not throw and should still contain the task name
+    expect(prompt).toContain(task.name);
+  });
+});
+
+describe('buildTestRunReviewPrompt', () => {
+  it('should include test plan criteria and actual output', () => {
+    const prompt = buildTestRunReviewPrompt(
+      makeTask(),
+      'Test plan with acceptance criteria',
+      makeTestResult({ output: 'PASS: login test', passed: 5, total: 5 }),
+      makeState(),
+    );
+    expect(prompt).toContain('Test plan with acceptance criteria');
+    expect(prompt).toContain('PASS: login test');
+    expect(prompt).toContain('Passed: 5');
+  });
+
+  it('should include failed test names', () => {
+    const prompt = buildTestRunReviewPrompt(
+      makeTask(),
+      'test plan',
+      makeTestResult({
+        success: false,
+        failed: 2,
+        passed: 3,
+        total: 5,
+        failedTests: ['test_login_invalid', 'test_login_expired'],
+      }),
+      makeState(),
+    );
+    expect(prompt).toContain('test_login_invalid');
+    expect(prompt).toContain('test_login_expired');
+  });
+
+  it('should handle empty test output', () => {
+    const prompt = buildTestRunReviewPrompt(
+      makeTask(),
+      'test plan',
+      makeTestResult({ output: '' }),
+      makeState(),
+    );
+    expect(prompt).toBeDefined();
+    expect(prompt).toContain('the Tester');
+  });
+
+  it('should truncate long output to 5000 chars', () => {
+    const longOutput = 'x'.repeat(10000);
+    const prompt = buildTestRunReviewPrompt(
+      makeTask(), 'plan',
+      makeTestResult({ output: longOutput }),
+      makeState(),
+    );
+    // The prompt should not contain all 10000 chars of output
+    expect(prompt.length).toBeLessThan(longOutput.length);
+  });
+});
+
+describe('buildTestFixPlanPrompt', () => {
+  const review: TestRunReview = {
+    verdict: 'FAIL',
+    summary: 'Login test failed due to missing hash',
+    evidenceReviewed: ['test output'],
+    failures: ['test_login_valid: AssertionError'],
+    gaps: [],
+    recommendations: ['Add bcrypt import'],
+    requiresConsensus: true,
+  };
+
+  it('should include root cause from review', () => {
+    const prompt = buildTestFixPlanPrompt(
+      makeTask(), 'test plan',
+      makeTestResult({ success: false, failed: 1 }),
+      review,
+      makeState(),
+    );
+    expect(prompt).toContain('Login test failed due to missing hash');
+    expect(prompt).toContain('test_login_valid: AssertionError');
+  });
+
+  it('should detect test runner crash', () => {
+    const crashResult = makeTestResult({
+      success: false, passed: 0, failed: 50, output: 'ImportError: cannot import bcrypt',
+    });
+    const prompt = buildTestFixPlanPrompt(
+      makeTask(), 'test plan', crashResult, review, makeState(),
+    );
+    expect(prompt).toContain('test runner crash');
+  });
+
+  it('should refer to "the Tester", not "Claude"', () => {
+    const prompt = buildTestFixPlanPrompt(
+      makeTask(), 'plan',
+      makeTestResult({ success: false, failed: 1 }),
+      review, makeState(),
+    );
+    expect(prompt).toContain('the Tester');
+    expect(prompt.toLowerCase()).not.toContain('claude');
+  });
+
+  it('should handle no tests needed scenario', () => {
+    const emptyReview: TestRunReview = {
+      ...review,
+      failures: [],
+      summary: 'No test failures to fix',
+    };
+    const prompt = buildTestFixPlanPrompt(
+      makeTask(), 'plan',
+      makeTestResult({ success: true, failed: 0 }),
+      emptyReview, makeState(),
+    );
+    expect(prompt).toContain('No test failures to fix');
+  });
+});
+
+describe('isQaEnabled', () => {
+  it('should return true when qaEnabled is true', () => {
+    expect(isQaEnabled(makeState({ qaEnabled: true }))).toBe(true);
+  });
+
+  it('should return false when qaEnabled is false', () => {
+    expect(isQaEnabled(makeState({ qaEnabled: false }))).toBe(false);
+  });
+
+  it('should return false when qaEnabled is undefined (existing projects)', () => {
+    expect(isQaEnabled(makeState())).toBe(false);
+  });
+});

package/tests/workflow/website-strategy.test.ts

@@ -11,6 +11,7 @@ import {
   loadWebsiteStrategy,
   formatStrategyForPlanContext,
   isStrategyStale,
+  packProductContext,
 } from '../../src/workflow/website-strategy.js';
 import type {
   WebsiteStrategyDocument,
@@ -189,3 +190,57 @@ describe('isStrategyStale', () => {
     expect(loaded!.strategy.messaging.headline).toBe('Ship Code 10x Faster');
   });
 });
+
+describe('packProductContext', () => {
+  it('preserves high-priority docs (spec, pricing) within budget', () => {
+    const context = [
+      '--- random-notes.md ---',
+      'Some random notes about the project.',
+      '',
+      '--- product-spec.md ---',
+      '# Product Specification\nThis is the product specification.',
+      '',
+      '--- pricing.md ---',
+      '# Pricing\nFree, Pro, Enterprise tiers.',
+      '',
+      '--- color-scheme.md ---',
+      '# Colors\nPrimary: #2563EB',
+    ].join('\n');
+
+    const packed = packProductContext(context, 500);
+
+    // Spec should come first (priority 1)
+    const specIndex = packed.indexOf('product-spec.md');
+    const pricingIndex = packed.indexOf('pricing.md');
+    const randomIndex = packed.indexOf('random-notes.md');
+
+    expect(specIndex).toBeGreaterThanOrEqual(0);
+    expect(pricingIndex).toBeGreaterThanOrEqual(0);
+    // Spec should appear before random notes (or random notes may be cut)
+    if (randomIndex >= 0) {
+      expect(specIndex).toBeLessThan(randomIndex);
+    }
+  });
+
+  it('handles context without headers gracefully', () => {
+    const context = 'Just raw text without any headers';
+
+    const packed = packProductContext(context, 100);
+
+    expect(packed).toBe(context);
+  });
+
+  it('respects budget limit', () => {
+    const largeContext = [
+      '--- spec.md ---',
+      'x'.repeat(5000),
+      '',
+      '--- pricing.md ---',
+      'y'.repeat(5000),
+    ].join('\n');
+
+    const packed = packProductContext(largeContext, 1000);
+
+    expect(packed.length).toBeLessThanOrEqual(1100); // Some tolerance for headers
+  });
+});