popeye-cli 1.10.0 → 2.1.0

package/tests/pipeline/constitution.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Constitution tests — artifact creation, hash computation, verification.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import {
+  computeConstitutionHash,
+  createConstitutionArtifact,
+  verifyConstitution,
+} from '../../src/pipeline/constitution.js';
+import { createArtifactManager } from '../../src/pipeline/artifact-manager.js';
+import { createDefaultPipelineState } from '../../src/pipeline/types.js';
+
+const TEST_DIR = join(process.cwd(), 'tmp-constitution-test');
+
+beforeEach(() => {
+  mkdirSync(join(TEST_DIR, 'skills'), { recursive: true });
+  mkdirSync(join(TEST_DIR, 'docs'), { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+});
+
+describe('computeConstitutionHash', () => {
+  it('should compute SHA-256 of constitution file', () => {
+    const content = '# POPEYE CONSTITUTION\nRule 1: Be deterministic';
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), content);
+
+    const hash = computeConstitutionHash(TEST_DIR);
+    const expected = createHash('sha256').update(content, 'utf-8').digest('hex');
+    expect(hash).toBe(expected);
+  });
+
+  it('should return empty string when file not found', () => {
+    const hash = computeConstitutionHash(TEST_DIR + '-nonexistent');
+    expect(hash).toBe('');
+  });
+
+  it('should produce different hashes for different content', () => {
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Version 1');
+    const hash1 = computeConstitutionHash(TEST_DIR);
+
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Version 2');
+    const hash2 = computeConstitutionHash(TEST_DIR);
+
+    expect(hash1).not.toBe(hash2);
+  });
+});
+
+describe('createConstitutionArtifact', () => {
+  it('should create an artifact from constitution file', () => {
+    writeFileSync(
+      join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'),
+      '# Constitution\nRule 1',
+    );
+    const am = createArtifactManager(TEST_DIR);
+    const entry = createConstitutionArtifact(TEST_DIR, am);
+
+    expect(entry).not.toBeNull();
+    expect(entry!.type).toBe('constitution');
+    expect(entry!.phase).toBe('INTAKE');
+  });
+
+  it('should return null when constitution file missing', () => {
+    const am = createArtifactManager(TEST_DIR);
+    const entry = createConstitutionArtifact(TEST_DIR + '-nope', am);
+    expect(entry).toBeNull();
+  });
+});
+
+describe('verifyConstitution', () => {
+  it('should pass when hash matches', () => {
+    const content = '# Constitution\nRule 1: Immutable';
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), content);
+
+    const pipeline = createDefaultPipelineState();
+    pipeline.constitutionHash = computeConstitutionHash(TEST_DIR);
+
+    const result = verifyConstitution(pipeline, TEST_DIR);
+    expect(result.valid).toBe(true);
+  });
+
+  it('should fail when constitution has been modified', () => {
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Original');
+    const pipeline = createDefaultPipelineState();
+    pipeline.constitutionHash = computeConstitutionHash(TEST_DIR);
+
+    // Modify the file
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Modified!');
+
+    const result = verifyConstitution(pipeline, TEST_DIR);
+    expect(result.valid).toBe(false);
+    expect(result.reason).toContain('modified');
+  });
+
+  it('should skip verification when no hash stored (pre-INTAKE)', () => {
+    const pipeline = createDefaultPipelineState();
+    // constitutionHash is '' by default
+
+    const result = verifyConstitution(pipeline, TEST_DIR);
+    expect(result.valid).toBe(true);
+  });
+
+  it('should fail when constitution file deleted after hash stored', () => {
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Content');
+    const pipeline = createDefaultPipelineState();
+    pipeline.constitutionHash = computeConstitutionHash(TEST_DIR);
+
+    // Delete the file
+    rmSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'));
+
+    const result = verifyConstitution(pipeline, TEST_DIR);
+    expect(result.valid).toBe(false);
+    expect(result.reason).toContain('not found');
+  });
+});

package/tests/pipeline/gate-engine.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Gate Engine tests — all transition rules, gate definitions, edge cases.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createGateEngine } from '../../src/pipeline/gate-engine.js';
+import { createDefaultPipelineState } from '../../src/pipeline/types.js';
+import type { PipelinePhase, PipelineState, ArtifactEntry } from '../../src/pipeline/types.js';
+
+function makeArtifact(type: string, phase: string): ArtifactEntry {
+  return {
+    id: `test-${type}-${phase}`,
+    type: type as ArtifactEntry['type'],
+    phase: phase as PipelinePhase,
+    version: 1,
+    path: `docs/${type}.md`,
+    sha256: 'abc123',
+    timestamp: new Date().toISOString(),
+    immutable: true,
+    content_type: 'markdown',
+    group_id: `group-${type}`,
+  };
+}
+
+describe('GateEngine', () => {
+  const engine = createGateEngine();
+
+  describe('getGateDefinition', () => {
+    it('should return definitions for all 14 phases', () => {
+      const phases: PipelinePhase[] = [
+        'INTAKE', 'CONSENSUS_MASTER_PLAN', 'ARCHITECTURE',
+        'CONSENSUS_ARCHITECTURE', 'ROLE_PLANNING', 'CONSENSUS_ROLE_PLANS',
+        'IMPLEMENTATION', 'QA_VALIDATION', 'REVIEW', 'AUDIT',
+        'PRODUCTION_GATE', 'RECOVERY_LOOP', 'DONE', 'STUCK',
+      ];
+
+      for (const phase of phases) {
+        const def = engine.getGateDefinition(phase);
+        expect(def).toBeDefined();
+        expect(def.phase).toBe(phase);
+        expect(def.failTransition).toBeDefined();
+      }
+    });
+
+    it('should require master_plan and repo_snapshot for INTAKE', () => {
+      const def = engine.getGateDefinition('INTAKE');
+      expect(def.requiredArtifacts).toContain('master_plan');
+      expect(def.requiredArtifacts).toContain('repo_snapshot');
+      expect(def.allowedTransitions).toEqual(['CONSENSUS_MASTER_PLAN']);
+    });
+
+    it('should require consensus threshold for consensus phases', () => {
+      const consensusPhases: PipelinePhase[] = [
+        'CONSENSUS_MASTER_PLAN', 'CONSENSUS_ARCHITECTURE', 'CONSENSUS_ROLE_PLANS',
+      ];
+      for (const phase of consensusPhases) {
+        const def = engine.getGateDefinition(phase);
+        expect(def.consensusThreshold).toBe(0.95);
+        expect(def.minReviewers).toBe(2);
+      }
+    });
+
+    it('should require build/test/lint/typecheck for PRODUCTION_GATE', () => {
+      const def = engine.getGateDefinition('PRODUCTION_GATE');
+      expect(def.requiredChecks).toContain('build');
+      expect(def.requiredChecks).toContain('test');
+      expect(def.requiredChecks).toContain('lint');
+      expect(def.requiredChecks).toContain('typecheck');
+    });
+
+    it('should have terminal DONE and STUCK phases', () => {
+      expect(engine.getGateDefinition('DONE').allowedTransitions).toEqual([]);
+      expect(engine.getGateDefinition('STUCK').allowedTransitions).toEqual([]);
+    });
+  });
+
+  describe('evaluateGate', () => {
+    it('should fail when required artifacts are missing', () => {
+      const pipeline = createDefaultPipelineState();
+      const result = engine.evaluateGate('INTAKE', pipeline);
+
+      expect(result.pass).toBe(false);
+      expect(result.missingArtifacts).toContain('master_plan');
+      expect(result.missingArtifacts).toContain('repo_snapshot');
+      expect(result.blockers.length).toBeGreaterThan(0);
+    });
+
+    it('should pass when all required artifacts exist', () => {
+      const pipeline = createDefaultPipelineState();
+      pipeline.artifacts.push(makeArtifact('master_plan', 'INTAKE'));
+      pipeline.artifacts.push(makeArtifact('repo_snapshot', 'INTAKE'));
+      pipeline.artifacts.push(makeArtifact('constitution', 'INTAKE'));
+
+      const result = engine.evaluateGate('INTAKE', pipeline);
+      expect(result.pass).toBe(true);
+      expect(result.blockers).toHaveLength(0);
+    });
+
+    it('should check gate check results for QA_VALIDATION', () => {
+      const pipeline = createDefaultPipelineState();
+      pipeline.artifacts.push(makeArtifact('qa_validation', 'QA_VALIDATION'));
+      // No test check result
+      const result = engine.evaluateGate('QA_VALIDATION', pipeline);
+      expect(result.pass).toBe(false);
+      expect(result.failedChecks).toContain('test');
+    });
+
+    it('should pass QA when test check passes', () => {
+      const pipeline = createDefaultPipelineState();
+      pipeline.artifacts.push(makeArtifact('qa_validation', 'QA_VALIDATION'));
+      pipeline.gateChecks['QA_VALIDATION'] = [{
+        check_type: 'test',
+        status: 'pass',
+        command: 'npm test',
+        exit_code: 0,
+        duration_ms: 1000,
+        timestamp: new Date().toISOString(),
+      }];
+
+      const result = engine.evaluateGate('QA_VALIDATION', pipeline);
+      expect(result.pass).toBe(true);
+    });
+
+    it('should fail when check result status is fail', () => {
+      const pipeline = createDefaultPipelineState();
+      pipeline.artifacts.push(makeArtifact('qa_validation', 'QA_VALIDATION'));
+      pipeline.gateChecks['QA_VALIDATION'] = [{
+        check_type: 'test',
+        status: 'fail',
+        command: 'npm test',
+        exit_code: 1,
+        duration_ms: 500,
+        timestamp: new Date().toISOString(),
+      }];
+
+      const result = engine.evaluateGate('QA_VALIDATION', pipeline);
+      expect(result.pass).toBe(false);
+      expect(result.failedChecks).toContain('test');
+    });
+  });
+
+  describe('getNextPhase', () => {
+    it('should follow the linear sequence', () => {
+      const passResult = {
+        phase: 'INTAKE' as PipelinePhase,
+        pass: true,
+        blockers: [],
+        missingArtifacts: [],
+        failedChecks: [],
+        timestamp: new Date().toISOString(),
+      };
+
+      expect(engine.getNextPhase('INTAKE', passResult)).toBe('CONSENSUS_MASTER_PLAN');
+      expect(engine.getNextPhase('CONSENSUS_MASTER_PLAN', passResult)).toBe('ARCHITECTURE');
+      expect(engine.getNextPhase('ARCHITECTURE', passResult)).toBe('CONSENSUS_ARCHITECTURE');
+      expect(engine.getNextPhase('PRODUCTION_GATE', passResult)).toBe('DONE');
+    });
+  });
+
+  describe('canTransition', () => {
+    it('should allow valid transitions when gate passes', () => {
+      const pipeline = createDefaultPipelineState();
+      pipeline.artifacts.push(makeArtifact('master_plan', 'INTAKE'));
+      pipeline.artifacts.push(makeArtifact('repo_snapshot', 'INTAKE'));
+      pipeline.artifacts.push(makeArtifact('constitution', 'INTAKE'));
+
+      const result = engine.canTransition('INTAKE', 'CONSENSUS_MASTER_PLAN', pipeline);
+      expect(result.allowed).toBe(true);
+    });
+
+    it('should reject invalid transitions', () => {
+      const pipeline = createDefaultPipelineState();
+      const result = engine.canTransition('INTAKE', 'PRODUCTION_GATE', pipeline);
+      expect(result.allowed).toBe(false);
+      expect(result.blockers.some((b) => b.includes('not allowed'))).toBe(true);
+    });
+  });
+
+  describe('getPhaseSequence', () => {
+    it('should return ordered phases ending with DONE', () => {
+      const seq = engine.getPhaseSequence();
+      expect(seq[0]).toBe('INTAKE');
+      expect(seq[seq.length - 1]).toBe('DONE');
+      expect(seq.length).toBe(12); // 12 phases in linear sequence
+    });
+  });
+
+  describe('getPhaseIndex', () => {
+    it('should return correct indices', () => {
+      expect(engine.getPhaseIndex('INTAKE')).toBe(0);
+      expect(engine.getPhaseIndex('DONE')).toBe(11);
+      expect(engine.getPhaseIndex('RECOVERY_LOOP')).toBe(-1); // Not in linear sequence
+    });
+  });
+});

package/tests/pipeline/migration.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Migration tests — phase mapping, defaults, role derivation.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  toPipelinePhase,
+  toLegacyPhase,
+  migrateToPipelineState,
+  needsPipelineMigration,
+} from '../../src/pipeline/migration.js';
+import type { ProjectState } from '../../src/types/workflow.js';
+
+function makeMinimalState(overrides: Partial<ProjectState> = {}): ProjectState {
+  return {
+    idea: 'test idea',
+    language: 'typescript',
+    phase: 'plan',
+    projectDir: '/tmp/test',
+    timestamp: new Date().toISOString(),
+    ...overrides,
+  } as ProjectState;
+}
+
+describe('Migration', () => {
+  describe('toPipelinePhase', () => {
+    it('should map plan to INTAKE', () => {
+      expect(toPipelinePhase('plan')).toBe('INTAKE');
+    });
+
+    it('should map execution to IMPLEMENTATION', () => {
+      expect(toPipelinePhase('execution')).toBe('IMPLEMENTATION');
+    });
+
+    it('should map complete to DONE', () => {
+      expect(toPipelinePhase('complete')).toBe('DONE');
+    });
+
+    it('should default to INTAKE for unknown phases', () => {
+      expect(toPipelinePhase('unknown' as any)).toBe('INTAKE');
+    });
+  });
+
+  describe('toLegacyPhase', () => {
+    it('should map planning phases to plan', () => {
+      expect(toLegacyPhase('INTAKE')).toBe('plan');
+      expect(toLegacyPhase('CONSENSUS_MASTER_PLAN')).toBe('plan');
+      expect(toLegacyPhase('ARCHITECTURE')).toBe('plan');
+      expect(toLegacyPhase('CONSENSUS_ARCHITECTURE')).toBe('plan');
+      expect(toLegacyPhase('ROLE_PLANNING')).toBe('plan');
+      expect(toLegacyPhase('CONSENSUS_ROLE_PLANS')).toBe('plan');
+    });
+
+    it('should map execution phases to execution', () => {
+      expect(toLegacyPhase('IMPLEMENTATION')).toBe('execution');
+      expect(toLegacyPhase('QA_VALIDATION')).toBe('execution');
+      expect(toLegacyPhase('REVIEW')).toBe('execution');
+      expect(toLegacyPhase('AUDIT')).toBe('execution');
+      expect(toLegacyPhase('PRODUCTION_GATE')).toBe('execution');
+      expect(toLegacyPhase('RECOVERY_LOOP')).toBe('execution');
+    });
+
+    it('should map terminal phases to complete', () => {
+      expect(toLegacyPhase('DONE')).toBe('complete');
+      expect(toLegacyPhase('STUCK')).toBe('complete');
+    });
+  });
+
+  describe('migrateToPipelineState', () => {
+    it('should create default pipeline state with correct phase', () => {
+      const state = makeMinimalState({ phase: 'plan' });
+      const pipeline = migrateToPipelineState(state);
+
+      expect(pipeline.pipelinePhase).toBe('INTAKE');
+      expect(pipeline.artifacts).toEqual([]);
+      expect(pipeline.recoveryCount).toBe(0);
+      expect(pipeline.maxRecoveryIterations).toBe(5);
+    });
+
+    it('should map execution phase', () => {
+      const state = makeMinimalState({ phase: 'execution' });
+      const pipeline = migrateToPipelineState(state);
+      expect(pipeline.pipelinePhase).toBe('IMPLEMENTATION');
+    });
+
+    it('should map complete phase', () => {
+      const state = makeMinimalState({ phase: 'complete' });
+      const pipeline = migrateToPipelineState(state);
+      expect(pipeline.pipelinePhase).toBe('DONE');
+    });
+
+    it('should derive roles for typescript project', () => {
+      const state = makeMinimalState({ language: 'typescript' });
+      const pipeline = migrateToPipelineState(state);
+
+      expect(pipeline.activeRoles).toContain('DISPATCHER');
+      expect(pipeline.activeRoles).toContain('ARCHITECT');
+      expect(pipeline.activeRoles).toContain('BACKEND_PROGRAMMER');
+      expect(pipeline.activeRoles).not.toContain('FRONTEND_PROGRAMMER');
+    });
+
+    it('should derive roles for fullstack project', () => {
+      const state = makeMinimalState({ language: 'fullstack' });
+      const pipeline = migrateToPipelineState(state);
+
+      expect(pipeline.activeRoles).toContain('DB_EXPERT');
+      expect(pipeline.activeRoles).toContain('BACKEND_PROGRAMMER');
+      expect(pipeline.activeRoles).toContain('FRONTEND_PROGRAMMER');
+      expect(pipeline.activeRoles).toContain('WEBSITE_PROGRAMMER');
+      expect(pipeline.activeRoles).toContain('UI_UX_SPECIALIST');
+    });
+
+    it('should derive roles for website project', () => {
+      const state = makeMinimalState({ language: 'website' });
+      const pipeline = migrateToPipelineState(state);
+
+      expect(pipeline.activeRoles).toContain('WEBSITE_PROGRAMMER');
+      expect(pipeline.activeRoles).toContain('MARKETING_EXPERT');
+      expect(pipeline.activeRoles).toContain('SOCIAL_EXPERT');
+      expect(pipeline.activeRoles).not.toContain('DB_EXPERT');
+    });
+  });
+
+  describe('needsPipelineMigration', () => {
+    it('should return true when pipeline is missing', () => {
+      expect(needsPipelineMigration({ phase: 'plan' })).toBe(true);
+    });
+
+    it('should return false when pipeline exists', () => {
+      expect(needsPipelineMigration({ pipeline: {} })).toBe(false);
+    });
+  });
+});