popeye-cli 1.0.0 → 1.1.0

package/src/state/registry.ts

@@ -0,0 +1,278 @@
+/**
+ * Project Registry
+ * Tracks all Popeye projects globally and provides discovery functionality
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'os';
+import { STATE_DIR, STATE_FILE, loadState } from './persistence.js';
+
+/**
+ * Global registry directory
+ */
+const REGISTRY_DIR = path.join(homedir(), '.popeye');
+
+/**
+ * Registry file name
+ */
+const REGISTRY_FILE = 'projects.json';
+
+/**
+ * Registered project entry
+ */
+export interface RegisteredProject {
+  path: string;
+  name: string;
+  idea?: string;
+  language: string;
+  phase: string;
+  status: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * Project registry structure
+ */
+interface ProjectRegistry {
+  version: string;
+  projects: RegisteredProject[];
+}
+
+/**
+ * Get registry file path
+ */
+function getRegistryPath(): string {
+  return path.join(REGISTRY_DIR, REGISTRY_FILE);
+}
+
+/**
+ * Ensure registry directory exists
+ */
+async function ensureRegistryDir(): Promise<void> {
+  await fs.mkdir(REGISTRY_DIR, { recursive: true });
+}
+
+/**
+ * Load the project registry
+ */
+async function loadRegistry(): Promise<ProjectRegistry> {
+  try {
+    const content = await fs.readFile(getRegistryPath(), 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return { version: '1.0', projects: [] };
+  }
+}
+
+/**
+ * Save the project registry
+ */
+async function saveRegistry(registry: ProjectRegistry): Promise<void> {
+  await ensureRegistryDir();
+  const content = JSON.stringify(registry, null, 2);
+  await fs.writeFile(getRegistryPath(), content, 'utf-8');
+}
+
+/**
+ * Register a new project or update existing registration
+ */
+export async function registerProject(projectDir: string): Promise<void> {
+  const state = await loadState(projectDir);
+  if (!state) return;
+
+  const registry = await loadRegistry();
+
+  // Check if project already registered
+  const existingIndex = registry.projects.findIndex(p => p.path === projectDir);
+
+  const entry: RegisteredProject = {
+    path: projectDir,
+    name: state.name,
+    idea: state.idea?.slice(0, 200),
+    language: state.language,
+    phase: state.phase,
+    status: state.status,
+    createdAt: state.createdAt,
+    updatedAt: state.updatedAt,
+  };
+
+  if (existingIndex >= 0) {
+    registry.projects[existingIndex] = entry;
+  } else {
+    registry.projects.push(entry);
+  }
+
+  await saveRegistry(registry);
+}
+
+/**
+ * Remove a project from the registry
+ */
+export async function unregisterProject(projectDir: string): Promise<void> {
+  const registry = await loadRegistry();
+  registry.projects = registry.projects.filter(p => p.path !== projectDir);
+  await saveRegistry(registry);
+}
+
+/**
+ * Get all registered projects
+ */
+export async function getRegisteredProjects(): Promise<RegisteredProject[]> {
+  const registry = await loadRegistry();
+
+  // Verify each project still exists and update status
+  const validProjects: RegisteredProject[] = [];
+
+  for (const project of registry.projects) {
+    try {
+      const state = await loadState(project.path);
+      if (state) {
+        validProjects.push({
+          ...project,
+          phase: state.phase,
+          status: state.status,
+          updatedAt: state.updatedAt,
+        });
+      }
+    } catch {
+      // Project no longer exists, skip it
+    }
+  }
+
+  // Update registry with valid projects only
+  if (validProjects.length !== registry.projects.length) {
+    await saveRegistry({ ...registry, projects: validProjects });
+  }
+
+  // Sort by updatedAt (most recent first)
+  return validProjects.sort((a, b) =>
+    new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+  );
+}
+
+/**
+ * Scan a directory (and subdirectories) for Popeye projects
+ */
+export async function scanForProjects(
+  baseDir: string,
+  maxDepth: number = 3
+): Promise<RegisteredProject[]> {
+  const discovered: RegisteredProject[] = [];
+
+  async function scanDir(dir: string, depth: number): Promise<void> {
+    if (depth > maxDepth) return;
+
+    try {
+      // Check if this directory has a Popeye project
+      const statePath = path.join(dir, STATE_DIR, STATE_FILE);
+      try {
+        await fs.access(statePath);
+        const state = await loadState(dir);
+        if (state) {
+          discovered.push({
+            path: dir,
+            name: state.name,
+            idea: state.idea?.slice(0, 200),
+            language: state.language,
+            phase: state.phase,
+            status: state.status,
+            createdAt: state.createdAt,
+            updatedAt: state.updatedAt,
+          });
+          // Register discovered project
+          await registerProject(dir);
+        }
+      } catch {
+        // No state file in this directory
+      }
+
+      // Scan subdirectories
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+          await scanDir(path.join(dir, entry.name), depth + 1);
+        }
+      }
+    } catch {
+      // Can't read directory, skip it
+    }
+  }
+
+  await scanDir(baseDir, 0);
+
+  // Sort by updatedAt (most recent first)
+  return discovered.sort((a, b) =>
+    new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+  );
+}
+
+/**
+ * Find projects in the current directory and registered projects
+ */
+export async function discoverProjects(cwd: string): Promise<{
+  registered: RegisteredProject[];
+  discovered: RegisteredProject[];
+  all: RegisteredProject[];
+}> {
+  // Get registered projects
+  const registered = await getRegisteredProjects();
+
+  // Scan current directory for projects
+  const scanned = await scanForProjects(cwd, 2);
+
+  // Merge, avoiding duplicates
+  const registeredPaths = new Set(registered.map(p => p.path));
+  const discovered = scanned.filter(p => !registeredPaths.has(p.path));
+
+  // Combine all projects
+  const all = [...registered, ...discovered].sort((a, b) =>
+    new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+  );
+
+  return { registered, discovered, all };
+}
+
+/**
+ * Format a project for display
+ */
+export function formatProjectForDisplay(project: RegisteredProject): {
+  name: string;
+  status: string;
+  path: string;
+  lastUpdated: string;
+  age: string;
+} {
+  const now = new Date();
+  const updated = new Date(project.updatedAt);
+  const diffMs = now.getTime() - updated.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  let age: string;
+  if (diffMins < 1) {
+    age = 'just now';
+  } else if (diffMins < 60) {
+    age = `${diffMins}m ago`;
+  } else if (diffHours < 24) {
+    age = `${diffHours}h ago`;
+  } else if (diffDays < 7) {
+    age = `${diffDays}d ago`;
+  } else {
+    age = updated.toLocaleDateString();
+  }
+
+  const statusIcon = project.status === 'complete' ? '✓' :
+                     project.status === 'failed' ? '✗' :
+                     project.status === 'in-progress' ? '→' : '○';
+
+  return {
+    name: project.name,
+    status: `${statusIcon} ${project.phase}/${project.status}`,
+    path: project.path,
+    lastUpdated: updated.toISOString(),
+    age,
+  };
+}

package/src/types/cli.ts

@@ -67,6 +67,10 @@ export interface AuthStatus {
     keyLastFour?: string;
     modelAccess?: string[];
   };
+  gemini?: {
+    authenticated: boolean;
+    keyLastFour?: string;
+  };
 }
 
 /**

package/src/types/consensus.ts

@@ -7,7 +7,17 @@ import { z } from 'zod';
 import type { OpenAIModel } from './project.js';
 
 /**
- * Result of a consensus review from OpenAI
+ * Supported AI providers for reviews and arbitration
+ */
+export type AIProvider = 'openai' | 'gemini';
+
+/**
+ * Supported Gemini models
+ */
+export type GeminiModel = 'gemini-2.0-flash' | 'gemini-1.5-pro' | 'gemini-1.5-flash';
+
+/**
+ * Result of a consensus review from OpenAI or Gemini
  */
 export interface ConsensusResult {
   score: number;
@@ -19,6 +29,21 @@ export interface ConsensusResult {
   rawResponse: string;
 }
 
+/**
+ * Result of an arbitration decision
+ */
+export interface ArbitrationResult {
+  approved: boolean;
+  score: number;
+  analysis: string;
+  criticalConcerns: string[];
+  minorConcerns: string[];
+  subjectiveConcerns: string[];
+  reasoning: string;
+  suggestedChanges: string[];
+  rawResponse: string;
+}
+
 /**
  * Single consensus iteration record
  */
@@ -35,33 +60,67 @@ export interface ConsensusIteration {
 export interface ConsensusConfig {
   threshold: number;
   maxIterations: number;
-  openaiKey: string;
+  openaiKey?: string;
+  geminiKey?: string;
   openaiModel: OpenAIModel;
+  geminiModel: GeminiModel;
+  reviewer: AIProvider;
+  arbitrator: AIProvider;
+  enableArbitration: boolean;
+  arbitrationThreshold: number; // Score at which to trigger arbitration (e.g., 85)
+  stuckIterations: number; // Number of iterations without improvement before arbitration
   escalationAction: 'pause' | 'continue' | 'abort';
   temperature: number;
   maxTokens: number;
+  /** Use optimized consensus with batched feedback and file-based plan storage (default: true) */
+  useOptimizedConsensus?: boolean;
+  /** Additional reviewers beyond primary (for parallel reviews) */
+  additionalReviewers?: AIProvider[];
 }
 
 /**
  * Default consensus configuration
  */
-export const DEFAULT_CONSENSUS_CONFIG: Omit<ConsensusConfig, 'openaiKey'> = {
+export const DEFAULT_CONSENSUS_CONFIG: Omit<ConsensusConfig, 'openaiKey' | 'geminiKey'> = {
   threshold: 95,
-  maxIterations: 5,
+  maxIterations: 10,
   openaiModel: 'gpt-4o',
+  geminiModel: 'gemini-2.0-flash',
+  reviewer: 'openai',
+  arbitrator: 'gemini',
+  enableArbitration: true,
+  arbitrationThreshold: 85,
+  stuckIterations: 3,
   escalationAction: 'pause',
   temperature: 0.3,
   maxTokens: 4096,
 };
 
+/**
+ * Zod schema for AI provider
+ */
+export const AIProviderSchema = z.enum(['openai', 'gemini']);
+
+/**
+ * Zod schema for Gemini model
+ */
+export const GeminiModelSchema = z.enum(['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash']);
+
 /**
  * Zod schema for consensus config validation
  */
 export const ConsensusConfigSchema = z.object({
   threshold: z.number().min(0).max(100).default(95),
-  maxIterations: z.number().min(1).max(10).default(5),
-  openaiKey: z.string().min(1),
+  maxIterations: z.number().min(1).max(20).default(10),
+  openaiKey: z.string().optional(),
+  geminiKey: z.string().optional(),
   openaiModel: z.enum(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini']),
+  geminiModel: GeminiModelSchema.default('gemini-2.0-flash'),
+  reviewer: AIProviderSchema.default('openai'),
+  arbitrator: AIProviderSchema.default('gemini'),
+  enableArbitration: z.boolean().default(true),
+  arbitrationThreshold: z.number().min(0).max(100).default(85),
+  stuckIterations: z.number().min(1).max(10).default(3),
   escalationAction: z.enum(['pause', 'continue', 'abort']).default('pause'),
   temperature: z.number().min(0).max(2).default(0.3),
   maxTokens: z.number().min(100).max(32000).default(4096),

package/src/types/workflow.ts

@@ -36,6 +36,14 @@ export interface Task {
   testsPassed?: boolean;
   testPlan?: string;
   error?: string;
+  // Per-task consensus tracking
+  plan?: string;                    // Detailed task implementation plan
+  consensusScore?: number;          // Consensus score for task plan (0-100)
+  consensusIterations?: number;     // Number of iterations to reach consensus
+  consensusApproved?: boolean;      // Whether task plan was approved
+  planDoc?: string;                 // Path to task plan document
+  testResultsDoc?: string;          // Path to test results document
+  implementationComplete?: boolean; // Whether code implementation finished (for resume)
 }
 
 /**
@@ -49,6 +57,13 @@ export const TaskSchema = z.object({
   testsPassed: z.boolean().optional(),
   testPlan: z.string().optional(),
   error: z.string().optional(),
+  plan: z.string().optional(),
+  consensusScore: z.number().optional(),
+  consensusIterations: z.number().optional(),
+  consensusApproved: z.boolean().optional(),
+  planDoc: z.string().optional(),
+  testResultsDoc: z.string().optional(),
+  implementationComplete: z.boolean().optional(),
 });
 
 /**
@@ -60,6 +75,17 @@ export interface Milestone {
   description: string;
   status: TaskStatus;
   tasks: Task[];
+  // Per-milestone consensus tracking
+  plan?: string;                    // Detailed milestone plan
+  consensusScore?: number;          // Consensus score for milestone plan
+  consensusIterations?: number;     // Number of iterations to reach consensus
+  consensusApproved?: boolean;      // Whether milestone plan was approved
+  planDoc?: string;                 // Path: docs/milestone_N_plan.md
+  // Milestone completion review
+  completionReview?: string;        // Code review and summary
+  completionScore?: number;         // Consensus score for completion
+  completionApproved?: boolean;     // Whether milestone completion was approved
+  completionDoc?: string;           // Path: docs/milestone_N_complete.md
 }
 
 /**
@@ -71,6 +97,15 @@ export const MilestoneSchema = z.object({
   description: z.string(),
   status: TaskStatusSchema,
   tasks: z.array(TaskSchema),
+  plan: z.string().optional(),
+  consensusScore: z.number().optional(),
+  consensusIterations: z.number().optional(),
+  consensusApproved: z.boolean().optional(),
+  planDoc: z.string().optional(),
+  completionReview: z.string().optional(),
+  completionScore: z.number().optional(),
+  completionApproved: z.boolean().optional(),
+  completionDoc: z.string().optional(),
 });
 
 /**