popeye-cli 1.1.0 → 1.2.1

package/src/generators/typescript.ts

@@ -31,6 +31,24 @@ export interface GenerationResult {
   error?: string;
 }
 
+/**
+ * TypeScript generator options for workspace/monorepo support
+ */
+export interface TypeScriptGeneratorOptions {
+  /** Base directory for project (defaults to outputDir/projectName) */
+  baseDir?: string;
+  /** Override auto-derived package name */
+  packageName?: string;
+  /** Adjust paths for monorepo structure */
+  workspaceMode?: boolean;
+  /** Skip Docker files (fullstack uses root docker-compose) */
+  skipDocker?: boolean;
+  /** Skip README (fullstack has root README) */
+  skipReadme?: boolean;
+  /** Generate frontend project (React + Vite + Tailwind) instead of Node.js */
+  frontend?: boolean;
+}
+
 /**
  * Create a directory if it doesn't exist
  */
@@ -50,14 +68,28 @@ async function writeFile(filePath: string, content: string): Promise<void> {
  *
  * @param spec - Project specification
  * @param outputDir - Output directory
+ * @param options - Generator options for workspace/monorepo support
  * @returns Generation result
  */
 export async function generateTypeScriptProject(
   spec: ProjectSpec,
-  outputDir: string
+  outputDir: string,
+  options: TypeScriptGeneratorOptions = {}
 ): Promise<GenerationResult> {
+  const {
+    baseDir,
+    packageName: customPackageName,
+    workspaceMode = false,
+    skipDocker = false,
+    skipReadme = false,
+    // frontend option reserved for future frontend-specific generation
+  } = options;
+
   const projectName = spec.name || 'my-project';
-  const projectDir = path.join(outputDir, projectName);
+  const packageJsonName = customPackageName || projectName;
+
+  // In workspace mode with baseDir, use it directly; otherwise create subdirectory
+  const projectDir = baseDir || path.join(outputDir, projectName);
   const filesCreated: string[] = [];
 
   try {
@@ -65,15 +97,19 @@ export async function generateTypeScriptProject(
     await ensureDir(projectDir);
     await ensureDir(path.join(projectDir, 'src'));
     await ensureDir(path.join(projectDir, 'tests'));
-    await ensureDir(path.join(projectDir, 'data'));
-    await ensureDir(path.join(projectDir, 'docs'));
+
+    // Only create data/docs dirs in standalone mode
+    if (!workspaceMode) {
+      await ensureDir(path.join(projectDir, 'data'));
+      await ensureDir(path.join(projectDir, 'docs'));
+    }
 
     // Generate and write files
     const files: Array<{ path: string; content: string }> = [
       // Root files
       {
         path: path.join(projectDir, 'package.json'),
-        content: generatePackageJson(projectName, spec.idea),
+        content: generatePackageJson(packageJsonName, spec.idea),
       },
       {
         path: path.join(projectDir, 'tsconfig.json'),
@@ -99,18 +135,6 @@ export async function generateTypeScriptProject(
         path: path.join(projectDir, '.env.example'),
         content: generateEnvExample(),
       },
-      {
-        path: path.join(projectDir, 'README.md'),
-        content: generateReadme(projectName, spec.idea),
-      },
-      {
-        path: path.join(projectDir, 'Dockerfile'),
-        content: generateDockerfile(projectName),
-      },
-      {
-        path: path.join(projectDir, 'docker-compose.yml'),
-        content: generateDockerCompose(projectName),
-      },
 
       // Source files
       {
@@ -123,13 +147,37 @@ export async function generateTypeScriptProject(
         path: path.join(projectDir, 'tests', 'index.test.ts'),
         content: generateTestFile(projectName),
       },
+    ];
 
-      // Data placeholder
-      {
+    // Add README if not skipped
+    if (!skipReadme) {
+      files.push({
+        path: path.join(projectDir, 'README.md'),
+        content: generateReadme(projectName, spec.idea),
+      });
+    }
+
+    // Add Docker files if not skipped
+    if (!skipDocker) {
+      files.push(
+        {
+          path: path.join(projectDir, 'Dockerfile'),
+          content: generateDockerfile(projectName),
+        },
+        {
+          path: path.join(projectDir, 'docker-compose.yml'),
+          content: generateDockerCompose(projectName),
+        }
+      );
+    }
+
+    // Add data placeholder in standalone mode
+    if (!workspaceMode) {
+      files.push({
         path: path.join(projectDir, 'data', '.gitkeep'),
         content: '',
-      },
-    ];
+      });
+    }
 
     // Write all files
     for (const file of files) {

package/src/types/cli.ts

@@ -71,6 +71,10 @@ export interface AuthStatus {
     authenticated: boolean;
     keyLastFour?: string;
   };
+  grok?: {
+    authenticated: boolean;
+    keyLastFour?: string;
+  };
 }
 
 /**

package/src/types/consensus.ts

@@ -9,13 +9,23 @@ import type { OpenAIModel } from './project.js';
 /**
  * Supported AI providers for reviews and arbitration
  */
-export type AIProvider = 'openai' | 'gemini';
+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
  */
@@ -62,8 +72,10 @@ export interface ConsensusConfig {
   maxIterations: number;
   openaiKey?: string;
   geminiKey?: string;
+  grokKey?: string;
   openaiModel: OpenAIModel;
   geminiModel: GeminiModel;
+  grokModel: GrokModel;
   reviewer: AIProvider;
   arbitrator: AIProvider;
   enableArbitration: boolean;
@@ -81,11 +93,12 @@ export interface ConsensusConfig {
 /**
  * Default consensus configuration
  */
-export const DEFAULT_CONSENSUS_CONFIG: Omit<ConsensusConfig, 'openaiKey' | 'geminiKey'> = {
+export const DEFAULT_CONSENSUS_CONFIG: Omit<ConsensusConfig, 'openaiKey' | 'geminiKey' | 'grokKey'> = {
   threshold: 95,
   maxIterations: 10,
   openaiModel: 'gpt-4o',
   geminiModel: 'gemini-2.0-flash',
+  grokModel: DEFAULT_GROK_MODEL,
   reviewer: 'openai',
   arbitrator: 'gemini',
   enableArbitration: true,
@@ -99,13 +112,18 @@ export const DEFAULT_CONSENSUS_CONFIG: Omit<ConsensusConfig, 'openaiKey' | 'gemi
 /**
  * Zod schema for AI provider
  */
-export const AIProviderSchema = z.enum(['openai', 'gemini']);
+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
  */
@@ -114,8 +132,10 @@ export const ConsensusConfigSchema = z.object({
   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),
@@ -173,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
  */

package/src/types/workflow.ts

@@ -16,15 +16,25 @@ export type WorkflowPhase = z.infer<typeof WorkflowPhaseSchema>;
 /**
  * Project status
  */
-export const ProjectStatusSchema = z.enum(['pending', 'in-progress', 'complete', 'failed']);
+export const ProjectStatusSchema = z.enum(['pending', 'in-progress', 'complete', 'failed', 'paused']);
 export type ProjectStatus = z.infer<typeof ProjectStatusSchema>;
 
 /**
  * Status of a task or milestone
  */
-export const TaskStatusSchema = z.enum(['pending', 'in-progress', 'complete', 'failed']);
+export const TaskStatusSchema = z.enum(['pending', 'in-progress', 'complete', 'failed', 'paused']);
 export type TaskStatus = z.infer<typeof TaskStatusSchema>;
 
+/**
+ * Per-app consensus tracking (for fullstack projects)
+ */
+export interface AppConsensusTracking {
+  score?: number;
+  iterations?: number;
+  approved?: boolean;
+  feedbackDoc?: string;  // Path to app-specific feedback
+}
+
 /**
  * Individual task within a milestone
  */
@@ -44,8 +54,26 @@ export interface Task {
   planDoc?: string;                 // Path to task plan document
   testResultsDoc?: string;          // Path to test results document
   implementationComplete?: boolean; // Whether code implementation finished (for resume)
+
+  // Per-app consensus tracking (fullstack projects)
+  frontendConsensus?: AppConsensusTracking;
+  backendConsensus?: AppConsensusTracking;
+  unifiedConsensus?: AppConsensusTracking;
+
+  // App target (which app this task affects)
+  appTarget?: 'frontend' | 'backend' | 'unified';
 }
 
+/**
+ * Zod schema for per-app consensus tracking
+ */
+export const AppConsensusTrackingSchema = z.object({
+  score: z.number().optional(),
+  iterations: z.number().optional(),
+  approved: z.boolean().optional(),
+  feedbackDoc: z.string().optional(),
+});
+
 /**
  * Zod schema for Task
  */
@@ -64,6 +92,11 @@ export const TaskSchema = z.object({
   planDoc: z.string().optional(),
   testResultsDoc: z.string().optional(),
   implementationComplete: z.boolean().optional(),
+  // Per-app consensus tracking (fullstack)
+  frontendConsensus: AppConsensusTrackingSchema.optional(),
+  backendConsensus: AppConsensusTrackingSchema.optional(),
+  unifiedConsensus: AppConsensusTrackingSchema.optional(),
+  appTarget: z.enum(['frontend', 'backend', 'unified']).optional(),
 });
 
 /**
@@ -80,12 +113,24 @@ export interface Milestone {
   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
+  planDoc?: string;                 // Path: docs/plans/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
+
+  // Per-app consensus tracking (fullstack projects)
+  frontendConsensus?: AppConsensusTracking;
+  backendConsensus?: AppConsensusTracking;
+  unifiedConsensus?: AppConsensusTracking;
+
+  // Feedback document paths (fullstack - separate by app)
+  feedbackDocs?: {
+    frontend?: string;  // docs/plans/milestone-N/frontend/feedback.md
+    backend?: string;   // docs/plans/milestone-N/backend/feedback.md
+    unified?: string;   // docs/plans/milestone-N/unified/feedback.md
+  };
 }
 
 /**
@@ -106,6 +151,15 @@ export const MilestoneSchema = z.object({
   completionScore: z.number().optional(),
   completionApproved: z.boolean().optional(),
   completionDoc: z.string().optional(),
+  // Per-app consensus tracking (fullstack)
+  frontendConsensus: AppConsensusTrackingSchema.optional(),
+  backendConsensus: AppConsensusTrackingSchema.optional(),
+  unifiedConsensus: AppConsensusTrackingSchema.optional(),
+  feedbackDocs: z.object({
+    frontend: z.string().optional(),
+    backend: z.string().optional(),
+    unified: z.string().optional(),
+  }).optional(),
 });
 
 /**
@@ -137,7 +191,7 @@ export const ProjectStateSchema = z.object({
   id: z.string(),
   name: z.string(),
   idea: z.string(),
-  language: z.enum(['python', 'typescript']),
+  language: z.enum(['python', 'typescript', 'fullstack']),
   openaiModel: z.enum(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini']),
   phase: WorkflowPhaseSchema,
   status: ProjectStatusSchema,