popeye-cli 1.10.0 → 2.0.0

package/tests/pipeline/packets/builders.test.ts

@@ -0,0 +1,347 @@
+/**
+ * Packet Builders tests — all 4 builders: auto-compute, version increment.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  buildPlanPacket,
+  buildConsensusPacket,
+  buildRCAPacket,
+  buildAuditReport,
+} from '../../../src/pipeline/packets/index.js';
+import type { ArtifactRef, ReviewerVote, AuditFinding } from '../../../src/pipeline/types.js';
+
+function makeRef(type: string = 'master_plan'): ArtifactRef {
+  return {
+    artifact_id: `ref-${type}`,
+    path: `docs/${type}.md`,
+    sha256: 'abc123',
+    version: 1,
+    type: type as ArtifactRef['type'],
+  };
+}
+
+function makeVote(
+  vote: 'APPROVE' | 'REJECT' | 'CONDITIONAL',
+  reviewerId: string = 'reviewer-1',
+): ReviewerVote {
+  return {
+    reviewer_id: reviewerId,
+    provider: 'openai',
+    model: 'gpt-4o',
+    temperature: 0.3,
+    prompt_hash: 'hash123',
+    vote,
+    confidence: 0.9,
+    blocking_issues: vote === 'REJECT' ? ['issue'] : [],
+    suggestions: [],
+    evidence_refs: [],
+  };
+}
+
+describe('PacketBuilders', () => {
+  describe('buildPlanPacket', () => {
+    it('should create a valid plan packet', () => {
+      const packet = buildPlanPacket({
+        phase: 'INTAKE',
+        submittedBy: 'DISPATCHER',
+        masterPlanRef: makeRef('master_plan'),
+        constitutionRef: makeRef('constitution'),
+        repoSnapshotRef: makeRef('repo_snapshot'),
+        proposedArtifacts: [makeRef('architecture')],
+        acceptanceCriteria: ['All endpoints documented'],
+        dependencies: [],
+        constraints: [],
+      });
+
+      expect(packet.metadata.packet_id).toBeDefined();
+      expect(packet.metadata.timestamp).toBeDefined();
+      expect(packet.metadata.phase).toBe('INTAKE');
+      expect(packet.metadata.submitted_by).toBe('DISPATCHER');
+      expect(packet.metadata.version).toBe(1);
+      expect(packet.references.master_plan.artifact_id).toBe('ref-master_plan');
+      expect(packet.proposed_artifacts).toHaveLength(1);
+      expect(packet.acceptance_criteria).toHaveLength(1);
+    });
+
+    it('should accept version override', () => {
+      const packet = buildPlanPacket({
+        phase: 'ARCHITECTURE',
+        submittedBy: 'ARCHITECT',
+        masterPlanRef: makeRef(),
+        constitutionRef: makeRef(),
+        repoSnapshotRef: makeRef('repo_snapshot'),
+        proposedArtifacts: [],
+        acceptanceCriteria: [],
+        dependencies: [],
+        constraints: [],
+        version: 3,
+      });
+
+      expect(packet.metadata.version).toBe(3);
+    });
+
+    it('should include open questions when provided', () => {
+      const packet = buildPlanPacket({
+        phase: 'INTAKE',
+        submittedBy: 'DISPATCHER',
+        masterPlanRef: makeRef(),
+        constitutionRef: makeRef(),
+        repoSnapshotRef: makeRef('repo_snapshot'),
+        proposedArtifacts: [],
+        acceptanceCriteria: [],
+        dependencies: [],
+        constraints: [],
+        openQuestions: ['Which database?', 'Auth strategy?'],
+      });
+
+      expect(packet.open_questions).toHaveLength(2);
+    });
+  });
+
+  describe('buildConsensusPacket', () => {
+    it('should auto-compute APPROVED when all approve', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('APPROVE', 'r1'), makeVote('APPROVE', 'r2')],
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+      });
+
+      expect(packet.consensus_result.approved).toBe(true);
+      expect(packet.consensus_result.score).toBe(1.0);
+      expect(packet.consensus_result.participating_reviewers).toBe(2);
+      expect(packet.final_status).toBe('APPROVED');
+    });
+
+    it('should auto-compute REJECTED when below threshold', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('APPROVE', 'r1'), makeVote('REJECT', 'r2')],
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+      });
+
+      expect(packet.consensus_result.approved).toBe(false);
+      expect(packet.consensus_result.score).toBe(0.5);
+      expect(packet.final_status).toBe('REJECTED');
+    });
+
+    it('should set ARBITRATED when arbitrator present', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('APPROVE', 'r1'), makeVote('REJECT', 'r2')],
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+        arbitratorResult: { decision: 'Approve with changes' },
+      });
+
+      expect(packet.final_status).toBe('ARBITRATED');
+      expect(packet.arbitrator_result?.decision).toBe('Approve with changes');
+    });
+
+    it('should reject when quorum not met', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('APPROVE', 'r1')],
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+      });
+
+      // Score is 1.0 but quorum=2, only 1 voter
+      expect(packet.consensus_result.approved).toBe(false);
+      expect(packet.final_status).toBe('REJECTED');
+    });
+
+    it('should handle zero votes', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [],
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+      });
+
+      expect(packet.consensus_result.score).toBe(0);
+      expect(packet.consensus_result.approved).toBe(false);
+    });
+
+    it('should include weighted_score in consensus result (v1.1)', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('APPROVE', 'r1'), makeVote('APPROVE', 'r2')],
+        rules: { threshold: 0.5, quorum: 1, min_reviewers: 1 },
+      });
+
+      expect(packet.consensus_result.weighted_score).toBeDefined();
+      expect(typeof packet.consensus_result.weighted_score).toBe('number');
+      expect(packet.consensus_result.weighted_score).toBe(1.0);
+    });
+
+    it('should have weighted_score < 1 for mixed votes (v1.1)', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('APPROVE', 'r1'), makeVote('REJECT', 'r2')],
+        rules: { threshold: 0.5, quorum: 1, min_reviewers: 1 },
+      });
+
+      // weighted_score should be 0 since REJECT vote has blocking_issues
+      expect(packet.consensus_result.weighted_score).toBe(0);
+    });
+
+    it('should link to plan packet', () => {
+      const planRef = makeRef();
+      const packet = buildConsensusPacket({
+        planPacketRef: planRef,
+        votes: [makeVote('APPROVE')],
+        rules: { threshold: 0.5, quorum: 1, min_reviewers: 1 },
+      });
+
+      expect(packet.metadata.plan_packet_id).toBe(planRef.artifact_id);
+      expect(packet.plan_packet_reference).toBe(planRef);
+    });
+  });
+
+  describe('buildRCAPacket', () => {
+    it('should create RCA with all fields', () => {
+      const rca = buildRCAPacket({
+        incidentSummary: 'Tests failing on CI',
+        symptoms: ['test timeout', 'flaky assertions'],
+        rootCause: 'Race condition in async setup',
+        responsibleLayer: 'test infrastructure',
+        originPhase: 'QA_VALIDATION',
+        governanceGap: 'No test isolation check',
+        correctiveActions: ['Add mutex to shared resource'],
+        prevention: 'Enable parallel test isolation',
+      });
+
+      expect(rca.rca_id).toBeDefined();
+      expect(rca.timestamp).toBeDefined();
+      expect(rca.incident_summary).toBe('Tests failing on CI');
+      expect(rca.symptoms).toHaveLength(2);
+      expect(rca.root_cause).toContain('Race condition');
+      expect(rca.origin_phase).toBe('QA_VALIDATION');
+      expect(rca.corrective_actions).toHaveLength(1);
+    });
+
+    it('should include rewind target when provided', () => {
+      const rca = buildRCAPacket({
+        incidentSummary: 'Architecture mismatch',
+        symptoms: ['contract violation'],
+        rootCause: 'Wrong API design',
+        responsibleLayer: 'architecture',
+        originPhase: 'IMPLEMENTATION',
+        governanceGap: 'No contract validation',
+        correctiveActions: ['Redesign API'],
+        prevention: 'Add contract tests',
+        rewindTo: 'ARCHITECTURE',
+        requiresConsensusOn: ['ARCHITECTURE'],
+      });
+
+      expect(rca.requires_phase_rewind_to).toBe('ARCHITECTURE');
+      expect(rca.requires_consensus_on).toEqual(['ARCHITECTURE']);
+    });
+
+    it('should leave rewind undefined when not needed', () => {
+      const rca = buildRCAPacket({
+        incidentSummary: 'Minor fix',
+        symptoms: ['typo'],
+        rootCause: 'Spelling error',
+        responsibleLayer: 'documentation',
+        originPhase: 'REVIEW',
+        governanceGap: 'None',
+        correctiveActions: ['Fix typo'],
+        prevention: 'Add spell check',
+      });
+
+      expect(rca.requires_phase_rewind_to).toBeUndefined();
+      expect(rca.requires_consensus_on).toBeUndefined();
+    });
+  });
+
+  describe('buildAuditReport', () => {
+    it('should PASS with no findings', () => {
+      const report = buildAuditReport({
+        repoSnapshot: makeRef('repo_snapshot'),
+        findings: [],
+      });
+
+      expect(report.audit_id).toBeDefined();
+      expect(report.overall_status).toBe('PASS');
+      expect(report.system_risk_score).toBe(0);
+      expect(report.recovery_required).toBe(false);
+      expect(report.findings).toHaveLength(0);
+    });
+
+    it('should FAIL with blocking findings', () => {
+      const finding: AuditFinding = {
+        id: 'f1',
+        severity: 'P0',
+        category: 'security',
+        description: 'SQL injection in login',
+        evidence: [],
+        blocking: true,
+        suggested_owner: 'BACKEND_PROGRAMMER',
+      };
+
+      const report = buildAuditReport({
+        repoSnapshot: makeRef('repo_snapshot'),
+        findings: [finding],
+      });
+
+      expect(report.overall_status).toBe('FAIL');
+      expect(report.system_risk_score).toBe(40); // P0 = 40
+      expect(report.recovery_required).toBe(true);
+    });
+
+    it('should PASS with non-blocking findings', () => {
+      const finding: AuditFinding = {
+        id: 'f1',
+        severity: 'P3',
+        category: 'config',
+        description: 'Missing optional config',
+        evidence: [],
+        blocking: false,
+        suggested_owner: 'BACKEND_PROGRAMMER',
+      };
+
+      const report = buildAuditReport({
+        repoSnapshot: makeRef('repo_snapshot'),
+        findings: [finding],
+      });
+
+      expect(report.overall_status).toBe('PASS');
+      expect(report.system_risk_score).toBe(2); // P3 = 2
+      expect(report.recovery_required).toBe(false);
+    });
+
+    it('should compute cumulative risk score', () => {
+      const findings: AuditFinding[] = [
+        { id: 'f1', severity: 'P0', category: 'security', description: 'A', evidence: [], blocking: true, suggested_owner: 'DEBUGGER' },
+        { id: 'f2', severity: 'P1', category: 'tests', description: 'B', evidence: [], blocking: true, suggested_owner: 'QA_TESTER' },
+        { id: 'f3', severity: 'P2', category: 'config', description: 'C', evidence: [], blocking: false, suggested_owner: 'BACKEND_PROGRAMMER' },
+      ];
+
+      const report = buildAuditReport({
+        repoSnapshot: makeRef('repo_snapshot'),
+        findings,
+      });
+
+      expect(report.system_risk_score).toBe(68); // 40 + 20 + 8
+      expect(report.recovery_required).toBe(true);
+    });
+
+    it('should cap risk score at 100', () => {
+      const findings: AuditFinding[] = Array.from({ length: 5 }, (_, i) => ({
+        id: `f${i}`,
+        severity: 'P0' as const,
+        category: 'security' as const,
+        description: `Finding ${i}`,
+        evidence: [],
+        blocking: true,
+        suggested_owner: 'DEBUGGER' as const,
+      }));
+
+      const report = buildAuditReport({
+        repoSnapshot: makeRef('repo_snapshot'),
+        findings,
+      });
+
+      expect(report.system_risk_score).toBe(100); // 5 * 40 = 200, capped at 100
+    });
+  });
+});

package/tests/pipeline/repo-snapshot.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Repo Snapshot tests — config detection, tree summary, diff.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { generateRepoSnapshot, diffSnapshots } from '../../src/pipeline/repo-snapshot.js';
+
+const TEST_DIR = join(process.cwd(), '.test-repo-snapshot');
+
+describe('RepoSnapshot', () => {
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+  });
+
+  describe('generateRepoSnapshot', () => {
+    it('should generate snapshot with basic fields', async () => {
+      writeFileSync(join(TEST_DIR, 'index.ts'), 'console.log("hello");\n');
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+
+      expect(snapshot.snapshot_id).toBeDefined();
+      expect(snapshot.snapshot_id.length).toBe(16);
+      expect(snapshot.timestamp).toBeDefined();
+      expect(snapshot.tree_summary).toBeDefined();
+      expect(Array.isArray(snapshot.config_files)).toBe(true);
+      expect(Array.isArray(snapshot.languages_detected)).toBe(true);
+      expect(typeof snapshot.total_files).toBe('number');
+      expect(typeof snapshot.total_lines).toBe('number');
+    });
+
+    it('should detect package.json config', async () => {
+      const pkg = { name: 'test', version: '1.0.0', scripts: { test: 'vitest' } };
+      writeFileSync(join(TEST_DIR, 'package.json'), JSON.stringify(pkg, null, 2));
+
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      const pkgConfig = snapshot.config_files.find((c) => c.type === 'package.json');
+
+      expect(pkgConfig).toBeDefined();
+      expect(pkgConfig!.content_hash).toBeDefined();
+      expect(pkgConfig!.key_fields).toHaveProperty('name', 'test');
+      expect(pkgConfig!.key_fields).toHaveProperty('scripts');
+    });
+
+    it('should detect languages from file extensions', async () => {
+      mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
+      writeFileSync(join(TEST_DIR, 'src', 'app.ts'), 'export const x = 1;\n');
+      writeFileSync(join(TEST_DIR, 'src', 'util.py'), 'x = 1\n');
+
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      expect(snapshot.languages_detected).toContain('typescript');
+      expect(snapshot.languages_detected).toContain('python');
+    });
+
+    it('should detect package manager from lock files', async () => {
+      writeFileSync(join(TEST_DIR, 'package.json'), '{}');
+      writeFileSync(join(TEST_DIR, 'pnpm-lock.yaml'), '');
+
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      expect(snapshot.package_manager).toBe('pnpm');
+    });
+
+    it('should detect test framework from scripts', async () => {
+      const pkg = { name: 'test', scripts: { test: 'vitest run' } };
+      writeFileSync(join(TEST_DIR, 'package.json'), JSON.stringify(pkg));
+
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      expect(snapshot.test_framework).toBe('vitest');
+    });
+
+    it('should detect build tool from scripts', async () => {
+      const pkg = { name: 'test', scripts: { build: 'tsc -b' } };
+      writeFileSync(join(TEST_DIR, 'package.json'), JSON.stringify(pkg));
+
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      expect(snapshot.build_tool).toBe('tsc');
+    });
+
+    it('should detect env files', async () => {
+      writeFileSync(join(TEST_DIR, '.env'), 'KEY=val');
+      writeFileSync(join(TEST_DIR, '.env.example'), 'KEY=');
+
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      expect(snapshot.env_files).toContain('.env');
+      expect(snapshot.env_files).toContain('.env.example');
+    });
+
+    it('should detect migrations presence', async () => {
+      mkdirSync(join(TEST_DIR, 'migrations'), { recursive: true });
+
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      expect(snapshot.migrations_present).toBe(true);
+    });
+
+    it('should count files and lines', async () => {
+      mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
+      writeFileSync(join(TEST_DIR, 'src', 'a.ts'), 'line1\nline2\nline3\n');
+      writeFileSync(join(TEST_DIR, 'src', 'b.ts'), 'one\ntwo\n');
+
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      expect(snapshot.total_files).toBe(2);
+      expect(snapshot.total_lines).toBeGreaterThan(0);
+    });
+
+    it('should exclude node_modules from scan', async () => {
+      mkdirSync(join(TEST_DIR, 'node_modules', 'dep'), { recursive: true });
+      writeFileSync(join(TEST_DIR, 'node_modules', 'dep', 'index.js'), 'x');
+      mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
+      writeFileSync(join(TEST_DIR, 'src', 'app.ts'), 'const x = 1;\n');
+
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      expect(snapshot.total_files).toBe(1); // Only src/app.ts
+    });
+  });
+
+  describe('diffSnapshots', () => {
+    it('should detect no changes for identical snapshots', async () => {
+      writeFileSync(join(TEST_DIR, 'index.ts'), 'x');
+      const snapshot = await generateRepoSnapshot(TEST_DIR);
+      const diff = diffSnapshots(snapshot, snapshot);
+
+      expect(diff.has_changes).toBe(false);
+      expect(diff.files_delta).toBe(0);
+      expect(diff.lines_delta).toBe(0);
+      expect(diff.added_configs).toHaveLength(0);
+      expect(diff.removed_configs).toHaveLength(0);
+      expect(diff.changed_configs).toHaveLength(0);
+    });
+
+    it('should detect added config files', () => {
+      const before = {
+        snapshot_id: 'a', timestamp: '', tree_summary: '',
+        config_files: [], languages_detected: [],
+        scripts: {}, env_files: [],
+        migrations_present: false, ports_entrypoints: [],
+        total_files: 10, total_lines: 100,
+      };
+      const after = {
+        ...before,
+        snapshot_id: 'b',
+        config_files: [{ path: 'package.json', type: 'package.json', content_hash: 'abc', key_fields: {} }],
+      };
+
+      const diff = diffSnapshots(before, after);
+      expect(diff.added_configs).toContain('package.json');
+      expect(diff.has_changes).toBe(true);
+    });
+
+    it('should detect changed config files', () => {
+      const before = {
+        snapshot_id: 'a', timestamp: '', tree_summary: '',
+        config_files: [{ path: 'package.json', type: 'package.json', content_hash: 'old', key_fields: {} }],
+        languages_detected: [], scripts: {},
+        env_files: [], migrations_present: false,
+        ports_entrypoints: [], total_files: 10, total_lines: 100,
+      };
+      const after = {
+        ...before,
+        snapshot_id: 'b',
+        config_files: [{ path: 'package.json', type: 'package.json', content_hash: 'new', key_fields: {} }],
+      };
+
+      const diff = diffSnapshots(before, after);
+      expect(diff.changed_configs).toContain('package.json');
+      expect(diff.has_changes).toBe(true);
+    });
+
+    it('should detect file count delta', () => {
+      const before = {
+        snapshot_id: 'a', timestamp: '', tree_summary: '',
+        config_files: [], languages_detected: [],
+        scripts: {}, env_files: [],
+        migrations_present: false, ports_entrypoints: [],
+        total_files: 10, total_lines: 100,
+      };
+      const after = { ...before, snapshot_id: 'b', total_files: 15, total_lines: 200 };
+
+      const diff = diffSnapshots(before, after);
+      expect(diff.files_delta).toBe(5);
+      expect(diff.lines_delta).toBe(100);
+      expect(diff.has_changes).toBe(true);
+    });
+  });
+});