popeye-cli 2.2.0 → 2.7.0

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

@@ -100,13 +100,17 @@ describe('PacketBuilders', () => {
   });
 
   describe('buildConsensusPacket', () => {
-    it('should auto-compute APPROVED when all approve', () => {
+    it('should auto-compute APPROVED when all approve with high confidence', () => {
       const packet = buildConsensusPacket({
         planPacketRef: makeRef(),
-        votes: [makeVote('APPROVE', 'r1'), makeVote('APPROVE', 'r2')],
+        votes: [
+          { ...makeVote('APPROVE', 'r1'), confidence: 0.96 },
+          { ...makeVote('APPROVE', 'r2'), confidence: 0.97 },
+        ],
         rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
       });
 
+      // Option B: (1.0*0.96 + 1.0*0.97)/2 = 0.965 >= 0.95
       expect(packet.consensus_result.approved).toBe(true);
       expect(packet.consensus_result.score).toBe(1.0);
       expect(packet.consensus_result.participating_reviewers).toBe(2);
@@ -169,18 +173,37 @@ describe('PacketBuilders', () => {
 
       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);
+      // Option B: (1.0*0.9 + 1.0*0.9)/2 = 0.9
+      expect(packet.consensus_result.weighted_score).toBeCloseTo(0.9, 3);
     });
 
-    it('should have weighted_score < 1 for mixed votes (v1.1)', () => {
+    it('should have weighted_score < 1 for mixed votes (v1.1, v2.4.2 honest scoring)', () => {
       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);
+      // v2.4.2: honest score — REJECT has blocking_issues but score is not force-zeroed
+      // Option B: (1.0*0.9 + 0.0*0.9) / 2 = 0.45
+      expect(packet.consensus_result.weighted_score).toBeCloseTo(0.45, 3);
+      expect(packet.consensus_result.has_true_blockers).toBe(true);
+    });
+
+    it('consensus_result includes has_true_blockers field (v2.4.2)', () => {
+      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.has_true_blockers).toBe(false);
+
+      const packetWithBlockers = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('APPROVE', 'r1'), makeVote('REJECT', 'r2')],
+        rules: { threshold: 0.5, quorum: 1, min_reviewers: 1 },
+      });
+      expect(packetWithBlockers.consensus_result.has_true_blockers).toBe(true);
     });
 
     it('should link to plan packet', () => {

package/tests/pipeline/phases/role-planning.strategy.test.ts

@@ -0,0 +1,204 @@
+/**
+ * Role planning strategy injection tests.
+ * Verifies that WEBSITE_PROGRAMMER, MARKETING_EXPERT, SOCIAL_EXPERT
+ * get strategy context in their planning prompts, and other roles do not.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { runRolePlanning } from '../../../src/pipeline/phases/role-planning.js';
+import type { PhaseContext } from '../../../src/pipeline/phases/phase-context.js';
+import type { PipelineRole, ArtifactEntry } from '../../../src/pipeline/types.js';
+import { createDefaultPipelineState } from '../../../src/pipeline/types.js';
+import { SkillUsageRegistry } from '../../../src/pipeline/skills/usage-registry.js';
+
+const TEST_DIR = join(process.cwd(), 'tmp-role-planning-strategy-test');
+
+function makeValidStrategy() {
+  return {
+    icp: { primaryPersona: 'developers', painPoints: ['slow builds'], goals: ['fast CI'], objections: ['cost'] },
+    positioning: { category: 'DevTools', differentiators: ['speed'], valueProposition: 'Build faster', proofPoints: ['10x'] },
+    messaging: { headline: 'Build Faster', subheadline: 'CI that works', elevatorPitch: 'Fast CI', longDescription: 'A fast CI platform' },
+    seoStrategy: { primaryKeywords: ['CI'], secondaryKeywords: ['build'], longTailKeywords: ['fast CI'], titleTemplates: {}, metaDescriptions: {} },
+    siteArchitecture: {
+      pages: [{ path: '/', title: 'Home', purpose: 'Landing', pageType: 'landing', sections: ['hero'], seoKeywords: ['CI'], conversionGoal: 'signup' }],
+      navigation: [{ label: 'Home', href: '/' }],
+      footerSections: [{ title: 'Links', links: [{ label: 'Home', href: '/' }] }],
+    },
+    conversionStrategy: {
+      primaryCta: { text: 'Get Started', href: '/signup' },
+      secondaryCta: { text: 'Learn More', href: '/docs' },
+      trustSignals: ['SOC2'],
+      socialProof: ['1000+ teams'],
+      leadCapture: 'webhook',
+    },
+    competitiveContext: { category: 'CI/CD', competitors: ['CircleCI'], differentiators: ['speed'] },
+  };
+}
+
+// Capture all prompts passed to executePrompt
+let capturedPrompts: string[] = [];
+
+vi.mock('../../../src/adapters/claude.js', () => ({
+  executePrompt: vi.fn(async (prompt: string) => {
+    capturedPrompts.push(prompt);
+    return { response: 'Mocked plan output' };
+  }),
+}));
+
+function makeMockSkill(role: string) {
+  return {
+    role,
+    version: '1.0',
+    systemPrompt: `You are ${role}. Follow best practices.`,
+    required_outputs: [],
+    constraints: ['Stay in scope'],
+    tools: [],
+  };
+}
+
+function makeArtifact(type: string, path: string): ArtifactEntry {
+  return {
+    id: `art-${type}`,
+    type: type as any,
+    phase: 'ARCHITECTURE',
+    version: 1,
+    path,
+    sha256: 'abc',
+    timestamp: new Date().toISOString(),
+    immutable: true,
+    content_type: 'markdown',
+    group_id: 'g1',
+  };
+}
+
+function makePhaseContext(activeRoles: PipelineRole[]): PhaseContext {
+  const pipeline = createDefaultPipelineState();
+  pipeline.activeRoles = activeRoles;
+
+  // Add architecture and master plan artifacts
+  const archPath = 'docs/architecture.md';
+  const planPath = 'docs/master-plan.md';
+  pipeline.artifacts.push(makeArtifact('architecture', archPath));
+  pipeline.artifacts.push(makeArtifact('master_plan', planPath));
+
+  // Write artifact files
+  writeFileSync(join(TEST_DIR, archPath), '# Architecture\nMicroservices');
+  writeFileSync(join(TEST_DIR, planPath), '# Master Plan\nBuild a CI tool');
+
+  const events: any[] = [];
+  const registry = new SkillUsageRegistry(events);
+
+  let artifactCounter = 0;
+
+  return {
+    pipeline,
+    projectDir: TEST_DIR,
+    state: {} as any,
+    skillLoader: {
+      loadSkill: (role: string) => makeMockSkill(role),
+      loadSkillWithMeta: (role: string) => ({
+        definition: makeMockSkill(role),
+        meta: { source: 'defaults' as const, version: '1.0' },
+      }),
+      listSkills: () => [],
+    } as any,
+    artifactManager: {
+      createAndStoreText: (_type: string, content: string, _phase: string) => {
+        artifactCounter++;
+        return makeArtifact('role_plan', `docs/role-plans/plan-${artifactCounter}.md`);
+      },
+    } as any,
+    gateEngine: {} as any,
+    consensusRunner: {} as any,
+    skillUsageRegistry: registry,
+  };
+}
+
+beforeEach(() => {
+  capturedPrompts = [];
+  mkdirSync(join(TEST_DIR, 'docs', 'role-plans'), { recursive: true });
+  mkdirSync(join(TEST_DIR, '.popeye'), { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+  vi.clearAllMocks();
+});
+
+describe('role-planning strategy injection', () => {
+  it('WEBSITE_PROGRAMMER planning prompt includes strategy when file exists', async () => {
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      JSON.stringify(makeValidStrategy()),
+    );
+
+    const ctx = makePhaseContext(['WEBSITE_PROGRAMMER']);
+    await runRolePlanning(ctx);
+
+    expect(capturedPrompts).toHaveLength(1);
+    expect(capturedPrompts[0]).toContain('Website Marketing Strategy');
+    expect(capturedPrompts[0]).toContain('Target Customer');
+    expect(capturedPrompts[0]).toContain('developers');
+  });
+
+  it('MARKETING_EXPERT planning prompt includes strategy', async () => {
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      JSON.stringify(makeValidStrategy()),
+    );
+
+    const ctx = makePhaseContext(['MARKETING_EXPERT']);
+    await runRolePlanning(ctx);
+
+    expect(capturedPrompts).toHaveLength(1);
+    expect(capturedPrompts[0]).toContain('Website Marketing Strategy');
+  });
+
+  it('DB_EXPERT planning prompt does NOT include strategy', async () => {
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      JSON.stringify(makeValidStrategy()),
+    );
+
+    const ctx = makePhaseContext(['DB_EXPERT']);
+    await runRolePlanning(ctx);
+
+    expect(capturedPrompts).toHaveLength(1);
+    expect(capturedPrompts[0]).not.toContain('Website Marketing Strategy');
+    expect(capturedPrompts[0]).not.toContain('Target Customer');
+  });
+
+  it('missing strategy file does not crash planning', async () => {
+    // No strategy file written
+    const ctx = makePhaseContext(['WEBSITE_PROGRAMMER', 'BACKEND_PROGRAMMER']);
+    const result = await runRolePlanning(ctx);
+
+    expect(result.success).toBe(true);
+    expect(capturedPrompts).toHaveLength(2);
+    // Neither prompt should contain strategy
+    for (const prompt of capturedPrompts) {
+      expect(prompt).not.toContain('Website Marketing Strategy');
+    }
+  });
+
+  it('records strategy_context usage for strategy roles only', async () => {
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      JSON.stringify(makeValidStrategy()),
+    );
+
+    const ctx = makePhaseContext(['WEBSITE_PROGRAMMER', 'BACKEND_PROGRAMMER']);
+    await runRolePlanning(ctx);
+
+    const events = ctx.skillUsageRegistry.getEvents();
+    const strategyEvents = events.filter((e) => e.used_as === 'strategy_context');
+    expect(strategyEvents).toHaveLength(1);
+    expect(strategyEvents[0].role).toBe('WEBSITE_PROGRAMMER');
+    expect(strategyEvents[0].phase).toBe('ROLE_PLANNING');
+    expect(strategyEvents[0].skill_source).toBe('disk');
+  });
+});

package/tests/pipeline/pipeline-persistence.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Pipeline Persistence tests — verify PipelineState round-trips through
+ * ProjectStateSchema, survives saveState/loadState, and merges via updateState.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { ProjectStateSchema } from '../../src/types/workflow.js';
+import type { ProjectState } from '../../src/types/workflow.js';
+import { PipelineStateSchema, createDefaultPipelineState } from '../../src/pipeline/types.js';
+import type { PipelineState } from '../../src/pipeline/types.js';
+import { saveState, loadState } from '../../src/state/persistence.js';
+import { updateState } from '../../src/state/index.js';
+
+/** Minimal valid ProjectState for testing (no pipeline field) */
+function makeBaseState(overrides: Partial<ProjectState> = {}): ProjectState {
+  const now = new Date().toISOString();
+  return {
+    id: 'test-id',
+    name: 'test-project',
+    idea: 'A test idea',
+    language: 'python',
+    openaiModel: 'gpt-4o',
+    phase: 'plan',
+    status: 'pending',
+    milestones: [],
+    currentMilestone: null,
+    currentTask: null,
+    consensusHistory: [],
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+}
+
+/** Build a populated PipelineState for round-trip testing */
+function makePopulatedPipeline(): PipelineState {
+  const base = createDefaultPipelineState();
+  return {
+    ...base,
+    pipelinePhase: 'CONSENSUS_ROLE_PLANS',
+    recoveryCount: 2,
+    artifacts: [
+      {
+        id: 'art-1',
+        type: 'master_plan',
+        phase: 'CONSENSUS_MASTER_PLAN',
+        version: 1,
+        path: 'docs/plans/master-plan.md',
+        sha256: 'abc123def456',
+        timestamp: new Date().toISOString(),
+        immutable: true,
+        content_type: 'markdown',
+        group_id: 'group-master',
+      },
+    ],
+    gateResults: {
+      INTAKE: {
+        phase: 'INTAKE',
+        pass: true,
+        blockers: [],
+        missingArtifacts: [],
+        failedChecks: [],
+        timestamp: new Date().toISOString(),
+      },
+    },
+    gateChecks: {
+      INTAKE: [
+        {
+          check_type: 'build',
+          status: 'pass',
+          command: 'npm run build',
+          exit_code: 0,
+          duration_ms: 1200,
+          timestamp: new Date().toISOString(),
+        },
+      ],
+    },
+    activeRoles: ['DISPATCHER', 'ARCHITECT'],
+    failedPhase: 'ARCHITECTURE',
+    skillUsageEvents: [
+      {
+        role: 'ARCHITECT',
+        phase: 'ARCHITECTURE',
+        used_as: 'system_prompt',
+        skill_source: 'defaults',
+        timestamp: new Date().toISOString(),
+      },
+    ],
+  };
+}
+
+describe('Pipeline Persistence', () => {
+  // ─── Test 1: Round-trip through ProjectStateSchema ──────────────
+
+  it('should round-trip pipeline state through ProjectStateSchema', () => {
+    const pipeline = makePopulatedPipeline();
+    const state = makeBaseState({ pipeline });
+
+    const result = ProjectStateSchema.safeParse(state);
+    expect(result.success).toBe(true);
+    if (!result.success) return;
+
+    expect(result.data.pipeline).toBeDefined();
+    expect(result.data.pipeline!.pipelinePhase).toBe('CONSENSUS_ROLE_PLANS');
+    expect(result.data.pipeline!.artifacts).toHaveLength(1);
+    expect(result.data.pipeline!.recoveryCount).toBe(2);
+  });
+
+  // ─── Test 2: Backward compatibility — legacy state without pipeline ─
+
+  it('should load legacy state without pipeline as undefined', () => {
+    const state = makeBaseState();
+    // Explicitly ensure no pipeline field
+    delete (state as Record<string, unknown>).pipeline;
+
+    const result = ProjectStateSchema.safeParse(state);
+    expect(result.success).toBe(true);
+    if (!result.success) return;
+
+    expect(result.data.pipeline).toBeUndefined();
+  });
+
+  // ─── Test 3: All subfields survive Zod round-trip ──────────────
+
+  it('should preserve all pipeline subfields through Zod round-trip', () => {
+    const pipeline = makePopulatedPipeline();
+    const state = makeBaseState({ pipeline });
+
+    const result = ProjectStateSchema.safeParse(state);
+    expect(result.success).toBe(true);
+    if (!result.success) return;
+
+    const p = result.data.pipeline!;
+
+    // Gate results preserved
+    expect(p.gateResults['INTAKE']).toBeDefined();
+    expect(p.gateResults['INTAKE'].pass).toBe(true);
+
+    // Gate checks preserved
+    expect(p.gateChecks['INTAKE']).toHaveLength(1);
+    expect(p.gateChecks['INTAKE'][0].check_type).toBe('build');
+    expect(p.gateChecks['INTAKE'][0].status).toBe('pass');
+
+    // Active roles preserved
+    expect(p.activeRoles).toEqual(['DISPATCHER', 'ARCHITECT']);
+
+    // Skill usage events preserved
+    expect(p.skillUsageEvents).toHaveLength(1);
+    expect(p.skillUsageEvents![0].role).toBe('ARCHITECT');
+    expect(p.skillUsageEvents![0].used_as).toBe('system_prompt');
+
+    // Failed phase preserved
+    expect(p.failedPhase).toBe('ARCHITECTURE');
+
+    // No inflation — constitutionHash stays empty string
+    expect(p.constitutionHash).toBe('');
+  });
+
+  // ─── Test 4 & 5: saveState/loadState and updateState ───────────
+  // These use disk I/O, so we create a temp dir
+
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(tmpdir(), 'popeye-persist-test-'));
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    } catch {
+      // cleanup best-effort
+    }
+  });
+
+  it('should persist and load pipeline state via saveState/loadState', async () => {
+    const pipeline = makePopulatedPipeline();
+    const state = makeBaseState({ pipeline });
+
+    await saveState(tmpDir, state);
+    const loaded = await loadState(tmpDir);
+
+    expect(loaded).not.toBeNull();
+    expect(loaded!.pipeline).toBeDefined();
+    expect(loaded!.pipeline!.pipelinePhase).toBe('CONSENSUS_ROLE_PLANS');
+    expect(loaded!.pipeline!.artifacts).toHaveLength(1);
+    expect(loaded!.pipeline!.artifacts[0].type).toBe('master_plan');
+    expect(loaded!.pipeline!.recoveryCount).toBe(2);
+    expect(loaded!.pipeline!.failedPhase).toBe('ARCHITECTURE');
+  });
+
+  it('should merge pipeline update via updateState without losing other fields', async () => {
+    const pipeline = makePopulatedPipeline();
+    const state = makeBaseState({
+      pipeline,
+      specification: 'original spec',
+    });
+
+    // Save initial state
+    await saveState(tmpDir, state);
+
+    // Update only the pipeline (advance phase, bump recovery)
+    const updatedPipeline: PipelineState = {
+      ...pipeline,
+      pipelinePhase: 'IMPLEMENTATION',
+      recoveryCount: 0,
+    };
+
+    const result = await updateState(tmpDir, { pipeline: updatedPipeline });
+
+    // Pipeline was updated
+    expect(result.pipeline).toBeDefined();
+    expect(result.pipeline!.pipelinePhase).toBe('IMPLEMENTATION');
+    expect(result.pipeline!.recoveryCount).toBe(0);
+
+    // Other fields preserved
+    expect(result.specification).toBe('original spec');
+    expect(result.name).toBe('test-project');
+    expect(result.id).toBe('test-id');
+
+    // Verify on disk too
+    const loaded = await loadState(tmpDir);
+    expect(loaded!.pipeline!.pipelinePhase).toBe('IMPLEMENTATION');
+    expect(loaded!.specification).toBe('original spec');
+  });
+});