popeye-cli 2.0.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "popeye-cli",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Fully autonomous code generation tool powered by Claude CLI and OpenAI consensus",
   "main": "./dist/index.js",
   "bin": {

package/src/adapters/gemini.ts

@@ -16,7 +16,7 @@ export type GeminiModel = string;
  * Default Gemini configuration
  */
 export const DEFAULT_GEMINI_CONFIG = {
-  model: 'gemini-2.0-flash' as GeminiModel,
+  model: 'gemini-2.5-flash' as GeminiModel,
   temperature: 0.3,
   maxTokens: 4096,
 };
@@ -94,7 +94,7 @@ export async function requestArbitration(
   scores: number[]
 ): Promise<ArbitrationResult> {
   const client = await createClient();
-  const generativeModel = client.getGenerativeModel({ model: 'gemini-2.0-flash' });
+  const generativeModel = client.getGenerativeModel({ model: 'gemini-2.5-flash' });
 
   const prompt = buildArbitrationPrompt(plan, reviewerFeedback, claudeFeedback, iterations, scores);
 
@@ -370,7 +370,7 @@ function parseList(text: string): string[] {
 export async function validateApiKey(): Promise<boolean> {
   try {
     const client = await createClient();
-    const model = client.getGenerativeModel({ model: 'gemini-2.0-flash' });
+    const model = client.getGenerativeModel({ model: 'gemini-2.5-flash' });
     await model.generateContent('Say "OK" if you can hear me.');
     return true;
   } catch {

package/src/adapters/openai.ts

@@ -322,7 +322,7 @@ Be specific and actionable. The specification should be detailed enough that a d
   }
 
   const completion = await client.chat.completions.create({
-    model: 'gpt-4o',
+    model: 'gpt-4.1',
     messages: [{ role: 'user', content: prompt }],
     temperature: 0.7,
     max_tokens: 4096,
@@ -360,7 +360,7 @@ Provide:
 Format your score as: CONSENSUS: [X]%`;
 
   const completion = await client.chat.completions.create({
-    model: 'gpt-4o',
+    model: 'gpt-4.1',
     messages: [{ role: 'user', content: prompt }],
     temperature: 0.3,
     max_tokens: 2048,

package/src/auth/gemini.ts

@@ -30,7 +30,7 @@ export interface GeminiAuthStatus {
 export async function validateGeminiToken(apiKey: string): Promise<boolean> {
   try {
     const client = new GoogleGenerativeAI(apiKey);
-    const model = client.getGenerativeModel({ model: 'gemini-2.0-flash' });
+    const model = client.getGenerativeModel({ model: 'gemini-2.5-flash' });
     // Test the key by making a simple request
     await model.generateContent('Say "OK"');
     return true;

package/src/cli/commands/create.ts

@@ -10,6 +10,7 @@ import { ProjectSpecSchema, type OutputLanguage, type OpenAIModel } from '../../
 import { requireAuth } from '../../auth/index.js';
 import { runWorkflow } from '../../workflow/index.js';
 import { generateProject, projectDirExists, cleanupProject } from '../../generators/index.js';
+import { readPopeyeMdConfig } from '../../config/popeye-md.js';
 import {
   printHeader,
   printSection,
@@ -41,8 +42,8 @@ export function createCreateCommand(): Command {
     )
     .option(
       '-m, --model <model>',
-      'OpenAI model for consensus (gpt-4o, gpt-4o-mini, o1-preview)',
-      'gpt-4o'
+      'OpenAI model for consensus (gpt-4.1, gpt-4o, o3, o4-mini)',
+      'gpt-4.1'
     )
     .option(
       '-o, --output <dir>',
@@ -93,9 +94,8 @@ export function createCreateCommand(): Command {
         }
 
         const model = options.model as OpenAIModel;
-        const validModels = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'];
-        if (!validModels.includes(model)) {
-          printError(`Invalid model: ${model}. Use one of: ${validModels.join(', ')}`);
+        if (!model || model.trim().length === 0) {
+          printError('Model name must not be empty.');
           process.exit(1);
         }
 
@@ -173,15 +173,21 @@ export function createCreateCommand(): Command {
           succeedSpinner(`Created ${scaffoldResult.filesCreated.length} files`);
         }
 
-        // Run the workflow
+        // Run the workflow — merge CLI flags with popeye.md config
         printSection('Workflow Execution');
 
+        const popeyeConfig = await readPopeyeMdConfig(projectDir);
         const workflowResult = await runWorkflow(spec, {
           projectDir,
           consensusConfig: {
             threshold,
             maxIterations,
             openaiModel: model,
+            reviewer: popeyeConfig?.reviewer ?? 'openai',
+            arbitrator: popeyeConfig?.arbitrator,
+            enableArbitration: popeyeConfig?.enableArbitration ?? false,
+            geminiModel: popeyeConfig?.geminiModel,
+            grokModel: popeyeConfig?.grokModel,
           },
           onProgress: (phase, message) => {
             handleProgressUpdate(phase, message);

package/src/cli/commands/resume.ts

@@ -12,6 +12,7 @@ import {
   resetWorkflow,
   cancelWorkflow,
 } from '../../workflow/index.js';
+import { readPopeyeMdConfig } from '../../config/popeye-md.js';
 import type { WorkflowPhase } from '../../types/workflow.js';
 import {
   printHeader,
@@ -94,13 +95,20 @@ export function createResumeCommand(): Command {
           process.exit(1);
         }
 
-        // Resume workflow
+        // Resume workflow — merge CLI flags with popeye.md config
         printSection('Resuming Workflow');
 
+        const popeyeConfig = await readPopeyeMdConfig(projectDir);
         const result = await resumeWorkflow(projectDir, {
           consensusConfig: {
             threshold,
             maxIterations,
+            reviewer: popeyeConfig?.reviewer ?? 'openai',
+            arbitrator: popeyeConfig?.arbitrator,
+            enableArbitration: popeyeConfig?.enableArbitration ?? false,
+            openaiModel: popeyeConfig?.openaiModel,
+            geminiModel: popeyeConfig?.geminiModel,
+            grokModel: popeyeConfig?.grokModel,
           },
           maxRetries,
           onProgress: (phase, message) => {

package/src/cli/interactive.ts

@@ -46,7 +46,7 @@ import { upgradeProject } from '../upgrade/index.js';
 import { buildUpgradeContext } from '../upgrade/context.js';
 import { OutputLanguageSchema, KNOWN_OPENAI_MODELS } from '../types/project.js';
 import type { ProjectSpec, OutputLanguage, OpenAIModel } from '../types/project.js';
-import { GeminiModelSchema, KNOWN_GEMINI_MODELS } from '../types/consensus.js';
+import { GeminiModelSchema, KNOWN_GEMINI_MODELS, KNOWN_GROK_MODELS } from '../types/consensus.js';
 import { OpenAIModelSchema } from '../types/project.js';
 import type { AIProvider, GeminiModel, GrokModel } from '../types/consensus.js';
 import {
@@ -1205,6 +1205,35 @@ async function handleReviewSlashCommand(state: SessionState, args: string[] = []
   }
 
   try {
+    // Check if project is pipeline-managed — route through bridge
+    const { loadProject } = await import('../state/index.js');
+    const projectState = await loadProject(state.projectDir);
+    const { isPipelineManaged, runReviewBridge } = await import('../pipeline/bridges/review-bridge.js');
+
+    if (isPipelineManaged(projectState)) {
+      printInfo('Pipeline-managed project detected — routing through pipeline bridge');
+      console.log();
+
+      const bridgeResult = await runReviewBridge({
+        projectDir: state.projectDir,
+        depth: options.depth,
+        strict: options.strict,
+        onProgress: (_stage, msg) => printInfo(msg),
+      });
+
+      if (bridgeResult.success) {
+        printSuccess(`Audit score: ${bridgeResult.overallScore}% — ${bridgeResult.recommendation}`);
+        printInfo(`${bridgeResult.findingsCount} finding(s), ${bridgeResult.changeRequestCount} CR(s) created, ${bridgeResult.artifactsCreated} artifact(s) stored`);
+        if (bridgeResult.changeRequestCount > 0) {
+          printInfo('Change Requests filed — run /resume to let the pipeline process them');
+        }
+      } else {
+        printError(bridgeResult.error ?? 'Review bridge failed');
+      }
+      return;
+    }
+
+    // Non-pipeline project — use legacy audit-mode
     const { runReview } = await import('./commands/review.js');
 
     console.log();
@@ -1484,7 +1513,7 @@ function handleLanguage(args: string[], state: SessionState): void {
 const KNOWN_MODELS: Record<string, readonly string[]> = {
   openai: KNOWN_OPENAI_MODELS,
   gemini: KNOWN_GEMINI_MODELS,
-  grok: ['grok-3', 'grok-3-mini', 'grok-2'],
+  grok: KNOWN_GROK_MODELS,
 };
 
 /**
@@ -2976,7 +3005,7 @@ export async function startInteractiveMode(): Promise<void> {
     projectDir: process.cwd(),
     language: config.project.default_language,
     openaiModel: config.apis.openai.model,
-    geminiModel: 'gemini-2.0-flash',
+    geminiModel: 'gemini-2.5-flash',
     grokModel: config.apis.grok.model,
     claudeAuth: false,
     openaiAuth: false,

package/src/config/defaults.ts

@@ -19,10 +19,15 @@ export const DEFAULT_CONFIG: Config = {
   },
   apis: {
     openai: {
-      model: 'gpt-4o',
+      model: 'gpt-4.1',
       temperature: 0.3,
       max_tokens: 4096,
-      available_models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'],
+      available_models: [
+        'gpt-4.1', 'gpt-4.1-mini', 'gpt-4.1-nano',
+        'o3', 'o3-mini', 'o4-mini',
+        'gpt-4o', 'gpt-4o-mini',
+        'gpt-4-turbo', 'o1-preview', 'o1-mini',
+      ],
     },
     claude: {
       model: 'claude-sonnet-4-20250514',

package/src/config/popeye-md.ts

@@ -0,0 +1,139 @@
+/**
+ * Shared popeye.md configuration reader.
+ * Reads project-local config from the YAML frontmatter in popeye.md.
+ * Used by both interactive mode and CLI commands.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { OutputLanguageSchema, type OutputLanguage } from '../types/project.js';
+import type { AIProvider, GeminiModel, GrokModel } from '../types/consensus.js';
+import type { OpenAIModel } from '../types/project.js';
+
+// ─── Types ───────────────────────────────────────────────
+
+/** Project-local configuration stored in popeye.md */
+export interface PopeyeMdConfig {
+  language: OutputLanguage;
+  reviewer: AIProvider;
+  arbitrator: AIProvider;
+  enableArbitration: boolean;
+  created: string;
+  lastRun: string;
+  projectName?: string;
+  description?: string;
+  notes?: string;
+  openaiModel?: OpenAIModel;
+  geminiModel?: GeminiModel;
+  grokModel?: GrokModel;
+}
+
+// ─── Reader ──────────────────────────────────────────────
+
+/**
+ * Read popeye.md from a project directory.
+ * Parses YAML frontmatter for project configuration.
+ *
+ * @param projectDir - Absolute path to the project root
+ * @returns Parsed config or null if file doesn't exist or is invalid
+ */
+export async function readPopeyeMdConfig(projectDir: string): Promise<PopeyeMdConfig | null> {
+  const configPath = path.join(projectDir, 'popeye.md');
+
+  try {
+    const content = await fs.readFile(configPath, 'utf-8');
+
+    // Parse YAML frontmatter
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+      return null;
+    }
+
+    const frontmatter = frontmatterMatch[1];
+    const config: Partial<PopeyeMdConfig> = {};
+
+    // Parse each line of YAML
+    for (const line of frontmatter.split('\n')) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        const [, key, value] = match;
+        const cleanValue = value.trim();
+
+        switch (key) {
+          case 'language':
+            if (OutputLanguageSchema.safeParse(cleanValue).success) {
+              config.language = cleanValue as OutputLanguage;
+            }
+            break;
+          case 'reviewer':
+            if (['openai', 'gemini', 'grok'].includes(cleanValue)) {
+              config.reviewer = cleanValue as AIProvider;
+            }
+            break;
+          case 'arbitrator':
+            if (['openai', 'gemini', 'grok', 'off'].includes(cleanValue)) {
+              if (cleanValue === 'off') {
+                config.enableArbitration = false;
+              } else {
+                config.arbitrator = cleanValue as AIProvider;
+                config.enableArbitration = true;
+              }
+            }
+            break;
+          case 'created':
+            config.created = cleanValue;
+            break;
+          case 'lastRun':
+            config.lastRun = cleanValue;
+            break;
+          case 'projectName':
+            config.projectName = cleanValue;
+            break;
+          case 'openaiModel':
+            if (cleanValue.length > 0) {
+              config.openaiModel = cleanValue;
+            }
+            break;
+          case 'geminiModel':
+            if (cleanValue.length > 0) {
+              config.geminiModel = cleanValue;
+            }
+            break;
+          case 'grokModel':
+            if (cleanValue.length > 0) {
+              config.grokModel = cleanValue;
+            }
+            break;
+        }
+      }
+    }
+
+    // Extract notes section if present
+    const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n## |$)/);
+    if (notesMatch) {
+      config.notes = notesMatch[1].trim();
+    }
+
+    // Return config only if we have the essential fields
+    if (config.language && config.reviewer) {
+      return {
+        language: config.language,
+        reviewer: config.reviewer,
+        arbitrator: config.arbitrator || 'gemini',
+        enableArbitration: config.enableArbitration ?? true,
+        created: config.created || new Date().toISOString(),
+        lastRun: config.lastRun || new Date().toISOString(),
+        projectName: config.projectName,
+        description: config.description,
+        notes: config.notes,
+        openaiModel: config.openaiModel,
+        geminiModel: config.geminiModel,
+        grokModel: config.grokModel,
+      };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/config/schema.ts

@@ -23,14 +23,17 @@ export const ConsensusSettingsSchema = z.object({
  * OpenAI API settings schema
  */
 export const OpenAISettingsSchema = z.object({
-  model: z
-    .enum(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'])
-    .default('gpt-4o'),
+  model: z.string().min(1).default('gpt-4.1'),
   temperature: z.number().min(0).max(2).default(0.3),
   max_tokens: z.number().min(100).max(32000).default(4096),
   available_models: z
     .array(z.string())
-    .default(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini']),
+    .default([
+      'gpt-4.1', 'gpt-4.1-mini', 'gpt-4.1-nano',
+      'o3', 'o3-mini', 'o4-mini',
+      'gpt-4o', 'gpt-4o-mini',
+      'gpt-4-turbo', 'o1-preview', 'o1-mini',
+    ]),
 });
 
 /**
@@ -55,10 +58,15 @@ export const GrokSettingsSchema = z.object({
  */
 export const APISettingsSchema = z.object({
   openai: OpenAISettingsSchema.default({
-    model: 'gpt-4o',
+    model: 'gpt-4.1',
     temperature: 0.3,
     max_tokens: 4096,
-    available_models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'],
+    available_models: [
+      'gpt-4.1', 'gpt-4.1-mini', 'gpt-4.1-nano',
+      'o3', 'o3-mini', 'o4-mini',
+      'gpt-4o', 'gpt-4o-mini',
+      'gpt-4-turbo', 'o1-preview', 'o1-mini',
+    ],
   }),
   claude: ClaudeSettingsSchema.default({
     model: 'claude-sonnet-4-20250514',
@@ -139,10 +147,15 @@ export const ConfigSchema = z.object({
   }),
   apis: APISettingsSchema.default({
     openai: {
-      model: 'gpt-4o',
+      model: 'gpt-4.1',
       temperature: 0.3,
       max_tokens: 4096,
-      available_models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'],
+      available_models: [
+        'gpt-4.1', 'gpt-4.1-mini', 'gpt-4.1-nano',
+        'o3', 'o3-mini', 'o4-mini',
+        'gpt-4o', 'gpt-4o-mini',
+        'gpt-4-turbo', 'o1-preview', 'o1-mini',
+      ],
     },
     claude: {
       model: 'claude-sonnet-4-20250514',