popeye-cli 1.4.1 → 1.4.3

package/src/workflow/task-workflow.ts

@@ -14,7 +14,7 @@ import {
   updateState,
 } from '../state/index.js';
 import { iterateUntilConsensus, runOptimizedConsensusProcess, type ConsensusProcessResult } from './consensus.js';
-import { executeTask as executeTaskCode } from './execution-mode.js';
+import { executeTask as executeTaskCode, handleTestFailure } from './execution-mode.js';
 import { runTests, testsExist, getTestSummary, type TestResult } from './test-runner.js';
 
 /**
@@ -224,6 +224,119 @@ async function updateTaskInState(
   return updateState(projectDir, { milestones: updatedMilestones });
 }
 
+/**
+ * Detect if the failure is a test runner crash (0 passed, many failed)
+ * vs actual individual test failures
+ */
+function isTestRunnerCrash(testResult: TestResult): boolean {
+  return testResult.passed === 0 && testResult.failed > 20;
+}
+
+/**
+ * Detect which app a task targets from its name (e.g., "[BE]", "[FE]", "[WEB]")
+ */
+function detectTaskApp(taskName: string): string | null {
+  if (taskName.includes('[BE]') || taskName.toLowerCase().includes('backend')) return 'backend';
+  if (taskName.includes('[FE]') || taskName.toLowerCase().includes('frontend')) return 'frontend';
+  if (taskName.includes('[WEB]') || taskName.toLowerCase().includes('website')) return 'website';
+  return null;
+}
+
+/**
+ * Build a fix plan for test failures that can be reviewed by consensus
+ *
+ * @param task - The task whose tests failed
+ * @param testResult - The test result with failure details
+ * @param state - Current project state
+ * @returns A plan string describing the proposed fix
+ */
+function buildTestFixPlan(
+  task: Task,
+  testResult: TestResult,
+  state: ProjectState,
+): string {
+  const isCrash = isTestRunnerCrash(testResult);
+  const targetApp = detectTaskApp(task.name);
+
+  // For crashes, extract the first error (usually the root cause)
+  const outputSnippet = isCrash
+    ? testResult.output.slice(0, 3000)
+    : testResult.output.slice(0, 2000);
+
+  if (isCrash) {
+    return `## Test Runner Crash - Fix Plan
+
+### Task: ${task.name}
+### Language: ${state.language}
+${targetApp ? `### Target App: ${targetApp}` : ''}
+
+### CRITICAL: Test Runner Crashed
+The test runner crashed with 0 passed out of ${testResult.failed} total tests.
+This is NOT ${testResult.failed} individual failures - this is a **startup/import crash**.
+
+### Most Likely Root Causes (check in this order)
+1. **Import error** - A new file imports a module that doesn't exist or has a typo
+2. **Syntax error** - A new or modified file has invalid syntax
+3. **Missing dependency** - A package is used but not installed
+4. **Circular import** - New code creates a circular dependency
+5. **Config error** - Test config (vitest.config, jest.config, pytest.ini) was broken
+
+### Test Output (look for the FIRST error)
+\`\`\`
+${outputSnippet}
+\`\`\`
+
+### Fix Approach
+1. Find the FIRST error in the output above - that's the root cause
+2. Fix that single error (likely a broken import or syntax issue)
+3. Do NOT try to fix ${testResult.failed} individual tests - they all fail because of the one root cause
+${targetApp ? `4. Focus ONLY on files in the apps/${targetApp}/ directory` : ''}
+
+### Review Checklist
+- [ ] Identified the single root cause (import/syntax/config error)
+- [ ] Fix targets the root cause, not symptoms
+- [ ] No unrelated code changes
+`;
+  }
+
+  // Normal case: individual test failures
+  const failedTests = testResult.failedTests?.map(t => `- ${t}`).join('\n') || '(see output)';
+
+  return `## Test Failure Fix Plan
+
+### Task: ${task.name}
+### Language: ${state.language}
+${targetApp ? `### Target App: ${targetApp}` : ''}
+
+### Test Results
+- Passed: ${testResult.passed}
+- Failed: ${testResult.failed}
+- Total: ${testResult.total}
+
+### Failed Tests
+${failedTests}
+
+### Test Output (truncated)
+\`\`\`
+${outputSnippet}
+\`\`\`
+
+### Proposed Fix Approach
+1. Analyze the root cause of each test failure from the output above
+2. Identify whether the issue is in the implementation code (most likely) or the test expectations
+3. Fix the implementation code to satisfy the test assertions
+4. Do NOT modify the tests unless they contain clear bugs
+5. Ensure fixes don't break other passing tests
+${targetApp ? `6. Focus ONLY on files in the apps/${targetApp}/ directory` : ''}
+
+### Review Checklist
+- [ ] Root cause correctly identified for each failure
+- [ ] Fix addresses the actual problem, not just the symptom
+- [ ] No regressions introduced to passing tests
+- [ ] Code changes are minimal and focused
+`;
+}
+
 /**
  * Run the complete task workflow: Plan → Consensus → Implement → Test
  *
@@ -486,11 +599,131 @@ Task: ${task.name}
           break;
         }
 
+        // Build failure reason for visibility
+        const isCrash = isTestRunnerCrash(testResult);
+        let failureReason: string;
+
+        if (isCrash) {
+          // Extract first meaningful error line from output
+          const errorLines = testResult.output.split('\n')
+            .filter(l => /error|Error|ERROR|failed to|cannot find|SyntaxError|ImportError|ModuleNotFound/i.test(l))
+            .slice(0, 2);
+          const rootCause = errorLines.length > 0
+            ? errorLines[0].trim().slice(0, 120)
+            : 'test runner crashed';
+          failureReason = `TEST RUNNER CRASH (0/${testResult.failed} passed) - ${rootCause}`;
+        } else {
+          const failedNames = testResult.failedTests?.slice(0, 5).join(', ') || '';
+          failureReason = failedNames
+            ? `${testResult.failed} failed: ${failedNames}${(testResult.failedTests?.length || 0) > 5 ? '...' : ''}`
+            : testResult.error || getTestSummary(testResult);
+        }
+
+        // Tests failed - check if retries exhausted
+        if (retries >= maxRetries) {
+          onProgress?.('task-test', `Tests failed after ${retries} retries (${failureReason})`);
+          break;
+        }
+
         retries++;
-        if (retries <= maxRetries) {
-          onProgress?.('task-test', `Tests failed, retry ${retries}/${maxRetries}...`);
-          // Could add fix attempt here
+        onProgress?.('task-test', `Tests failed (${failureReason}), planning fix ${retries}/${maxRetries}...`);
+
+        // Build a fix plan and get consensus before implementing
+        const fixPlan = buildTestFixPlan(task, testResult, state);
+        const fixContext = `
+Project: ${state.name}
+Language: ${state.language}
+Milestone: ${milestone.name}
+Task: ${task.name}
+Phase: Test failure fix (attempt ${retries}/${maxRetries})
+`.trim();
+
+        const useOptimized = consensusConfig?.useOptimizedConsensus !== false;
+        let fixConsensus: ConsensusProcessResult;
+
+        if (useOptimized) {
+          onProgress?.('task-test', `Getting consensus on fix plan (attempt ${retries}/${maxRetries})...`);
+          fixConsensus = await runOptimizedConsensusProcess(
+            fixPlan,
+            fixContext,
+            {
+              projectDir,
+              config: consensusConfig,
+              milestoneId: milestone.id,
+              milestoneName: milestone.name,
+              taskId: task.id,
+              taskName: `${task.name} - Test Fix ${retries}`,
+              parallelReviews: true,
+              isFullstack: isWorkspace(state.language),
+              onIteration: (iteration, result) => {
+                onProgress?.('task-test', `Fix consensus iteration ${iteration}: ${result.score}%`);
+              },
+              onProgress,
+            }
+          );
+        } else {
+          onProgress?.('task-test', `Getting consensus on fix plan (attempt ${retries}/${maxRetries})...`);
+          fixConsensus = await iterateUntilConsensus(
+            fixPlan,
+            fixContext,
+            {
+              projectDir,
+              config: consensusConfig,
+              isFullstack: isWorkspace(state.language),
+              language: state.language,
+              onIteration: (iteration, result) => {
+                onProgress?.('task-test', `Fix consensus iteration ${iteration}: ${result.score}%`);
+              },
+              onProgress,
+            }
+          );
         }
+
+        if (!fixConsensus.approved) {
+          onProgress?.('task-test', `Fix plan not approved (${fixConsensus.finalScore}%), skipping fix`);
+          break;
+        }
+
+        onProgress?.('task-test', `Fix plan approved (${fixConsensus.finalScore}%), implementing fix...`);
+
+        // Implement the consensus-approved fix
+        const fixResult = await handleTestFailure(
+          task,
+          testResult,
+          fixConsensus.bestPlan,
+          projectDir,
+          (msg) => onProgress?.('task-test', msg),
+        );
+
+        if (!fixResult.success) {
+          // Check if this is a rate limit pause (not a real failure)
+          if (fixResult.rateLimitPaused) {
+            const resetInfo = fixResult.rateLimitInfo;
+            const pauseMessage = resetInfo?.message || 'Rate limit reached';
+
+            state = await updateTaskInState(projectDir, task.id, {
+              status: 'paused',
+              error: `Rate limit during test fix: ${pauseMessage}. Run /resume to continue.`,
+            });
+
+            onProgress?.('task-test', `Test fix paused due to rate limit: ${pauseMessage}`);
+            onProgress?.('task-test', 'Your progress is saved. Run /resume to continue after the rate limit resets.');
+
+            return {
+              success: false,
+              task: { ...task, status: 'paused' },
+              consensusResult,
+              testResult,
+              rateLimitPaused: true,
+              error: `Rate limit: ${pauseMessage}`,
+            };
+          }
+
+          onProgress?.('task-test', `Fix attempt ${retries} failed: ${fixResult.error || 'unknown error'}`);
+          break;
+        }
+
+        onProgress?.('task-test', `Fix ${retries} applied, re-running tests...`);
       }
 
       if (testResult && !testResult.success) {

package/src/workflow/ui-setup.ts

@@ -418,10 +418,11 @@ export async function setupUI(
     theme?: string;
     projectType?: string;
     idea?: string;
+    frontendDir?: string;
   } = {},
   onProgress?: (message: string) => void
 ): Promise<UISetupResult> {
-  const frontendDir = path.join(projectDir, 'packages', 'frontend');
+  const frontendDir = options.frontendDir || path.join(projectDir, 'packages', 'frontend');
   const componentsInstalled: string[] = [];
 
   try {

package/tests/workflow/auto-fix-enhanced.test.ts

@@ -0,0 +1,351 @@
+/**
+ * Tests for enhanced auto-fix: ENOENT detection, path parsing, structural issue heuristic
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { parseErrorFilePaths, analyzeFileExistence } from '../../src/workflow/execution-mode.js';
+import { parseTypeScriptErrors } from '../../src/workflow/auto-fix.js';
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-autofix-'));
+});
+
+afterEach(async () => {
+  await fs.rm(tempDir, { recursive: true, force: true });
+});
+
+describe('parseErrorFilePaths', () => {
+  it('should extract paths from TS format: path(line,col): error TS', () => {
+    const output = `src/index.ts(10,5): error TS2304: Cannot find name 'foo'
+src/utils.ts(25,12): error TS2339: Property 'bar' does not exist`;
+
+    const paths = parseErrorFilePaths(output);
+
+    expect(paths).toContain('src/index.ts');
+    expect(paths).toContain('src/utils.ts');
+    expect(paths).toHaveLength(2);
+  });
+
+  it('should extract paths from generic format: path:line:col - error TS', () => {
+    const output = `src/app.tsx:15:3 - error TS2322: Type 'string' is not assignable
+src/components/Button.tsx:8:1 - error TS2307: Cannot find module`;
+
+    const paths = parseErrorFilePaths(output);
+
+    expect(paths).toContain('src/app.tsx');
+    expect(paths).toContain('src/components/Button.tsx');
+    expect(paths).toHaveLength(2);
+  });
+
+  it('should normalize Windows backslashes to forward slashes', () => {
+    const output = `src\\components\\Header.tsx(5,10): error TS2304: Cannot find name 'x'`;
+
+    const paths = parseErrorFilePaths(output);
+
+    expect(paths).toContain('src/components/Header.tsx');
+  });
+
+  it('should strip ANSI color codes before parsing', () => {
+    const output = `\x1b[31msrc/index.ts\x1b[0m(10,5): error TS2304: Cannot find name 'foo'`;
+
+    const paths = parseErrorFilePaths(output);
+
+    expect(paths).toContain('src/index.ts');
+  });
+
+  it('should filter out virtual/non-project paths', () => {
+    const output = `src/index.ts(10,5): error TS2304: Cannot find name 'foo'
+node_modules/@types/react/index.d.ts(100,1): error TS2300: Duplicate identifier
+../node_modules/vite/dist/node/index.d.ts(50,1): error TS2300: Duplicate`;
+
+    const paths = parseErrorFilePaths(output);
+
+    expect(paths).toContain('src/index.ts');
+    // node_modules and vite paths should be filtered
+    expect(paths).not.toContain('node_modules/@types/react/index.d.ts');
+    expect(paths).toHaveLength(1);
+  });
+
+  it('should de-duplicate paths after normalization', () => {
+    const output = `src/index.ts(10,5): error TS2304: Cannot find name 'foo'
+src/index.ts(15,1): error TS2339: Property 'bar' does not exist
+src/index.ts(20,3): error TS2322: Type mismatch`;
+
+    const paths = parseErrorFilePaths(output);
+
+    expect(paths).toContain('src/index.ts');
+    expect(paths).toHaveLength(1);
+  });
+
+  it('should handle ERROR in prefix wrappers', () => {
+    const output = `ERROR in src/app.ts(5,10): error TS2304: Cannot find name 'x'`;
+
+    const paths = parseErrorFilePaths(output);
+
+    expect(paths).toContain('src/app.ts');
+  });
+
+  it('should handle apps/ and packages/ prefixed paths', () => {
+    const output = `apps/frontend/src/App.tsx(10,5): error TS2304: Cannot find name 'foo'
+packages/shared/src/types.ts(5,1): error TS2307: Cannot find module`;
+
+    const paths = parseErrorFilePaths(output);
+
+    expect(paths).toContain('apps/frontend/src/App.tsx');
+    expect(paths).toContain('packages/shared/src/types.ts');
+    expect(paths).toHaveLength(2);
+  });
+
+  it('should return empty array for non-TS error output', () => {
+    const output = 'npm ERR! code ELIFECYCLE\nnpm ERR! errno 1';
+
+    const paths = parseErrorFilePaths(output);
+
+    expect(paths).toHaveLength(0);
+  });
+});
+
+describe('analyzeFileExistence', () => {
+  it('should correctly identify existing and missing files', async () => {
+    // Create some files
+    await fs.mkdir(path.join(tempDir, 'src'), { recursive: true });
+    await fs.writeFile(path.join(tempDir, 'src', 'index.ts'), 'export {}');
+
+    const result = await analyzeFileExistence(tempDir, [
+      'src/index.ts',       // exists
+      'src/missing.ts',     // does not exist
+    ]);
+
+    expect(result.existing).toContain('src/index.ts');
+    expect(result.missing).toContain('src/missing.ts');
+    expect(result.existing).toHaveLength(1);
+    expect(result.missing).toHaveLength(1);
+    expect(result.summary).toContain('1/2 error files exist');
+    expect(result.summary).toContain('1/2 MISSING');
+  });
+
+  it('should handle absolute paths correctly', async () => {
+    await fs.mkdir(path.join(tempDir, 'src'), { recursive: true });
+    await fs.writeFile(path.join(tempDir, 'src', 'app.ts'), 'export {}');
+
+    const absolutePath = path.join(tempDir, 'src', 'app.ts');
+    const result = await analyzeFileExistence(tempDir, [absolutePath]);
+
+    expect(result.existing).toContain(absolutePath);
+    expect(result.missing).toHaveLength(0);
+  });
+
+  it('should handle empty file list', async () => {
+    const result = await analyzeFileExistence(tempDir, []);
+
+    expect(result.existing).toHaveLength(0);
+    expect(result.missing).toHaveLength(0);
+    expect(result.summary).toBe('No error files to check');
+  });
+
+  it('should report all missing when no files exist', async () => {
+    const result = await analyzeFileExistence(tempDir, [
+      'src/a.ts',
+      'src/b.ts',
+      'src/c.ts',
+    ]);
+
+    expect(result.existing).toHaveLength(0);
+    expect(result.missing).toHaveLength(3);
+    expect(result.summary).toContain('0/3 error files exist');
+    expect(result.summary).toContain('3/3 MISSING');
+  });
+});
+
+describe('structural issue heuristic', () => {
+  it('should flag structural issue when >50% of files are missing', () => {
+    // Testing the heuristic logic directly
+    const missingFileCount = 6;
+    const totalErrorFiles = 10;
+
+    const isStructuralIssue = totalErrorFiles > 0 && (
+      (missingFileCount / totalErrorFiles >= 0.5) ||
+      (missingFileCount >= 25)
+    );
+
+    expect(isStructuralIssue).toBe(true);
+  });
+
+  it('should flag structural issue when >=25 missing even if <50%', () => {
+    const missingFileCount = 25;
+    const totalErrorFiles = 100;
+
+    const isStructuralIssue = totalErrorFiles > 0 && (
+      (missingFileCount / totalErrorFiles >= 0.5) ||
+      (missingFileCount >= 25)
+    );
+
+    expect(isStructuralIssue).toBe(true);
+  });
+
+  it('should NOT flag structural issue when all files are accessible', () => {
+    const missingFileCount = 0;
+    const totalErrorFiles = 50;
+
+    const isStructuralIssue = totalErrorFiles > 0 && (
+      (missingFileCount / totalErrorFiles >= 0.5) ||
+      (missingFileCount >= 25)
+    );
+
+    expect(isStructuralIssue).toBe(false);
+  });
+
+  it('should NOT flag structural issue when few files are missing (<50% and <25)', () => {
+    const missingFileCount = 3;
+    const totalErrorFiles = 20;
+
+    const isStructuralIssue = totalErrorFiles > 0 && (
+      (missingFileCount / totalErrorFiles >= 0.5) ||
+      (missingFileCount >= 25)
+    );
+
+    expect(isStructuralIssue).toBe(false);
+  });
+
+  it('should NOT flag structural issue when there are no error files', () => {
+    const missingFileCount = 0;
+    const totalErrorFiles = 0;
+
+    const isStructuralIssue = totalErrorFiles > 0 && (
+      (missingFileCount / totalErrorFiles >= 0.5) ||
+      (missingFileCount >= 25)
+    );
+
+    expect(isStructuralIssue).toBe(false);
+  });
+});
+
+describe('parseTypeScriptErrors', () => {
+  it('should parse tsc direct format: path(line,col): error TS', () => {
+    const output = `src/index.ts(10,5): error TS2304: Cannot find name 'foo'
+src/utils.ts(25,12): error TS2339: Property 'bar' does not exist`;
+
+    const errors = parseTypeScriptErrors(output);
+
+    expect(errors).toHaveLength(2);
+    expect(errors[0]).toEqual({
+      file: 'src/index.ts',
+      line: 10,
+      column: 5,
+      code: 'TS2304',
+      message: "Cannot find name 'foo'",
+    });
+    expect(errors[1]).toEqual({
+      file: 'src/utils.ts',
+      line: 25,
+      column: 12,
+      code: 'TS2339',
+      message: "Property 'bar' does not exist",
+    });
+  });
+
+  it('should parse bundler format: path:line:col - error TS', () => {
+    const output = `src/App.tsx:5:3 - error TS2304: Cannot find name 'Component'
+src/pages/Home.tsx:15:10 - error TS2322: Type 'string' is not assignable to type 'number'`;
+
+    const errors = parseTypeScriptErrors(output);
+
+    expect(errors).toHaveLength(2);
+    expect(errors[0]).toEqual({
+      file: 'src/App.tsx',
+      line: 5,
+      column: 3,
+      code: 'TS2304',
+      message: "Cannot find name 'Component'",
+    });
+    expect(errors[1]).toEqual({
+      file: 'src/pages/Home.tsx',
+      line: 15,
+      column: 10,
+      code: 'TS2322',
+      message: "Type 'string' is not assignable to type 'number'",
+    });
+  });
+
+  it('should parse mixed formats and de-duplicate', () => {
+    const output = `src/index.ts(10,5): error TS2304: Cannot find name 'foo'
+src/index.ts:10:5 - error TS2304: Cannot find name 'foo'
+src/utils.ts:3:1 - error TS2307: Cannot find module './missing'`;
+
+    const errors = parseTypeScriptErrors(output);
+
+    // First two are the same error in different formats - should be de-duped
+    expect(errors).toHaveLength(2);
+    expect(errors[0].file).toBe('src/index.ts');
+    expect(errors[1].file).toBe('src/utils.ts');
+  });
+
+  it('should strip ANSI color codes before parsing', () => {
+    const output = `\x1b[31msrc/index.ts\x1b[0m(10,5): error TS2304: Cannot find name 'foo'
+\x1b[36msrc/App.tsx\x1b[0m:5:3 - error TS2322: Type mismatch`;
+
+    const errors = parseTypeScriptErrors(output);
+
+    expect(errors).toHaveLength(2);
+    expect(errors[0].file).toBe('src/index.ts');
+    expect(errors[0].code).toBe('TS2304');
+    expect(errors[1].file).toBe('src/App.tsx');
+    expect(errors[1].code).toBe('TS2322');
+  });
+
+  it('should return empty array for non-TS error output', () => {
+    const output = `npm ERR! code ELIFECYCLE
+npm ERR! errno 1
+npm ERR! project@1.0.0 build: vite build
+npm ERR! Exit status 1`;
+
+    const errors = parseTypeScriptErrors(output);
+
+    expect(errors).toHaveLength(0);
+  });
+
+  it('should return empty array for empty output', () => {
+    expect(parseTypeScriptErrors('')).toHaveLength(0);
+  });
+});
+
+describe('autoFixTypeScriptErrors false success prevention', () => {
+  it('should return success: false when zero errors parsed on first attempt', () => {
+    // Simulating the logic from autoFixTypeScriptErrors
+    const attempts = 1;
+    const fixes: Array<{ file: string; description: string }> = [];
+
+    // Build failed but parseTypeScriptErrors returned 0 errors (unparseable format)
+    const errorsLength = 0;
+
+    // This is the logic under test
+    const noParsedOnFirstAttempt = attempts === 1 && fixes.length === 0;
+
+    if (errorsLength === 0 && noParsedOnFirstAttempt) {
+      // Should NOT return success: true
+      expect(noParsedOnFirstAttempt).toBe(true);
+    }
+  });
+
+  it('should return success: true when zero errors after prior fixes', () => {
+    // After fixing files, tsc --noEmit returns 0 errors = genuinely fixed
+    const attempts = 2;
+    const fixes = [{ file: 'src/index.ts', description: 'Fixed 1 error' }];
+
+    const errorsLength = 0;
+    const noParsedOnFirstAttempt = attempts === 1 && fixes.length === 0;
+
+    // Should NOT trigger the false-success guard
+    expect(noParsedOnFirstAttempt).toBe(false);
+
+    // So the function would return success: true (correct behavior)
+    if (errorsLength === 0 && !noParsedOnFirstAttempt) {
+      expect(true).toBe(true); // Reaches the success: true branch
+    }
+  });
+});