popeye-cli 2.0.0 → 2.1.0

package/tests/pipeline/session-guidance.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Fix A tests — sessionGuidance threading through pipeline.
+ * Verifies additionalContext persists in PipelineState and reaches phases.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  createDefaultPipelineState,
+  PipelineStateSchema,
+  ArtifactTypeSchema,
+} from '../../src/pipeline/types.js';
+
+describe('Fix A: sessionGuidance threading', () => {
+  describe('PipelineState.sessionGuidance', () => {
+    it('should accept sessionGuidance in pipeline state', () => {
+      const state = createDefaultPipelineState();
+      state.sessionGuidance = 'Upgrade from v1 to v2: preserve API backwards compat';
+
+      const result = PipelineStateSchema.safeParse(state);
+      expect(result.success).toBe(true);
+      expect(result.data?.sessionGuidance).toBe(
+        'Upgrade from v1 to v2: preserve API backwards compat',
+      );
+    });
+
+    it('should allow omitting sessionGuidance (backward compat)', () => {
+      const state = createDefaultPipelineState();
+      // No sessionGuidance set
+
+      const result = PipelineStateSchema.safeParse(state);
+      expect(result.success).toBe(true);
+      expect(result.data?.sessionGuidance).toBeUndefined();
+    });
+
+    it('should allow empty string for sessionGuidance', () => {
+      const state = createDefaultPipelineState();
+      state.sessionGuidance = '';
+
+      const result = PipelineStateSchema.safeParse(state);
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('additional_context artifact type', () => {
+    it('should accept additional_context as valid artifact type', () => {
+      const result = ArtifactTypeSchema.safeParse('additional_context');
+      expect(result.success).toBe(true);
+    });
+
+    it('should still accept all existing artifact types', () => {
+      const existingTypes = [
+        'master_plan', 'architecture', 'role_plan', 'consensus',
+        'arbitration', 'audit_report', 'rca_report', 'production_readiness',
+        'change_request',
+      ];
+
+      for (const type of existingTypes) {
+        expect(ArtifactTypeSchema.safeParse(type).success).toBe(true);
+      }
+    });
+  });
+
+  describe('PipelineOptions additionalContext -> sessionGuidance', () => {
+    it('should store additionalContext in pipeline state when not already set', () => {
+      const pipeline = createDefaultPipelineState();
+      const additionalContext = 'Focus on mobile-first responsive design';
+
+      // Simulates orchestrator logic
+      if (additionalContext && !pipeline.sessionGuidance) {
+        pipeline.sessionGuidance = additionalContext;
+      }
+
+      expect(pipeline.sessionGuidance).toBe('Focus on mobile-first responsive design');
+    });
+
+    it('should not overwrite existing sessionGuidance on resume', () => {
+      const pipeline = createDefaultPipelineState();
+      pipeline.sessionGuidance = 'Original guidance from first run';
+      const additionalContext = 'New guidance on resume';
+
+      // Simulates orchestrator logic
+      if (additionalContext && !pipeline.sessionGuidance) {
+        pipeline.sessionGuidance = additionalContext;
+      }
+
+      expect(pipeline.sessionGuidance).toBe('Original guidance from first run');
+    });
+
+    it('should leave sessionGuidance undefined when no additionalContext', () => {
+      const pipeline = createDefaultPipelineState();
+      const additionalContext: string | undefined = undefined;
+
+      if (additionalContext && !pipeline.sessionGuidance) {
+        pipeline.sessionGuidance = additionalContext;
+      }
+
+      expect(pipeline.sessionGuidance).toBeUndefined();
+    });
+  });
+
+  describe('INTAKE phase guidance injection', () => {
+    it('should prepend guidance to plan input when provided', () => {
+      const guidance = 'Upgrade context: migrate from Express to Fastify';
+      const expandedIdea = 'Build a REST API with user authentication';
+
+      const planInput = guidance
+        ? `${guidance}\n\n---\n\n${expandedIdea}`
+        : expandedIdea;
+
+      expect(planInput).toContain(guidance);
+      expect(planInput).toContain('---');
+      expect(planInput).toContain(expandedIdea);
+      expect(planInput.indexOf(guidance)).toBeLessThan(planInput.indexOf(expandedIdea));
+    });
+
+    it('should pass through expandedIdea unchanged when no guidance', () => {
+      const guidance = '';
+      const expandedIdea = 'Build a REST API with user authentication';
+
+      const planInput = guidance
+        ? `${guidance}\n\n---\n\n${expandedIdea}`
+        : expandedIdea;
+
+      expect(planInput).toBe(expandedIdea);
+    });
+  });
+
+  describe('IMPLEMENTATION phase guidance injection', () => {
+    it('should merge role prompt with guidance', () => {
+      const combinedRolePrompt = '## BACKEND_PROGRAMMER\nScope: API endpoints';
+      const guidance = 'Preserve backwards compatibility with v1 API';
+
+      const systemPrompt = [combinedRolePrompt, guidance].filter(Boolean).join('\n\n') || undefined;
+
+      expect(systemPrompt).toContain(combinedRolePrompt);
+      expect(systemPrompt).toContain(guidance);
+    });
+
+    it('should use only role prompt when no guidance', () => {
+      const combinedRolePrompt = '## BACKEND_PROGRAMMER\nScope: API endpoints';
+      const guidance: string | undefined = undefined;
+
+      const systemPrompt = [combinedRolePrompt, guidance].filter(Boolean).join('\n\n') || undefined;
+
+      expect(systemPrompt).toBe(combinedRolePrompt);
+    });
+
+    it('should use only guidance when no role prompt', () => {
+      const combinedRolePrompt = '';
+      const guidance = 'Focus on performance';
+
+      const systemPrompt = [combinedRolePrompt, guidance].filter(Boolean).join('\n\n') || undefined;
+
+      expect(systemPrompt).toBe(guidance);
+    });
+
+    it('should return undefined when neither role prompt nor guidance', () => {
+      const combinedRolePrompt = '';
+      const guidance: string | undefined = undefined;
+
+      const systemPrompt = [combinedRolePrompt, guidance].filter(Boolean).join('\n\n') || undefined;
+
+      expect(systemPrompt).toBeUndefined();
+    });
+  });
+
+  describe('RECOVERY_LOOP guidance in RCA prompt', () => {
+    it('should include user guidance in RCA prompt when available', () => {
+      const debuggerPrompt = 'You are a debugger agent...';
+      const guidance = 'User wants API backwards compat preserved';
+      const failureEvidence = 'Failed phase: QA_VALIDATION';
+
+      const rcaPrompt = [
+        debuggerPrompt,
+        '',
+        ...(guidance ? ['## User Guidance', guidance, ''] : []),
+        '## Failure Evidence',
+        failureEvidence,
+      ].join('\n');
+
+      expect(rcaPrompt).toContain('## User Guidance');
+      expect(rcaPrompt).toContain(guidance);
+      expect(rcaPrompt.indexOf('User Guidance')).toBeLessThan(
+        rcaPrompt.indexOf('Failure Evidence'),
+      );
+    });
+
+    it('should omit User Guidance section when no guidance', () => {
+      const debuggerPrompt = 'You are a debugger agent...';
+      const guidance: string | undefined = undefined;
+      const failureEvidence = 'Failed phase: QA_VALIDATION';
+
+      const rcaPrompt = [
+        debuggerPrompt,
+        '',
+        ...(guidance ? ['## User Guidance', guidance, ''] : []),
+        '## Failure Evidence',
+        failureEvidence,
+      ].join('\n');
+
+      expect(rcaPrompt).not.toContain('## User Guidance');
+      expect(rcaPrompt).toContain('## Failure Evidence');
+    });
+  });
+});

package/tests/types/consensus.test.ts

@@ -141,7 +141,7 @@ describe('DEFAULT_CONSENSUS_CONFIG', () => {
   it('should have valid default values', () => {
     expect(DEFAULT_CONSENSUS_CONFIG.threshold).toBe(95);
     expect(DEFAULT_CONSENSUS_CONFIG.maxIterations).toBe(10);
-    expect(DEFAULT_CONSENSUS_CONFIG.openaiModel).toBe('gpt-4o');
+    expect(DEFAULT_CONSENSUS_CONFIG.openaiModel).toBe('gpt-4.1');
     expect(DEFAULT_CONSENSUS_CONFIG.temperature).toBe(0.3);
     expect(DEFAULT_CONSENSUS_CONFIG.maxTokens).toBe(4096);
   });

package/tests/workflow/pipeline-bootstrap.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Fix B tests — new projects use pipeline from start.
+ * Verifies that runWorkflow() bootstraps state before pipeline.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the modules before importing
+vi.mock('../../src/state/index.js', () => ({
+  loadProject: vi.fn(),
+  projectExists: vi.fn(),
+  getProgress: vi.fn(),
+  resetToPhase: vi.fn(),
+  deleteProject: vi.fn(),
+  verifyProjectCompletion: vi.fn(),
+  resetIncompleteProject: vi.fn(),
+  createProject: vi.fn(),
+}));
+
+vi.mock('../../src/pipeline/orchestrator.js', () => ({
+  runPipeline: vi.fn(),
+  resumePipeline: vi.fn(),
+}));
+
+vi.mock('../../src/workflow/plan-mode.js', () => ({
+  runPlanMode: vi.fn(),
+  resumePlanMode: vi.fn(),
+}));
+
+vi.mock('../../src/workflow/execution-mode.js', () => ({
+  runExecutionMode: vi.fn(),
+  resumeExecutionMode: vi.fn(),
+  executeSingleTask: vi.fn(),
+}));
+
+vi.mock('../../src/workflow/workflow-logger.js', () => ({
+  getWorkflowLogger: () => ({
+    stageStart: vi.fn(),
+    stageComplete: vi.fn(),
+    stageFailed: vi.fn(),
+    info: vi.fn(),
+  }),
+}));
+
+describe('Fix B: New projects use pipeline from start', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    // Default: pipeline mode enabled
+    delete process.env.POPEYE_LEGACY_WORKFLOW;
+  });
+
+  it('should create state and run pipeline when state does not exist', async () => {
+    const { loadProject, createProject } = await import('../../src/state/index.js');
+    const { runPipeline } = await import('../../src/pipeline/orchestrator.js');
+
+    const mockState = {
+      id: 'test-id',
+      name: 'test-project',
+      idea: 'Build something',
+      language: 'python' as const,
+      phase: 'plan' as const,
+      status: 'pending' as const,
+      milestones: [],
+      currentMilestone: null,
+      currentTask: null,
+      consensusHistory: [],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    // loadProject fails (no state.json) on first call, succeeds after create
+    vi.mocked(loadProject)
+      .mockRejectedValueOnce(new Error('No project found'))
+      .mockResolvedValue(mockState as any);
+
+    vi.mocked(createProject).mockResolvedValue(mockState as any);
+    vi.mocked(runPipeline).mockResolvedValue({
+      success: true,
+      finalPhase: 'DONE',
+      artifacts: [],
+      recoveryIterations: 0,
+    });
+
+    const { runWorkflow } = await import('../../src/workflow/index.js');
+
+    const result = await runWorkflow(
+      { idea: 'Build something', name: 'test-project', language: 'python', openaiModel: 'gpt-4o' },
+      { projectDir: '/tmp/test-project' },
+    );
+
+    expect(createProject).toHaveBeenCalledWith(
+      expect.objectContaining({ idea: 'Build something' }),
+      '/tmp/test-project',
+    );
+    expect(runPipeline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectDir: '/tmp/test-project',
+        state: mockState,
+      }),
+    );
+    expect(result.success).toBe(true);
+  });
+
+  it('should use existing state when state already exists', async () => {
+    const { loadProject, createProject } = await import('../../src/state/index.js');
+    const { runPipeline } = await import('../../src/pipeline/orchestrator.js');
+
+    const existingState = {
+      id: 'existing-id',
+      name: 'existing-project',
+      phase: 'execution' as const,
+    };
+
+    vi.mocked(loadProject).mockResolvedValue(existingState as any);
+    vi.mocked(runPipeline).mockResolvedValue({
+      success: true,
+      finalPhase: 'DONE',
+      artifacts: [],
+      recoveryIterations: 0,
+    });
+
+    const { runWorkflow } = await import('../../src/workflow/index.js');
+
+    await runWorkflow(
+      { idea: 'Build something', name: 'existing-project', language: 'python', openaiModel: 'gpt-4o' },
+      { projectDir: '/tmp/existing-project' },
+    );
+
+    // Should NOT call createProject since state exists
+    expect(createProject).not.toHaveBeenCalled();
+    expect(runPipeline).toHaveBeenCalled();
+  });
+
+  it('should fall through to legacy workflow when POPEYE_LEGACY_WORKFLOW=1', async () => {
+    process.env.POPEYE_LEGACY_WORKFLOW = '1';
+
+    const { runPipeline } = await import('../../src/pipeline/orchestrator.js');
+    const { runPlanMode } = await import('../../src/workflow/plan-mode.js');
+    const { runExecutionMode } = await import('../../src/workflow/execution-mode.js');
+
+    vi.mocked(runPlanMode).mockResolvedValue({
+      success: true,
+      state: { phase: 'execution' } as any,
+    });
+    vi.mocked(runExecutionMode).mockResolvedValue({
+      success: true,
+      state: { phase: 'complete' } as any,
+      completedTasks: 5,
+      failedTasks: 0,
+    });
+
+    const { runWorkflow } = await import('../../src/workflow/index.js');
+
+    await runWorkflow(
+      { idea: 'Build something', name: 'test', language: 'python', openaiModel: 'gpt-4o' },
+      { projectDir: '/tmp/test' },
+    );
+
+    // Pipeline should NOT be called in legacy mode
+    expect(runPipeline).not.toHaveBeenCalled();
+  });
+});