popeye-cli 1.10.0 → 2.1.0

package/tests/pipeline/start-env-checks.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Start & Env Checks tests — application start check,
+ * environment variable validation from .env.example.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { runStartCheck, runEnvCheck } from '../../src/pipeline/check-runner.js';
+
+const TEST_DIR = join(process.cwd(), 'tmp-start-env-test');
+
+beforeEach(() => {
+  mkdirSync(TEST_DIR, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+});
+
+describe('runStartCheck', () => {
+  it('should pass when process stays alive past timeout', async () => {
+    // 'sleep 10' will stay alive for 10s, well past our 1s timeout
+    const result = await runStartCheck('sleep 10', TEST_DIR, { timeoutMs: 1000 });
+    expect(result.check_type).toBe('start');
+    expect(result.status).toBe('pass');
+    expect(result.exit_code).toBe(0);
+  }, 10000);
+
+  it('should fail when process crashes immediately', async () => {
+    const result = await runStartCheck('exit 1', TEST_DIR, { timeoutMs: 3000 });
+    expect(result.check_type).toBe('start');
+    expect(result.status).toBe('fail');
+  }, 10000);
+
+  it('should fail for dangerous commands', async () => {
+    const result = await runStartCheck('sudo rm -rf /', TEST_DIR);
+    expect(result.status).toBe('fail');
+    expect(result.stderr_summary).toContain('rejected');
+  });
+
+  it('should return start check type', async () => {
+    const result = await runStartCheck('echo hello', TEST_DIR, { timeoutMs: 1000 });
+    expect(result.check_type).toBe('start');
+  }, 5000);
+});
+
+describe('runEnvCheck', () => {
+  it('should pass when no .env.example exists', () => {
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.check_type).toBe('env_check');
+    expect(result.status).toBe('pass');
+    expect(result.stderr_summary).toContain('No .env.example');
+  });
+
+  it('should fail when .env.example exists but .env is missing', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'API_KEY=\nDB_URL=');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('fail');
+    expect(result.stderr_summary).toContain('.env file not found');
+    expect(result.stderr_summary).toContain('API_KEY');
+    expect(result.stderr_summary).toContain('DB_URL');
+  });
+
+  it('should pass when all required vars are present', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'API_KEY=your-key\nDB_URL=postgres://');
+    writeFileSync(join(TEST_DIR, '.env'), 'API_KEY=real-key\nDB_URL=postgres://localhost/db');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+  });
+
+  it('should fail when required vars are missing from .env', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'API_KEY=\nDB_URL=\nSECRET=');
+    writeFileSync(join(TEST_DIR, '.env'), 'API_KEY=real-key');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('fail');
+    expect(result.stderr_summary).toContain('Missing vars');
+    expect(result.stderr_summary).toContain('DB_URL');
+    expect(result.stderr_summary).toContain('SECRET');
+  });
+
+  it('should warn about empty vars but still pass', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'API_KEY=\nOPTIONAL_VAR=');
+    writeFileSync(join(TEST_DIR, '.env'), 'API_KEY=real-key\nOPTIONAL_VAR=');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+    expect(result.stderr_summary).toContain('Empty vars');
+    expect(result.stderr_summary).toContain('OPTIONAL_VAR');
+  });
+
+  it('should skip comments in .env.example', () => {
+    writeFileSync(
+      join(TEST_DIR, '.env.example'),
+      '# Database config\nDB_URL=postgres://\n# API keys\nAPI_KEY=',
+    );
+    writeFileSync(join(TEST_DIR, '.env'), 'DB_URL=postgres://localhost\nAPI_KEY=key123');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+  });
+
+  it('should handle quoted values in .env', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'SECRET=');
+    writeFileSync(join(TEST_DIR, '.env'), 'SECRET="my-secret-value"');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+  });
+
+  it('should skip empty lines in .env.example', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), '\nAPI_KEY=\n\nDB_URL=\n\n');
+    writeFileSync(join(TEST_DIR, '.env'), 'API_KEY=key\nDB_URL=url');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+  });
+});

package/tests/pipeline/types.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Pipeline Types tests — Zod schema validation for all types.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  PipelinePhaseSchema,
+  PipelineRoleSchema,
+  ArtifactTypeSchema,
+  GateCheckTypeSchema,
+  createDefaultPipelineState,
+} from '../../src/pipeline/types.js';
+
+describe('PipelineTypes', () => {
+  describe('PipelinePhaseSchema', () => {
+    it('should accept valid phases', () => {
+      const phases = [
+        '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 result = PipelinePhaseSchema.safeParse(phase);
+        expect(result.success).toBe(true);
+      }
+    });
+
+    it('should reject invalid phases', () => {
+      const result = PipelinePhaseSchema.safeParse('INVALID_PHASE');
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject non-string values', () => {
+      expect(PipelinePhaseSchema.safeParse(42).success).toBe(false);
+      expect(PipelinePhaseSchema.safeParse(null).success).toBe(false);
+    });
+  });
+
+  describe('PipelineRoleSchema', () => {
+    it('should accept all valid roles', () => {
+      const roles = [
+        'DISPATCHER', 'ARCHITECT', 'DB_EXPERT',
+        'BACKEND_PROGRAMMER', 'FRONTEND_PROGRAMMER',
+        'WEBSITE_PROGRAMMER', 'QA_TESTER',
+        'REVIEWER', 'ARBITRATOR', 'DEBUGGER',
+        'AUDITOR', 'JOURNALIST', 'RELEASE_MANAGER',
+        'MARKETING_EXPERT', 'SOCIAL_EXPERT', 'UI_UX_SPECIALIST',
+      ];
+
+      for (const role of roles) {
+        const result = PipelineRoleSchema.safeParse(role);
+        expect(result.success).toBe(true);
+      }
+    });
+
+    it('should reject invalid roles', () => {
+      expect(PipelineRoleSchema.safeParse('INVALID_ROLE').success).toBe(false);
+    });
+
+    it('should have exactly 16 roles', () => {
+      expect(PipelineRoleSchema.options.length).toBe(16);
+    });
+  });
+
+  describe('createDefaultPipelineState', () => {
+    it('should create state with INTAKE phase', () => {
+      const state = createDefaultPipelineState();
+      expect(state.pipelinePhase).toBe('INTAKE');
+    });
+
+    it('should create state with empty artifacts', () => {
+      const state = createDefaultPipelineState();
+      expect(state.artifacts).toEqual([]);
+    });
+
+    it('should create state with zero recovery count', () => {
+      const state = createDefaultPipelineState();
+      expect(state.recoveryCount).toBe(0);
+    });
+
+    it('should create state with max recovery of 5', () => {
+      const state = createDefaultPipelineState();
+      expect(state.maxRecoveryIterations).toBe(5);
+    });
+
+    it('should create state with empty gate results', () => {
+      const state = createDefaultPipelineState();
+      expect(state.gateResults).toEqual({});
+      expect(state.gateChecks).toEqual({});
+    });
+
+    it('should create state with empty active roles', () => {
+      const state = createDefaultPipelineState();
+      expect(state.activeRoles).toEqual([]);
+    });
+
+    it('should create state with empty constitution hash', () => {
+      const state = createDefaultPipelineState();
+      expect(state.constitutionHash).toBe('');
+    });
+
+    it('should return independent instances', () => {
+      const s1 = createDefaultPipelineState();
+      const s2 = createDefaultPipelineState();
+      s1.artifacts.push({} as any);
+      expect(s2.artifacts).toHaveLength(0);
+    });
+  });
+
+  describe('ArtifactTypeSchema (v1.1)', () => {
+    it('should accept constitution artifact type', () => {
+      expect(ArtifactTypeSchema.safeParse('constitution').success).toBe(true);
+    });
+
+    it('should accept change_request artifact type', () => {
+      expect(ArtifactTypeSchema.safeParse('change_request').success).toBe(true);
+    });
+
+    it('should still accept all original artifact types', () => {
+      const originals = [
+        'master_plan', 'architecture', 'role_plan', 'consensus',
+        'audit_report', 'repo_snapshot', 'build_check', 'qa_validation',
+      ];
+      for (const t of originals) {
+        expect(ArtifactTypeSchema.safeParse(t).success).toBe(true);
+      }
+    });
+
+    it('should reject unknown artifact types', () => {
+      expect(ArtifactTypeSchema.safeParse('unknown_type').success).toBe(false);
+    });
+  });
+
+  describe('GateCheckTypeSchema (v1.1)', () => {
+    it('should accept start check type', () => {
+      expect(GateCheckTypeSchema.safeParse('start').success).toBe(true);
+    });
+
+    it('should accept env_check type', () => {
+      expect(GateCheckTypeSchema.safeParse('env_check').success).toBe(true);
+    });
+
+    it('should still accept all original check types', () => {
+      const originals = ['build', 'test', 'lint', 'typecheck', 'migration', 'placeholder_scan'];
+      for (const t of originals) {
+        expect(GateCheckTypeSchema.safeParse(t).success).toBe(true);
+      }
+    });
+
+    it('should reject unknown check types', () => {
+      expect(GateCheckTypeSchema.safeParse('unknown_check').success).toBe(false);
+    });
+  });
+});

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();
+  });
+});