popeye-cli 1.0.1 → 1.2.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,14 @@ export interface AuthStatus {
     keyLastFour?: string;
     modelAccess?: string[];
   };
+  gemini?: {
+    authenticated: boolean;
+    keyLastFour?: string;
+  };
+  grok?: {
+    authenticated: boolean;
+    keyLastFour?: string;
+  };
 }
 
 /**

package/src/types/consensus.ts

@@ -7,7 +7,27 @@ 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' | 'grok';
+
+/**
+ * Supported Gemini models
+ */
+export type GeminiModel = 'gemini-2.0-flash' | 'gemini-1.5-pro' | 'gemini-1.5-flash';
+
+/**
+ * Grok model type (flexible string - API evolves fast)
+ */
+export type GrokModel = string;
+
+/**
+ * Default Grok model
+ */
+export const DEFAULT_GROK_MODEL = 'grok-3';
+
+/**
+ * Result of a consensus review from OpenAI or Gemini
  */
 export interface ConsensusResult {
   score: number;
@@ -19,6 +39,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 +70,77 @@ export interface ConsensusIteration {
 export interface ConsensusConfig {
   threshold: number;
   maxIterations: number;
-  openaiKey: string;
+  openaiKey?: string;
+  geminiKey?: string;
+  grokKey?: string;
   openaiModel: OpenAIModel;
+  geminiModel: GeminiModel;
+  grokModel: GrokModel;
+  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' | 'grokKey'> = {
   threshold: 95,
-  maxIterations: 5,
+  maxIterations: 10,
   openaiModel: 'gpt-4o',
+  geminiModel: 'gemini-2.0-flash',
+  grokModel: DEFAULT_GROK_MODEL,
+  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', 'grok']);
+
+/**
+ * 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 Grok model (flexible string)
+ */
+export const GrokModelSchema = z.string().default(DEFAULT_GROK_MODEL);
+
 /**
  * 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(),
+  grokKey: 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'),
+  grokModel: GrokModelSchema.default(DEFAULT_GROK_MODEL),
+  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),
@@ -114,3 +193,115 @@ export interface EscalationDetails {
   unresolvable_concerns: string[];
   suggestedActions: string[];
 }
+
+/**
+ * App target for fullstack reviews
+ */
+export type ReviewAppTarget = 'frontend' | 'backend' | 'unified';
+
+/**
+ * Tagged concern/recommendation with app context
+ */
+export interface TaggedItem {
+  app: ReviewAppTarget;
+  content: string;
+}
+
+/**
+ * Per-app consensus scores for fullstack projects
+ */
+export interface AppConsensusScores {
+  frontend?: number;
+  backend?: number;
+  unified: number;  // Combined/overall score
+}
+
+/**
+ * Per-app feedback for fullstack reviews
+ */
+export interface AppFeedback {
+  app: ReviewAppTarget;
+  score: number;
+  concerns: string[];
+  recommendations: string[];
+  analysis: string;
+}
+
+/**
+ * Fullstack-aware consensus result
+ */
+export interface FullstackConsensusResult extends ConsensusResult {
+  /** Per-app breakdown of scores */
+  appScores: AppConsensusScores;
+  /** Concerns tagged by app */
+  taggedConcerns: TaggedItem[];
+  /** Recommendations tagged by app */
+  taggedRecommendations: TaggedItem[];
+  /** Per-app feedback breakdown */
+  appFeedback: AppFeedback[];
+  /** Whether this is a fullstack project review */
+  isFullstack: boolean;
+}
+
+/**
+ * Fullstack consensus iteration with per-app tracking
+ */
+export interface FullstackConsensusIteration extends ConsensusIteration {
+  /** Per-app scores for this iteration */
+  appScores?: AppConsensusScores;
+  /** Per-app approval status */
+  appApproved?: {
+    frontend?: boolean;
+    backend?: boolean;
+    unified: boolean;
+  };
+}
+
+/**
+ * Correction/revision record for tracking all changes
+ */
+export interface CorrectionRecord {
+  id: string;
+  timestamp: string;
+  app: ReviewAppTarget;
+  previousScore: number;
+  newScore: number;
+  concerns: string[];
+  changes: string[];
+  reviewer: AIProvider;
+}
+
+/**
+ * Complete consensus tracking for a plan level (master/milestone/task)
+ */
+export interface ConsensusTrackingRecord {
+  planLevel: 'master' | 'milestone' | 'task';
+  planId: string;
+  milestoneName?: string;
+  taskName?: string;
+  isFullstack: boolean;
+
+  /** Overall consensus status */
+  overallScore: number;
+  overallApproved: boolean;
+  totalIterations: number;
+
+  /** Per-app consensus status (fullstack only) */
+  frontendScore?: number;
+  frontendApproved?: boolean;
+  frontendIterations?: number;
+
+  backendScore?: number;
+  backendApproved?: boolean;
+  backendIterations?: number;
+
+  /** All corrections/revisions made */
+  corrections: CorrectionRecord[];
+
+  /** Timestamps */
+  startedAt: string;
+  completedAt?: string;
+
+  /** Final status */
+  status: 'in-progress' | 'approved' | 'escalated' | 'failed';
+}

package/src/types/project.ts

@@ -8,9 +8,90 @@ import { z } from 'zod';
 /**
  * Supported output languages for generated projects
  */
-export const OutputLanguageSchema = z.enum(['python', 'typescript']);
+export const OutputLanguageSchema = z.enum(['python', 'typescript', 'fullstack']);
 export type OutputLanguage = z.infer<typeof OutputLanguageSchema>;
 
+/**
+ * Commands configuration for a workspace app
+ */
+export interface WorkspaceAppCommands {
+  test: string;
+  lint: string;
+  build: string;
+  dev: string;
+  typecheck?: string;
+}
+
+/**
+ * Docker configuration for a workspace app
+ */
+export interface WorkspaceAppDocker {
+  dockerfile: string;
+  imageName: string;
+  context: string;
+}
+
+/**
+ * Single app configuration in a workspace
+ */
+export interface WorkspaceApp {
+  name: string;
+  path: string;
+  language: 'python' | 'typescript';
+  commands: WorkspaceAppCommands;
+  docker?: WorkspaceAppDocker;
+  /** Dependencies on other apps or shared packages */
+  dependsOn?: string[];
+  /** Files to include as context for AI code generation */
+  contextRoots?: string[];
+  /** UI spec path (frontend only) */
+  uiSpec?: string;
+}
+
+/**
+ * Shared configuration in a workspace
+ */
+export interface WorkspaceShared {
+  /** OpenAPI spec path for contract-first development */
+  contracts?: string;
+  /** Generator command for FE client from OpenAPI */
+  contractsGenerator?: string;
+}
+
+/**
+ * Repo-level commands for workspace orchestration
+ */
+export interface WorkspaceCommands {
+  testAll: string;
+  lintAll: string;
+  buildAll: string;
+  devAll?: string;
+}
+
+/**
+ * Docker configuration at workspace level
+ */
+export interface WorkspaceDocker {
+  composePath: string;
+  /** Root-level compose for convenience symlink */
+  rootComposeSymlink?: boolean;
+}
+
+/**
+ * Workspace configuration for fullstack projects
+ */
+export interface WorkspaceConfig {
+  version: '1.0';
+  apps: {
+    frontend?: WorkspaceApp;
+    backend?: WorkspaceApp;
+  };
+  shared?: WorkspaceShared;
+  /** Repo-level commands that orchestrate across apps */
+  commands: WorkspaceCommands;
+  docker: WorkspaceDocker;
+}
+
 /**
  * Supported OpenAI models for consensus reviews
  */