popeye-cli 2.2.0 → 2.7.0

package/tests/shared/text-utils.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Tests for isNoneVariant() and normalizeIssueList()
+ * Ensures false-positive blocking issues are filtered while real issues are preserved.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { isNoneVariant, normalizeIssueList } from '../../src/shared/text-utils.js';
+
+describe('isNoneVariant', () => {
+  describe('true positives (should be filtered out)', () => {
+    it('should detect exact "none" variants', () => {
+      expect(isNoneVariant('None')).toBe(true);
+      expect(isNoneVariant('none')).toBe(true);
+      expect(isNoneVariant('NONE')).toBe(true);
+      expect(isNoneVariant('None.')).toBe(true);
+      expect(isNoneVariant('N/A')).toBe(true);
+      expect(isNoneVariant('n/a')).toBe(true);
+      expect(isNoneVariant('NA')).toBe(true);
+      expect(isNoneVariant('Nil')).toBe(true);
+      expect(isNoneVariant('Nothing')).toBe(true);
+    });
+
+    it('should detect bullet-prefixed none-variants', () => {
+      expect(isNoneVariant('- None')).toBe(true);
+      expect(isNoneVariant('* N/A')).toBe(true);
+      expect(isNoneVariant('+ Nothing')).toBe(true);
+      expect(isNoneVariant('1) Nothing')).toBe(true);
+      expect(isNoneVariant('1. None')).toBe(true);
+    });
+
+    it('should detect "no issues" phrases', () => {
+      expect(isNoneVariant('No blocking issues')).toBe(true);
+      expect(isNoneVariant('No blocking issues found')).toBe(true);
+      expect(isNoneVariant('No issues')).toBe(true);
+      expect(isNoneVariant('No issues found')).toBe(true);
+      expect(isNoneVariant('No critical issues')).toBe(true);
+      expect(isNoneVariant('No blockers')).toBe(true);
+      expect(isNoneVariant('No showstoppers')).toBe(true);
+      expect(isNoneVariant('No concerns')).toBe(true);
+      expect(isNoneVariant('No significant issues')).toBe(true);
+      expect(isNoneVariant('No major blocking issues')).toBe(true);
+    });
+
+    it('should detect "none identified/found" phrases', () => {
+      expect(isNoneVariant('None identified')).toBe(true);
+      expect(isNoneVariant('None found')).toBe(true);
+      expect(isNoneVariant('None detected')).toBe(true);
+      expect(isNoneVariant('None at this time')).toBe(true);
+      expect(isNoneVariant('None noted')).toBe(true);
+      expect(isNoneVariant('None observed')).toBe(true);
+      expect(isNoneVariant('None reported')).toBe(true);
+      expect(isNoneVariant('None applicable')).toBe(true);
+    });
+
+    it('should detect "there are no" phrases', () => {
+      expect(isNoneVariant('There are no blocking issues')).toBe(true);
+      expect(isNoneVariant('There are no significant issues')).toBe(true);
+      expect(isNoneVariant('There are no major blocking issues')).toBe(true);
+      expect(isNoneVariant('There are no critical blockers')).toBe(true);
+    });
+
+    it('should handle empty and whitespace strings', () => {
+      expect(isNoneVariant('')).toBe(true);
+      expect(isNoneVariant('   ')).toBe(true);
+      expect(isNoneVariant('\n')).toBe(true);
+      expect(isNoneVariant('\t')).toBe(true);
+    });
+
+    it('should strip trailing punctuation before matching', () => {
+      expect(isNoneVariant('None.')).toBe(true);
+      expect(isNoneVariant('N/A.')).toBe(true);
+      expect(isNoneVariant('No issues!')).toBe(true);
+      expect(isNoneVariant('No blocking issues found.')).toBe(true);
+    });
+  });
+
+  describe('true negatives (must keep as real issues)', () => {
+    it('should keep real blocking issues', () => {
+      expect(isNoneVariant('Missing authentication layer')).toBe(false);
+      expect(isNoneVariant('SQL injection vulnerability')).toBe(false);
+      expect(isNoneVariant('The API has no rate limiting')).toBe(false);
+      expect(isNoneVariant('Authentication is not implemented')).toBe(false);
+    });
+
+    it('should keep "No rollback plan" (not issues/concerns/problems/blockers)', () => {
+      expect(isNoneVariant('No rollback plan defined')).toBe(false);
+    });
+
+    it('should keep "None of the..." sentences (classic false positive)', () => {
+      expect(isNoneVariant('None of the database migrations handle rollback')).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should reject long plain text (>80 chars) as real issues', () => {
+      const longIssue = 'The authentication system does not properly validate JWT tokens which could lead to unauthorized access to protected endpoints';
+      expect(longIssue.length).toBeGreaterThan(80);
+      expect(isNoneVariant(longIssue)).toBe(false);
+    });
+
+    it('should still detect long none-variant phrases', () => {
+      // A "no issues" phrase that happens to be long due to qualifiers
+      expect(isNoneVariant('No significant blocking issues or critical concerns identified in this review.')).toBe(true);
+    });
+  });
+});
+
+describe('normalizeIssueList', () => {
+  it('should filter out all none-variants from a list', () => {
+    const input = [
+      'None',
+      'No blocking issues found',
+      'Missing authentication layer',
+      'N/A',
+      'SQL injection vulnerability',
+    ];
+    const result = normalizeIssueList(input);
+    expect(result).toEqual([
+      'Missing authentication layer',
+      'SQL injection vulnerability',
+    ]);
+  });
+
+  it('should handle empty lists', () => {
+    expect(normalizeIssueList([])).toEqual([]);
+  });
+
+  it('should filter out empty and whitespace-only items', () => {
+    const input = ['', '  ', 'Real issue', '\t'];
+    const result = normalizeIssueList(input);
+    expect(result).toEqual(['Real issue']);
+  });
+
+  it('should trim items before checking', () => {
+    const input = ['  None  ', '  Missing auth  '];
+    const result = normalizeIssueList(input);
+    expect(result).toEqual(['Missing auth']);
+  });
+
+  it('should preserve order of real issues', () => {
+    const input = [
+      'None',
+      'First real issue',
+      'N/A',
+      'Second real issue',
+      'Third real issue',
+    ];
+    const result = normalizeIssueList(input);
+    expect(result).toEqual([
+      'First real issue',
+      'Second real issue',
+      'Third real issue',
+    ]);
+  });
+});

package/tests/state/progress-analysis.test.ts

@@ -0,0 +1,375 @@
+/**
+ * Tests for analyzeProjectProgress and verifyProjectCompletion
+ *
+ * Validates that the progress analysis correctly handles the edge case
+ * where a project is genuinely complete but has no milestone tracking data.
+ */
+
+import { describe, it, expect, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import {
+  analyzeProjectProgress,
+  verifyProjectCompletion,
+} from '../../src/state/index.js';
+
+/**
+ * Build a minimal valid ProjectState JSON object.
+ *
+ * @param overrides - Partial fields to merge on top of the defaults
+ * @returns A plain object that satisfies ProjectStateSchema
+ */
+function buildState(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  const now = new Date().toISOString();
+  return {
+    id: 'test-id',
+    name: 'test-project',
+    idea: 'A test project',
+    language: 'typescript',
+    openaiModel: 'gpt-4o',
+    phase: 'complete',
+    status: 'complete',
+    specification: '',
+    plan: '',
+    milestones: [],
+    currentMilestone: null,
+    currentTask: null,
+    consensusHistory: [],
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+}
+
+/**
+ * Write a state.json file inside a temp directory's .popeye/ folder.
+ *
+ * @param tmpDir - The temporary project root directory
+ * @param state - The state object to write
+ */
+async function writeState(tmpDir: string, state: Record<string, unknown>): Promise<void> {
+  const stateDir = path.join(tmpDir, '.popeye');
+  await fs.mkdir(stateDir, { recursive: true });
+  await fs.writeFile(path.join(stateDir, 'state.json'), JSON.stringify(state));
+}
+
+/**
+ * Write a plan file so readPlanFile can parse it.
+ *
+ * @param tmpDir - The temporary project root directory
+ * @param content - Markdown content for the plan
+ */
+async function writePlan(tmpDir: string, content: string): Promise<void> {
+  const docsDir = path.join(tmpDir, 'docs');
+  await fs.mkdir(docsDir, { recursive: true });
+  await fs.writeFile(path.join(docsDir, 'PLAN.md'), content);
+}
+
+// Track temp dirs for cleanup
+const tmpDirs: string[] = [];
+
+async function makeTmpDir(): Promise<string> {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'progress-test-'));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(async () => {
+  for (const dir of tmpDirs) {
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+  tmpDirs.length = 0;
+});
+
+describe('analyzeProjectProgress', () => {
+  it('should treat zero milestones + explicitly complete as genuinely complete', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'complete',
+      milestones: [],
+    }));
+
+    const result = await analyzeProjectProgress(tmpDir);
+
+    expect(result.isActuallyComplete).toBe(true);
+    expect(result.statusMismatch).toBe(false);
+    expect(result.totalMilestones).toBe(0);
+    expect(result.totalTasks).toBe(0);
+  });
+
+  it('should detect mismatch when zero milestones but phase is not complete', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'execution',
+      milestones: [],
+    }));
+
+    const result = await analyzeProjectProgress(tmpDir);
+
+    expect(result.isActuallyComplete).toBe(false);
+    expect(result.statusMismatch).toBe(true);
+  });
+
+  it('should treat non-zero milestones with all tasks complete as genuinely complete', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'complete',
+      milestones: [
+        {
+          id: 'm1',
+          name: 'Milestone 1',
+          description: 'First milestone',
+          status: 'complete',
+          tasks: [
+            { id: 't1', name: 'Task 1', description: 'First task', status: 'complete' },
+            { id: 't2', name: 'Task 2', description: 'Second task', status: 'complete' },
+          ],
+        },
+        {
+          id: 'm2',
+          name: 'Milestone 2',
+          description: 'Second milestone',
+          status: 'complete',
+          tasks: [
+            { id: 't3', name: 'Task 3', description: 'Third task', status: 'complete' },
+          ],
+        },
+      ],
+    }));
+
+    const result = await analyzeProjectProgress(tmpDir);
+
+    expect(result.isActuallyComplete).toBe(true);
+    expect(result.statusMismatch).toBe(false);
+    expect(result.totalMilestones).toBe(2);
+    expect(result.completedTasks).toBe(3);
+  });
+
+  it('should detect mismatch when non-zero milestones are incomplete', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'complete',
+      milestones: [
+        {
+          id: 'm1',
+          name: 'Milestone 1',
+          description: 'First milestone',
+          status: 'complete',
+          tasks: [
+            { id: 't1', name: 'Task 1', description: 'First task', status: 'complete' },
+          ],
+        },
+        {
+          id: 'm2',
+          name: 'Milestone 2',
+          description: 'Second milestone',
+          status: 'pending',
+          tasks: [
+            { id: 't2', name: 'Task 2', description: 'Second task', status: 'pending' },
+          ],
+        },
+      ],
+    }));
+
+    const result = await analyzeProjectProgress(tmpDir);
+
+    expect(result.isActuallyComplete).toBe(false);
+    expect(result.statusMismatch).toBe(true);
+    expect(result.completedMilestones).toBe(1);
+    expect(result.totalMilestones).toBe(2);
+  });
+});
+
+describe('verifyProjectCompletion', () => {
+  it('should return isComplete=true for zero milestones + explicitly complete', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'complete',
+      milestones: [],
+    }));
+
+    const result = await verifyProjectCompletion(tmpDir);
+
+    expect(result.isComplete).toBe(true);
+  });
+
+  it('should return isComplete=false when zero milestones but phase is execution', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'execution',
+      milestones: [],
+    }));
+
+    const result = await verifyProjectCompletion(tmpDir);
+
+    expect(result.isComplete).toBe(false);
+    expect(result.reason).toBeDefined();
+  });
+});
+
+// ─── Pipeline test helpers ────────────────────────────────
+
+/**
+ * Build a minimal valid pipeline state object that satisfies PipelineStateSchema.
+ *
+ * @param overrides - Fields to merge on top of the defaults
+ * @returns A plain object matching PipelineState
+ */
+function buildPipelineState(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    pipelinePhase: 'DONE',
+    artifacts: [],
+    recoveryCount: 0,
+    maxRecoveryIterations: 5,
+    gateResults: {},
+    gateChecks: {},
+    activeRoles: [],
+    constitutionHash: '',
+    ...overrides,
+  };
+}
+
+// ─── Pipeline terminal state handling ─────────────────────
+
+describe('pipeline terminal state handling', () => {
+  it('should treat pipeline DONE + 0 milestones as genuinely complete', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'execution',
+      milestones: [],
+      pipeline: buildPipelineState({ pipelinePhase: 'DONE' }),
+    }));
+
+    const result = await analyzeProjectProgress(tmpDir);
+
+    expect(result.isActuallyComplete).toBe(true);
+    expect(result.statusMismatch).toBe(false);
+    expect(result.pipelineTerminal).toBe(true);
+    expect(result.pipelinePhase).toBe('DONE');
+  });
+
+  it('should treat pipeline STUCK + 0 milestones as not complete but no mismatch', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'execution',
+      milestones: [],
+      pipeline: buildPipelineState({
+        pipelinePhase: 'STUCK',
+        failedPhase: 'QA_VALIDATION',
+        recoveryCount: 3,
+      }),
+    }));
+
+    const result = await analyzeProjectProgress(tmpDir);
+
+    expect(result.isActuallyComplete).toBe(false);
+    expect(result.statusMismatch).toBe(false);
+    expect(result.pipelineTerminal).toBe(true);
+    expect(result.progressSummary).toContain('STUCK');
+  });
+
+  it('should treat pipeline active phase + 0 milestones as not terminal', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'in-progress',
+      phase: 'execution',
+      milestones: [],
+      pipeline: buildPipelineState({ pipelinePhase: 'IMPLEMENTATION' }),
+    }));
+
+    const result = await analyzeProjectProgress(tmpDir);
+
+    expect(result.pipelineTerminal).toBe(false);
+    expect(result.isActuallyComplete).toBe(false);
+  });
+
+  it('should handle exact gateco reproducer (STUCK + complete status + 0 milestones)', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'execution',
+      milestones: [],
+      pipeline: buildPipelineState({
+        pipelinePhase: 'STUCK',
+        failedPhase: 'QA_VALIDATION',
+        recoveryCount: 5,
+      }),
+    }));
+
+    const result = await analyzeProjectProgress(tmpDir);
+
+    // Must NOT trigger status mismatch — pipeline terminal overrides
+    expect(result.statusMismatch).toBe(false);
+    expect(result.pipelineTerminal).toBe(true);
+    expect(result.isActuallyComplete).toBe(false);
+    // Summary should contain the stuck details
+    expect(result.progressSummary).toContain('STUCK');
+    expect(result.progressSummary).toContain('QA_VALIDATION');
+    expect(result.progressSummary).toContain('5');
+  });
+
+  it('should treat RECOVERY_LOOP the same as STUCK (interrupted mid-recovery)', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'execution',
+      milestones: [],
+      pipeline: buildPipelineState({
+        pipelinePhase: 'RECOVERY_LOOP',
+        failedPhase: 'QA_VALIDATION',
+        recoveryCount: 1,
+      }),
+    }));
+
+    const result = await analyzeProjectProgress(tmpDir);
+
+    expect(result.statusMismatch).toBe(false);
+    expect(result.pipelineTerminal).toBe(true);
+    expect(result.isActuallyComplete).toBe(false);
+    expect(result.progressSummary).toContain('STUCK');
+    expect(result.progressSummary).toContain('QA_VALIDATION');
+  });
+});
+
+describe('verifyProjectCompletion with pipeline', () => {
+  it('should return isComplete=true for pipeline DONE', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'execution',
+      milestones: [],
+      pipeline: buildPipelineState({ pipelinePhase: 'DONE' }),
+    }));
+
+    const result = await verifyProjectCompletion(tmpDir);
+
+    expect(result.isComplete).toBe(true);
+  });
+
+  it('should return isComplete=false for pipeline STUCK', async () => {
+    const tmpDir = await makeTmpDir();
+    await writeState(tmpDir, buildState({
+      status: 'complete',
+      phase: 'execution',
+      milestones: [],
+      pipeline: buildPipelineState({
+        pipelinePhase: 'STUCK',
+        failedPhase: 'QA_VALIDATION',
+        recoveryCount: 5,
+      }),
+    }));
+
+    const result = await verifyProjectCompletion(tmpDir);
+
+    expect(result.isComplete).toBe(false);
+  });
+});

package/tests/upgrade/handlers.test.ts

@@ -13,6 +13,7 @@ vi.mock('../../src/generators/website-context.js', () => ({
   buildWebsiteContext: vi.fn(),
   resolveBrandAssets: vi.fn(),
   validateWebsiteContext: vi.fn(),
+  extractDocPathsFromText: vi.fn().mockReturnValue([]),
 }));
 
 vi.mock('../../src/generators/workspace-root.js', () => ({
@@ -82,8 +83,8 @@ describe('buildUpgradeContentContext', () => {
     expect(context!.features).toHaveLength(1);
     expect(context!.features[0].title).toBe('Feature 1');
 
-    // Verify buildWebsiteContext was called with correct args
-    expect(mockBuildWebsiteContext).toHaveBeenCalledWith(tmpDir, 'TestProject');
+    // Verify buildWebsiteContext was called with state specification/idea fallback (null state = undefined)
+    expect(mockBuildWebsiteContext).toHaveBeenCalledWith(tmpDir, 'TestProject', undefined, []);
   });
 
   it('should apply brand context from state when available', async () => {
@@ -149,6 +150,36 @@ describe('buildUpgradeContentContext', () => {
     expect(warning).toBe('Unknown error building website context');
   });
 
+  it('should pass specification to buildWebsiteContext when state has it', async () => {
+    mockLoadState.mockResolvedValue({
+      name: 'TestProject',
+      language: 'all',
+      specification: 'Expanded specification text',
+      idea: 'Original idea text',
+    } as any);
+
+    await buildUpgradeContentContext(tmpDir, 'TestProject');
+
+    // specification takes priority over idea
+    expect(mockBuildWebsiteContext).toHaveBeenCalledWith(
+      tmpDir, 'TestProject', 'Expanded specification text', [],
+    );
+  });
+
+  it('should fall back to idea when state has no specification', async () => {
+    mockLoadState.mockResolvedValue({
+      name: 'TestProject',
+      language: 'all',
+      idea: 'Original idea text',
+    } as any);
+
+    await buildUpgradeContentContext(tmpDir, 'TestProject');
+
+    expect(mockBuildWebsiteContext).toHaveBeenCalledWith(
+      tmpDir, 'TestProject', 'Original idea text', [],
+    );
+  });
+
   it('should work when no state or strategy exists', async () => {
     // Default mocks already return null for state and strategy
     const { context, warning } = await buildUpgradeContentContext(tmpDir, 'TestProject');

package/tests/workflow/consensus.test.ts

@@ -42,7 +42,9 @@ describe('extractConcerns', () => {
     const result: ConsensusResult = {
       score: 80,
       analysis: 'Good plan overall',
+      strengths: [],
       concerns: ['Missing error handling', 'No tests defined'],
+      blockingIssues: [],
       recommendations: ['Add logging', 'Consider caching'],
       approved: false,
       rawResponse: '',
@@ -60,6 +62,10 @@ describe('extractConcerns', () => {
     const result: ConsensusResult = {
       score: 95,
       analysis: 'Perfect',
+      strengths: [],
+      concerns: [],
+      blockingIssues: [],
+      recommendations: [],
       approved: true,
       rawResponse: '',
     };

package/tsconfig.json

@@ -3,7 +3,7 @@
     "target": "ES2022",
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
+    "lib": ["ES2022", "ES2023"],
     "outDir": "./dist",
     "rootDir": "./src",
     "strict": true,