popeye-cli 2.0.0 → 2.1.0

package/src/upgrade/handlers.ts

@@ -349,7 +349,7 @@ export async function upgradeFullstackToAll(
       idea: 'Marketing website',
       name: projectName,
       language: 'all',
-      openaiModel: 'gpt-4o',
+      openaiModel: 'gpt-4.1',
     };
 
     // Build content context from user docs, brand assets, and strategy
@@ -421,7 +421,7 @@ export async function upgradeSingleToFullstack(
     if (!(await pathExists(frontendDir))) {
       const spec: ProjectSpec = {
         idea: 'Frontend application', name: projectName,
-        language: 'fullstack', openaiModel: 'gpt-4o',
+        language: 'fullstack', openaiModel: 'gpt-4.1',
       };
       const result = await generateTypeScriptProject(spec, path.join(projectDir, 'apps'), {
         baseDir: frontendDir,
@@ -439,7 +439,7 @@ export async function upgradeSingleToFullstack(
     if (!(await pathExists(backendDir))) {
       const spec: ProjectSpec = {
         idea: 'Backend API', name: projectName,
-        language: 'fullstack', openaiModel: 'gpt-4o',
+        language: 'fullstack', openaiModel: 'gpt-4.1',
       };
       const result = await generatePythonProject(spec, path.join(projectDir, 'apps'), {
         baseDir: backendDir,
@@ -508,7 +508,7 @@ export async function upgradeWebsiteToAll(
   if (!(await pathExists(frontendDir))) {
     const spec: ProjectSpec = {
       idea: 'Frontend application', name: projectName,
-      language: 'all', openaiModel: 'gpt-4o',
+      language: 'all', openaiModel: 'gpt-4.1',
     };
     const result = await generateTypeScriptProject(spec, path.join(projectDir, 'apps'), {
       baseDir: frontendDir,
@@ -520,7 +520,7 @@ export async function upgradeWebsiteToAll(
   if (!(await pathExists(backendDir))) {
     const spec: ProjectSpec = {
       idea: 'Backend API', name: projectName,
-      language: 'all', openaiModel: 'gpt-4o',
+      language: 'all', openaiModel: 'gpt-4.1',
     };
     const result = await generatePythonProject(spec, path.join(projectDir, 'apps'), {
       baseDir: backendDir,

package/src/workflow/index.ts

@@ -104,21 +104,24 @@ export async function runWorkflow(
   const useLegacy = process.env.POPEYE_LEGACY_WORKFLOW === '1' || process.env.POPEYE_LEGACY_WORKFLOW === 'true';
   if (!useLegacy) {
     try {
-      const state = await loadProject(projectDir).catch(() => null);
-      if (state) {
-        const result = await runPipeline({
-          projectDir,
-          state,
-          consensusConfig,
-          onPhaseStart: (phase) => onProgress?.('pipeline', `Starting phase: ${phase}`),
-          onProgress: (msg) => onProgress?.('pipeline', msg),
-        });
-        return {
-          success: result.success,
-          state: await loadProject(projectDir).catch(() => ({} as ProjectState)),
-          error: result.error,
-        };
+      // Bootstrap state if it doesn't exist yet (new projects)
+      let state = await loadProject(projectDir).catch(() => null);
+      if (!state) {
+        const { createProject } = await import('../state/index.js');
+        state = await createProject(spec, projectDir);
       }
+      const result = await runPipeline({
+        projectDir,
+        state,
+        consensusConfig,
+        onPhaseStart: (phase) => onProgress?.('pipeline', `Starting phase: ${phase}`),
+        onProgress: (msg) => onProgress?.('pipeline', msg),
+      });
+      return {
+        success: result.success,
+        state: await loadProject(projectDir).catch(() => ({} as ProjectState)),
+        error: result.error,
+      };
     } catch {
       // Fall through to legacy workflow on pipeline error
       onProgress?.('workflow', 'Pipeline mode failed, falling back to legacy workflow...');
@@ -241,6 +244,7 @@ export async function resumeWorkflow(
         projectDir,
         state,
         consensusConfig,
+        additionalContext,
         onPhaseStart: (phase) => onProgress?.('pipeline', `Resuming phase: ${phase}`),
         onProgress: (msg) => onProgress?.('pipeline', msg),
       });

package/src/workflow/website-strategy.ts

@@ -142,7 +142,7 @@ Respond with ONLY valid JSON, no markdown code fences or explanation.`;
   onProgress?.('Generating website strategy via AI...');
 
   const completion = await client.chat.completions.create({
-    model: 'gpt-4o',
+    model: 'gpt-4.1',
     messages: [{ role: 'user', content: prompt }],
     temperature: 0.4,
     max_tokens: 4096,

package/tests/cli/model-command.test.ts

@@ -5,7 +5,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { OpenAIModelSchema, KNOWN_OPENAI_MODELS } from '../../src/types/project.js';
-import { GeminiModelSchema, GrokModelSchema, KNOWN_GEMINI_MODELS } from '../../src/types/consensus.js';
+import { GeminiModelSchema, GrokModelSchema, KNOWN_GEMINI_MODELS, KNOWN_GROK_MODELS } from '../../src/types/consensus.js';
 
 describe('OpenAI model validation', () => {
   it('should accept known OpenAI models', () => {
@@ -17,7 +17,7 @@ describe('OpenAI model validation', () => {
   it('should accept unknown/new OpenAI models (flexible)', () => {
     expect(OpenAIModelSchema.safeParse('gpt-5').success).toBe(true);
     expect(OpenAIModelSchema.safeParse('gpt-5.2-turbo').success).toBe(true);
-    expect(OpenAIModelSchema.safeParse('o3-mini').success).toBe(true);
+    expect(OpenAIModelSchema.safeParse('some-future-model').success).toBe(true);
   });
 
   it('should reject empty string', () => {
@@ -33,8 +33,8 @@ describe('Gemini model validation', () => {
   });
 
   it('should accept unknown/new Gemini models (flexible)', () => {
-    expect(GeminiModelSchema.safeParse('gemini-2.5-pro').success).toBe(true);
     expect(GeminiModelSchema.safeParse('gemini-3.0-ultra').success).toBe(true);
+    expect(GeminiModelSchema.safeParse('gemini-4.0-flash').success).toBe(true);
   });
 
   it('should reject empty string', () => {
@@ -44,9 +44,9 @@ describe('Gemini model validation', () => {
 
 describe('Grok model validation', () => {
   it('should accept any non-empty string as Grok model', () => {
+    expect(GrokModelSchema.safeParse('grok-4-0709').success).toBe(true);
     expect(GrokModelSchema.safeParse('grok-3').success).toBe(true);
     expect(GrokModelSchema.safeParse('grok-3-mini').success).toBe(true);
-    expect(GrokModelSchema.safeParse('grok-2').success).toBe(true);
     expect(GrokModelSchema.safeParse('some-future-model').success).toBe(true);
   });
 
@@ -62,15 +62,25 @@ describe('Grok model validation', () => {
 
 describe('known models lists', () => {
   it('should have known OpenAI models', () => {
+    expect(KNOWN_OPENAI_MODELS).toContain('gpt-4.1');
     expect(KNOWN_OPENAI_MODELS).toContain('gpt-4o');
-    expect(KNOWN_OPENAI_MODELS).toContain('gpt-4o-mini');
-    expect(KNOWN_OPENAI_MODELS.length).toBeGreaterThanOrEqual(5);
+    expect(KNOWN_OPENAI_MODELS).toContain('o3');
+    expect(KNOWN_OPENAI_MODELS).toContain('o4-mini');
+    expect(KNOWN_OPENAI_MODELS.length).toBeGreaterThanOrEqual(8);
   });
 
   it('should have known Gemini models', () => {
+    expect(KNOWN_GEMINI_MODELS).toContain('gemini-2.5-flash');
+    expect(KNOWN_GEMINI_MODELS).toContain('gemini-2.5-pro');
     expect(KNOWN_GEMINI_MODELS).toContain('gemini-2.0-flash');
-    expect(KNOWN_GEMINI_MODELS).toContain('gemini-1.5-pro');
-    expect(KNOWN_GEMINI_MODELS.length).toBeGreaterThanOrEqual(3);
+    expect(KNOWN_GEMINI_MODELS.length).toBeGreaterThanOrEqual(5);
+  });
+
+  it('should have known Grok models', () => {
+    expect(KNOWN_GROK_MODELS).toContain('grok-4-0709');
+    expect(KNOWN_GROK_MODELS).toContain('grok-3');
+    expect(KNOWN_GROK_MODELS).toContain('grok-3-mini');
+    expect(KNOWN_GROK_MODELS.length).toBeGreaterThanOrEqual(4);
   });
 });
 
@@ -84,7 +94,7 @@ describe('backward compatibility', () => {
   });
 
   it('should not auto-detect non-OpenAI models as known OpenAI', () => {
-    const nonOpenAI = ['gemini-2.0-flash', 'grok-3'];
+    const nonOpenAI = ['gemini-2.5-flash', 'grok-3', 'grok-4-0709'];
     for (const model of nonOpenAI) {
       const isKnown = (KNOWN_OPENAI_MODELS as readonly string[]).includes(model);
       expect(isKnown).toBe(false);

package/tests/config/config.test.ts

@@ -23,7 +23,7 @@ describe('DEFAULT_CONFIG', () => {
   });
 
   it('should have valid API defaults', () => {
-    expect(DEFAULT_CONFIG.apis.openai.model).toBe('gpt-4o');
+    expect(DEFAULT_CONFIG.apis.openai.model).toBe('gpt-4.1');
     expect(DEFAULT_CONFIG.apis.openai.temperature).toBe(0.3);
     expect(DEFAULT_CONFIG.apis.openai.max_tokens).toBe(4096);
   });
@@ -122,11 +122,11 @@ describe('ConfigSchema', () => {
     expect(result.success).toBe(false);
   });
 
-  it('should reject invalid model', () => {
+  it('should reject empty model string', () => {
     const config = {
       apis: {
         openai: {
-          model: 'gpt-5',
+          model: '',
         },
       },
     };

package/tests/config/popeye-md.test.ts

@@ -0,0 +1,168 @@
+/**
+ * Fix C tests — readPopeyeMdConfig shared config reader.
+ * Verifies popeye.md parsing for CLI commands.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { readPopeyeMdConfig } from '../../src/config/popeye-md.js';
+
+describe('Fix C: readPopeyeMdConfig', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-md-test-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should return null when popeye.md does not exist', async () => {
+    const config = await readPopeyeMdConfig(tmpDir);
+    expect(config).toBeNull();
+  });
+
+  it('should parse basic config with reviewer and language', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'popeye.md'),
+      [
+        '---',
+        'language: python',
+        'reviewer: openai',
+        'arbitrator: gemini',
+        '---',
+        '',
+        '# Project Config',
+      ].join('\n'),
+    );
+
+    const config = await readPopeyeMdConfig(tmpDir);
+    expect(config).not.toBeNull();
+    expect(config!.language).toBe('python');
+    expect(config!.reviewer).toBe('openai');
+    expect(config!.arbitrator).toBe('gemini');
+    expect(config!.enableArbitration).toBe(true);
+  });
+
+  it('should parse model fields from popeye.md', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'popeye.md'),
+      [
+        '---',
+        'language: typescript',
+        'reviewer: gemini',
+        'arbitrator: grok',
+        'openaiModel: gpt-4o-mini',
+        'geminiModel: gemini-2.0-flash',
+        'grokModel: grok-3',
+        '---',
+      ].join('\n'),
+    );
+
+    const config = await readPopeyeMdConfig(tmpDir);
+    expect(config).not.toBeNull();
+    expect(config!.openaiModel).toBe('gpt-4o-mini');
+    expect(config!.geminiModel).toBe('gemini-2.0-flash');
+    expect(config!.grokModel).toBe('grok-3');
+  });
+
+  it('should handle arbitrator: off', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'popeye.md'),
+      [
+        '---',
+        'language: fullstack',
+        'reviewer: openai',
+        'arbitrator: off',
+        '---',
+      ].join('\n'),
+    );
+
+    const config = await readPopeyeMdConfig(tmpDir);
+    expect(config).not.toBeNull();
+    expect(config!.enableArbitration).toBe(false);
+  });
+
+  it('should return null when frontmatter is missing', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'popeye.md'),
+      '# Just a markdown file\n\nNo frontmatter here.',
+    );
+
+    const config = await readPopeyeMdConfig(tmpDir);
+    expect(config).toBeNull();
+  });
+
+  it('should return null when essential fields are missing', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'popeye.md'),
+      [
+        '---',
+        'projectName: my-app',
+        'created: 2024-01-01',
+        '---',
+      ].join('\n'),
+    );
+
+    const config = await readPopeyeMdConfig(tmpDir);
+    // Missing language and reviewer -> null
+    expect(config).toBeNull();
+  });
+
+  it('should extract notes section', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'popeye.md'),
+      [
+        '---',
+        'language: website',
+        'reviewer: openai',
+        '---',
+        '',
+        '## Notes',
+        'This project uses Tailwind CSS.',
+        'Deploy to Vercel.',
+      ].join('\n'),
+    );
+
+    const config = await readPopeyeMdConfig(tmpDir);
+    expect(config).not.toBeNull();
+    expect(config!.notes).toContain('Tailwind CSS');
+  });
+
+  it('should reject invalid language values', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'popeye.md'),
+      [
+        '---',
+        'language: rust',
+        'reviewer: openai',
+        '---',
+      ].join('\n'),
+    );
+
+    const config = await readPopeyeMdConfig(tmpDir);
+    // Invalid language means essential field is missing
+    expect(config).toBeNull();
+  });
+
+  it('should return model fields as undefined when not specified', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'popeye.md'),
+      [
+        '---',
+        'language: python',
+        'reviewer: openai',
+        '---',
+      ].join('\n'),
+    );
+
+    const config = await readPopeyeMdConfig(tmpDir);
+    expect(config).not.toBeNull();
+    expect(config!.openaiModel).toBeUndefined();
+    expect(config!.geminiModel).toBeUndefined();
+    expect(config!.grokModel).toBeUndefined();
+  });
+});

package/tests/pipeline/bridges/review-bridge.test.ts

@@ -0,0 +1,243 @@
+/**
+ * Review Bridge tests — severity mapping, category mapping, CR routing,
+ * pipeline detection, finding conversion.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  mapSeverity,
+  mapCategory,
+  categoryToChangeType,
+  convertFinding,
+  isPipelineManaged,
+  extractPipelineState,
+} from '../../../src/pipeline/bridges/review-bridge.js';
+import { createDefaultPipelineState } from '../../../src/pipeline/types.js';
+import type { AuditFinding as WorkflowFinding } from '../../../src/types/audit.js';
+import type { ArtifactRef } from '../../../src/pipeline/types.js';
+import type { ProjectState } from '../../../src/types/workflow.js';
+
+// ─── Test Data ───────────────────────────────────────────
+
+function makeSnapshotRef(): ArtifactRef {
+  return {
+    artifact_id: 'snap-001',
+    path: 'docs/snapshots/repo_snapshot_001.json',
+    sha256: 'abc123',
+    version: 1,
+    type: 'repo_snapshot',
+  };
+}
+
+function makeWorkflowFinding(overrides: Partial<WorkflowFinding> = {}): WorkflowFinding {
+  return {
+    id: 'finding-1',
+    category: 'integration-wiring',
+    severity: 'critical',
+    title: 'API endpoint mismatch',
+    description: 'Frontend calls /api/users but backend serves /api/v1/users',
+    evidence: [{ file: 'src/api.ts', line: 42, snippet: 'fetch("/api/users")' }],
+    recommendation: 'Update frontend API base URL',
+    autoFixable: true,
+    ...overrides,
+  };
+}
+
+function makeProjectState(withPipeline = false): ProjectState {
+  const base: ProjectState = {
+    id: 'test-id',
+    name: 'test-project',
+    idea: 'Build something',
+    language: 'python',
+    phase: 'execution',
+    status: 'in-progress',
+    milestones: [],
+    currentMilestone: null,
+    currentTask: null,
+    consensusHistory: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  } as ProjectState;
+
+  if (withPipeline) {
+    (base as unknown as { pipeline: unknown }).pipeline = createDefaultPipelineState();
+  }
+
+  return base;
+}
+
+// ─── Tests ───────────────────────────────────────────────
+
+describe('Review Bridge', () => {
+  describe('severity mapping', () => {
+    it('should map critical to P0', () => {
+      expect(mapSeverity('critical')).toBe('P0');
+    });
+
+    it('should map major to P1', () => {
+      expect(mapSeverity('major')).toBe('P1');
+    });
+
+    it('should map minor to P2', () => {
+      expect(mapSeverity('minor')).toBe('P2');
+    });
+
+    it('should map info to P3', () => {
+      expect(mapSeverity('info')).toBe('P3');
+    });
+  });
+
+  describe('category mapping', () => {
+    it('should map integration-wiring to integration', () => {
+      expect(mapCategory('integration-wiring')).toBe('integration');
+    });
+
+    it('should map feature-completeness to integration', () => {
+      expect(mapCategory('feature-completeness')).toBe('integration');
+    });
+
+    it('should map test-coverage to tests', () => {
+      expect(mapCategory('test-coverage')).toBe('tests');
+    });
+
+    it('should map config-deployment to config', () => {
+      expect(mapCategory('config-deployment')).toBe('config');
+    });
+
+    it('should map security to security', () => {
+      expect(mapCategory('security')).toBe('security');
+    });
+
+    it('should map dependency-sanity to deployment', () => {
+      expect(mapCategory('dependency-sanity')).toBe('deployment');
+    });
+
+    it('should map consistency to schema', () => {
+      expect(mapCategory('consistency')).toBe('schema');
+    });
+
+    it('should map documentation to deployment', () => {
+      expect(mapCategory('documentation')).toBe('deployment');
+    });
+  });
+
+  describe('CR change type routing', () => {
+    it('should route integration to architecture CR', () => {
+      expect(categoryToChangeType('integration')).toBe('architecture');
+    });
+
+    it('should route schema to architecture CR', () => {
+      expect(categoryToChangeType('schema')).toBe('architecture');
+    });
+
+    it('should route security to requirement CR', () => {
+      expect(categoryToChangeType('security')).toBe('requirement');
+    });
+
+    it('should route tests to config CR', () => {
+      expect(categoryToChangeType('tests')).toBe('config');
+    });
+
+    it('should route config to config CR', () => {
+      expect(categoryToChangeType('config')).toBe('config');
+    });
+
+    it('should route deployment to config CR', () => {
+      expect(categoryToChangeType('deployment')).toBe('config');
+    });
+  });
+
+  describe('finding conversion', () => {
+    it('should convert a critical workflow finding to P0 pipeline finding', () => {
+      const wf = makeWorkflowFinding({ severity: 'critical', category: 'integration-wiring' });
+      const ref = makeSnapshotRef();
+
+      const pf = convertFinding(wf, ref);
+
+      expect(pf.id).toBe('finding-1');
+      expect(pf.severity).toBe('P0');
+      expect(pf.category).toBe('integration');
+      expect(pf.blocking).toBe(true);
+      expect(pf.description).toContain('API endpoint mismatch');
+      expect(pf.file_path).toBe('src/api.ts');
+      expect(pf.line_number).toBe(42);
+      expect(pf.evidence).toEqual([ref]);
+      expect(pf.suggested_owner).toBe('AUDITOR');
+    });
+
+    it('should convert an info finding to P3 non-blocking', () => {
+      const wf = makeWorkflowFinding({ severity: 'info', category: 'documentation' });
+      const ref = makeSnapshotRef();
+
+      const pf = convertFinding(wf, ref);
+
+      expect(pf.severity).toBe('P3');
+      expect(pf.blocking).toBe(false);
+    });
+
+    it('should mark P0 and P1 as blocking, P2 and P3 as non-blocking', () => {
+      const ref = makeSnapshotRef();
+
+      expect(convertFinding(makeWorkflowFinding({ severity: 'critical' }), ref).blocking).toBe(true);
+      expect(convertFinding(makeWorkflowFinding({ severity: 'major' }), ref).blocking).toBe(true);
+      expect(convertFinding(makeWorkflowFinding({ severity: 'minor' }), ref).blocking).toBe(false);
+      expect(convertFinding(makeWorkflowFinding({ severity: 'info' }), ref).blocking).toBe(false);
+    });
+
+    it('should handle finding with no evidence', () => {
+      const wf = makeWorkflowFinding({ evidence: [] });
+      const ref = makeSnapshotRef();
+
+      const pf = convertFinding(wf, ref);
+
+      expect(pf.file_path).toBeUndefined();
+      expect(pf.line_number).toBeUndefined();
+    });
+  });
+
+  describe('pipeline detection', () => {
+    it('should detect pipeline-managed state', () => {
+      const state = makeProjectState(true);
+      expect(isPipelineManaged(state)).toBe(true);
+    });
+
+    it('should detect non-pipeline state', () => {
+      const state = makeProjectState(false);
+      expect(isPipelineManaged(state)).toBe(false);
+    });
+
+    it('should extract pipeline state when present', () => {
+      const state = makeProjectState(true);
+      const pipeline = extractPipelineState(state);
+
+      expect(pipeline).toBeDefined();
+      expect(pipeline!.pipelinePhase).toBe('INTAKE');
+    });
+
+    it('should return undefined when no pipeline state', () => {
+      const state = makeProjectState(false);
+      expect(extractPipelineState(state)).toBeUndefined();
+    });
+  });
+
+  describe('CR routing determinism', () => {
+    it('should route integration findings to CONSENSUS_ARCHITECTURE', () => {
+      // Integration → architecture CR → CONSENSUS_ARCHITECTURE (via change-request.ts routing)
+      const changeType = categoryToChangeType('integration');
+      expect(changeType).toBe('architecture');
+      // architecture routes to CONSENSUS_ARCHITECTURE per CHANGE_TYPE_ROUTING
+    });
+
+    it('should route security findings to CONSENSUS_MASTER_PLAN', () => {
+      const changeType = categoryToChangeType('security');
+      expect(changeType).toBe('requirement');
+      // requirement routes to CONSENSUS_MASTER_PLAN per CHANGE_TYPE_ROUTING
+    });
+
+    it('should route test findings to QA_VALIDATION', () => {
+      const changeType = categoryToChangeType('tests');
+      expect(changeType).toBe('config');
+      // config routes to QA_VALIDATION per CHANGE_TYPE_ROUTING
+    });
+  });
+});