popeye-cli 1.0.1 → 1.2.0

package/src/types/workflow.ts

@@ -25,6 +25,16 @@ export type ProjectStatus = z.infer<typeof ProjectStatusSchema>;
 export const TaskStatusSchema = z.enum(['pending', 'in-progress', 'complete', 'failed']);
 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
  */
@@ -36,8 +46,34 @@ 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)
+
+  // 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
  */
@@ -49,6 +85,18 @@ 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(),
+  // Per-app consensus tracking (fullstack)
+  frontendConsensus: AppConsensusTrackingSchema.optional(),
+  backendConsensus: AppConsensusTrackingSchema.optional(),
+  unifiedConsensus: AppConsensusTrackingSchema.optional(),
+  appTarget: z.enum(['frontend', 'backend', 'unified']).optional(),
 });
 
 /**
@@ -60,6 +108,29 @@ 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/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
+  };
 }
 
 /**
@@ -71,6 +142,24 @@ 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(),
+  // 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(),
 });
 
 /**
@@ -102,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,

package/src/workflow/auto-fix.ts

@@ -0,0 +1,340 @@
+/**
+ * Auto-fix module for automatically fixing build and TypeScript errors
+ * Uses Claude to analyze errors and apply fixes
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { executePrompt } from '../adapters/claude.js';
+
+/**
+ * Build error details
+ */
+export interface BuildError {
+  file: string;
+  line?: number;
+  column?: number;
+  message: string;
+  code?: string;
+}
+
+/**
+ * Auto-fix result
+ */
+export interface AutoFixResult {
+  success: boolean;
+  fixedErrors: number;
+  remainingErrors: number;
+  attempts: number;
+  fixes: Array<{
+    file: string;
+    description: string;
+  }>;
+  error?: string;
+}
+
+/**
+ * Parse TypeScript compiler errors from output
+ */
+export function parseTypeScriptErrors(output: string): BuildError[] {
+  const errors: BuildError[] = [];
+  const errorPattern = /^(.+?)\((\d+),(\d+)\): error (TS\d+): (.+)$/gm;
+
+  let match;
+  while ((match = errorPattern.exec(output)) !== null) {
+    errors.push({
+      file: match[1],
+      line: parseInt(match[2], 10),
+      column: parseInt(match[3], 10),
+      code: match[4],
+      message: match[5],
+    });
+  }
+
+  return errors;
+}
+
+/**
+ * Group errors by file for efficient fixing
+ */
+function groupErrorsByFile(errors: BuildError[]): Map<string, BuildError[]> {
+  const grouped = new Map<string, BuildError[]>();
+
+  for (const error of errors) {
+    const existing = grouped.get(error.file) || [];
+    existing.push(error);
+    grouped.set(error.file, existing);
+  }
+
+  return grouped;
+}
+
+/**
+ * Generate fix prompt for a file with errors
+ */
+function generateFixPrompt(filePath: string, fileContent: string, errors: BuildError[]): string {
+  const errorList = errors
+    .map(e => `- Line ${e.line}: ${e.code} - ${e.message}`)
+    .join('\n');
+
+  return `
+Fix the following TypeScript errors in this file. Return ONLY the complete fixed file content, no explanations.
+
+## File: ${filePath}
+
+## Errors to fix:
+${errorList}
+
+## Current file content:
+\`\`\`typescript
+${fileContent}
+\`\`\`
+
+## Instructions:
+1. Fix ALL the errors listed above
+2. Do not change any working code
+3. Preserve all imports, exports, and functionality
+4. For type-only exports (interfaces, types), use \`export type { ... }\` syntax
+5. For unused variables, either use them or prefix with underscore
+6. For missing properties, add them with appropriate default values
+7. Return ONLY the fixed TypeScript code, no markdown formatting
+
+Fixed code:
+`.trim();
+}
+
+/**
+ * Extract code from Claude's response
+ */
+function extractCodeFromResponse(response: string): string {
+  // Try to extract from code block first
+  const codeBlockMatch = response.match(/```(?:typescript|ts)?\n([\s\S]*?)\n```/);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+
+  // If no code block, assume the entire response is code
+  // But strip any leading/trailing explanation text
+  const lines = response.split('\n');
+
+  // Find first line that looks like code (import, export, const, etc.)
+  const codeStartPatterns = [
+    /^import\s/,
+    /^export\s/,
+    /^const\s/,
+    /^let\s/,
+    /^var\s/,
+    /^function\s/,
+    /^class\s/,
+    /^interface\s/,
+    /^type\s/,
+    /^\/\//,
+    /^\/\*/,
+    /^['"`]/,
+  ];
+
+  let startIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (codeStartPatterns.some(p => p.test(line))) {
+      startIndex = i;
+      break;
+    }
+  }
+
+  return lines.slice(startIndex).join('\n').trim();
+}
+
+/**
+ * Auto-fix TypeScript errors in a project
+ */
+export async function autoFixTypeScriptErrors(
+  projectDir: string,
+  buildOutput: string,
+  maxAttempts: number = 3,
+  onProgress?: (message: string) => void
+): Promise<AutoFixResult> {
+  const fixes: Array<{ file: string; description: string }> = [];
+  let attempts = 0;
+  let currentOutput = buildOutput;
+
+  while (attempts < maxAttempts) {
+    attempts++;
+    onProgress?.(`Auto-fix attempt ${attempts}/${maxAttempts}...`);
+
+    const errors = parseTypeScriptErrors(currentOutput);
+
+    if (errors.length === 0) {
+      onProgress?.('No TypeScript errors found');
+      return {
+        success: true,
+        fixedErrors: fixes.length,
+        remainingErrors: 0,
+        attempts,
+        fixes,
+      };
+    }
+
+    onProgress?.(`Found ${errors.length} TypeScript error(s) to fix`);
+
+    // Group errors by file
+    const errorsByFile = groupErrorsByFile(errors);
+    let fixedInThisAttempt = 0;
+
+    // Fix each file
+    for (const [filePath, fileErrors] of errorsByFile) {
+      const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(projectDir, filePath);
+
+      try {
+        // Read current file content
+        const fileContent = await fs.readFile(absolutePath, 'utf-8');
+
+        onProgress?.(`Fixing ${fileErrors.length} error(s) in ${path.basename(filePath)}...`);
+
+        // Generate fix prompt
+        const prompt = generateFixPrompt(filePath, fileContent, fileErrors);
+
+        // Ask Claude to fix
+        const result = await executePrompt(prompt, {
+          allowedTools: [],
+          permissionMode: 'default',
+        });
+
+        if (result.success && result.response) {
+          const fixedCode = extractCodeFromResponse(result.response);
+
+          // Validate the fix is not empty and looks like code
+          if (fixedCode.length > 100 && (fixedCode.includes('import') || fixedCode.includes('export'))) {
+            // Write fixed content
+            await fs.writeFile(absolutePath, fixedCode, 'utf-8');
+
+            fixes.push({
+              file: filePath,
+              description: `Fixed ${fileErrors.length} error(s): ${fileErrors.map(e => e.code).join(', ')}`,
+            });
+
+            fixedInThisAttempt += fileErrors.length;
+            onProgress?.(`Fixed ${path.basename(filePath)}`);
+          } else {
+            onProgress?.(`Skipped ${path.basename(filePath)} - fix doesn't look valid`);
+          }
+        } else {
+          onProgress?.(`Failed to get fix for ${path.basename(filePath)}: ${result.error}`);
+        }
+      } catch (err) {
+        onProgress?.(`Error fixing ${filePath}: ${err instanceof Error ? err.message : 'Unknown error'}`);
+      }
+    }
+
+    if (fixedInThisAttempt === 0) {
+      onProgress?.('No fixes were applied in this attempt');
+      break;
+    }
+
+    // Re-run TypeScript check to get remaining errors
+    onProgress?.('Re-checking for remaining errors...');
+    const { exec } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const execAsync = promisify(exec);
+
+    try {
+      await execAsync('npx tsc --noEmit', { cwd: projectDir });
+      currentOutput = '';
+    } catch (err: unknown) {
+      if (err && typeof err === 'object' && 'stdout' in err) {
+        currentOutput = (err as { stdout: string; stderr: string }).stdout + (err as { stdout: string; stderr: string }).stderr;
+      } else {
+        currentOutput = '';
+      }
+    }
+  }
+
+  // Final error count
+  const remainingErrors = parseTypeScriptErrors(currentOutput);
+
+  return {
+    success: remainingErrors.length === 0,
+    fixedErrors: fixes.length,
+    remainingErrors: remainingErrors.length,
+    attempts,
+    fixes,
+    error: remainingErrors.length > 0
+      ? `${remainingErrors.length} error(s) remain after ${attempts} fix attempt(s)`
+      : undefined,
+  };
+}
+
+/**
+ * Run build with auto-fix
+ */
+export async function buildWithAutoFix(
+  projectDir: string,
+  language: string,
+  maxAttempts: number = 3,
+  onProgress?: (message: string) => void
+): Promise<{ success: boolean; output: string; autoFixed: boolean }> {
+  const { exec } = await import('node:child_process');
+  const { promisify } = await import('node:util');
+  const execAsync = promisify(exec);
+
+  // Determine build command based on language
+  let buildCommand: string;
+  if (language === 'typescript' || language === 'javascript') {
+    // Check for package.json build script
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(projectDir, 'package.json'), 'utf-8'));
+      if (pkgJson.scripts?.build) {
+        buildCommand = 'npm run build';
+      } else {
+        buildCommand = 'npx tsc --noEmit';
+      }
+    } catch {
+      buildCommand = 'npx tsc --noEmit';
+    }
+  } else if (language === 'python') {
+    buildCommand = 'python -m py_compile $(find . -name "*.py" -not -path "./venv/*")';
+  } else {
+    buildCommand = 'npm run build';
+  }
+
+  // Initial build attempt
+  onProgress?.(`Running build: ${buildCommand}`);
+
+  try {
+    const { stdout, stderr } = await execAsync(buildCommand, {
+      cwd: projectDir,
+      timeout: 120000,
+    });
+    return { success: true, output: stdout + stderr, autoFixed: false };
+  } catch (err: unknown) {
+    const output = err && typeof err === 'object' && 'stdout' in err
+      ? (err as { stdout: string; stderr: string }).stdout + (err as { stdout: string; stderr: string }).stderr
+      : String(err);
+
+    onProgress?.('Build failed, attempting auto-fix...');
+
+    // Try auto-fix for TypeScript errors
+    if (language === 'typescript' || language === 'javascript') {
+      const fixResult = await autoFixTypeScriptErrors(projectDir, output, maxAttempts, onProgress);
+
+      if (fixResult.success) {
+        // Retry build after fixes
+        onProgress?.('Auto-fix successful, retrying build...');
+        try {
+          const { stdout: retryStdout, stderr: retryStderr } = await execAsync(buildCommand, {
+            cwd: projectDir,
+            timeout: 120000,
+          });
+          return { success: true, output: retryStdout + retryStderr, autoFixed: true };
+        } catch (retryErr: unknown) {
+          const retryOutput = retryErr && typeof retryErr === 'object' && 'stdout' in retryErr
+            ? (retryErr as { stdout: string; stderr: string }).stdout + (retryErr as { stdout: string; stderr: string }).stderr
+            : String(retryErr);
+          return { success: false, output: retryOutput, autoFixed: true };
+        }
+      }
+    }
+
+    return { success: false, output, autoFixed: false };
+  }
+}