@jojonax/codex-copilot 1.2.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jojonax/codex-copilot",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "PRD-driven automated development orchestrator for CodeX / Cursor",
   "bin": {
     "codex-copilot": "./bin/cli.js"

package/src/commands/run.js

@@ -10,7 +10,7 @@ import { resolve } from 'path';
 import { log, progressBar } from '../utils/logger.js';
 import { git } from '../utils/git.js';
 import { github } from '../utils/github.js';
-import { ask, closePrompt } from '../utils/prompt.js';
+import { closePrompt } from '../utils/prompt.js';
 import { createCheckpoint } from '../utils/checkpoint.js';
 import { provider } from '../utils/provider.js';
 
@@ -162,6 +162,18 @@ export async function run(projectDir) {
       log.dim('⏩ Skipping merge phase (already merged)');
     }
 
+    // Check if task was blocked during review/merge
+    if (task.status === 'blocked') {
+      writeJSON(tasksPath, tasks);
+      log.blank();
+      log.warn(`⚠ Task #${task.id} is blocked — needs manual intervention`);
+      log.blank();
+      const done = tasks.tasks.filter(t => t.status === 'completed').length;
+      const blocked = tasks.tasks.filter(t => t.status === 'blocked').length;
+      progressBar(done, tasks.total, `${done}/${tasks.total} done, ${blocked} blocked`);
+      continue;
+    }
+
     // Mark task complete
     task.status = 'completed';
     writeJSON(tasksPath, tasks);
@@ -282,7 +294,9 @@ async function prPhase(projectDir, task, baseBranch, checkpoint) {
 // Phase 3: Review loop
 // ──────────────────────────────────────────────
 async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pollInterval, waitTimeout }, checkpoint, providerId) {
-  let maxRounds = _maxRounds;
+  const HARD_MAX_ROUNDS = 5;
+  const MAX_POLL_RETRIES = 3;
+  let maxRounds = Math.min(_maxRounds, HARD_MAX_ROUNDS);
   log.step('Phase 3/4: Waiting for review');
 
   // Resume from saved review round
@@ -291,6 +305,8 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
     ? state.review_round
     : 1;
 
+  let pollRetries = 0;
+
   for (let round = startRound; round <= maxRounds; round++) {
     // Step: Waiting for review
     checkpoint.saveStep(task.id, 'review', 'waiting_review', {
@@ -299,40 +315,38 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
       review_round: round,
     });
 
-    log.info(`Waiting for review feedback... (timeout: ${waitTimeout}s)`);
-
-    // When resuming from waiting_review, the review may have already arrived
-    // before the restart. Check for existing reviews first before polling.
-    const isResuming = (state.current_task === task.id && state.phase === 'review'
-      && state.phase_step === 'waiting_review' && round === startRound);
-
-    let gotReview;
-    if (isResuming) {
-      const existingReviews = github.getReviews(projectDir, prInfo.number);
-      const existingComments = github.getIssueComments(projectDir, prInfo.number);
-      const hasReview = existingReviews.some(r => r.state !== 'PENDING');
-      const hasBotComment = existingComments.some(c =>
-        c.user?.type === 'Bot' || c.user?.login?.includes('bot')
-      );
-      if (hasReview || hasBotComment) {
-        log.info('Found existing review — processing immediately');
-        gotReview = true;
-      } else {
-        gotReview = await waitForReview(projectDir, prInfo.number, pollInterval, waitTimeout);
-      }
+    log.info('Checking for review feedback...');
+
+    // Always proactively check for existing reviews first.
+    let gotReview = false;
+    const existingReviews = github.getReviews(projectDir, prInfo.number);
+    const existingComments = github.getIssueComments(projectDir, prInfo.number);
+    const hasReview = existingReviews.some(r => r.state !== 'PENDING');
+    const hasBotComment = existingComments.some(c =>
+      c.user?.type === 'Bot' || c.user?.login?.includes('bot')
+    );
+
+    if (hasReview || hasBotComment) {
+      log.info('Review found — processing immediately');
+      gotReview = true;
     } else {
+      // No reviews yet — enter polling mode
+      log.info(`No review yet, polling... (timeout: ${waitTimeout}s)`);
       gotReview = await waitForReview(projectDir, prInfo.number, pollInterval, waitTimeout);
     }
 
     if (!gotReview) {
-      log.warn('Review wait timed out');
-      const action = await ask('Enter "skip" (skip review) or "wait" (keep waiting):');
-      if (action === 'wait') {
-        round--;
-        continue;
+      pollRetries++;
+      if (pollRetries >= MAX_POLL_RETRIES) {
+        log.error(`Review polling timed out ${MAX_POLL_RETRIES} times — marking task as blocked`);
+        task.status = 'blocked';
+        return;
       }
-      break;
+      log.warn(`Review wait timed out — auto-retrying (${pollRetries}/${MAX_POLL_RETRIES})...`);
+      round--; // retry same round
+      continue;
     }
+    pollRetries = 0; // reset on success
 
     // Step: Feedback received
     checkpoint.saveStep(task.id, 'review', 'feedback_received', {
@@ -373,40 +387,37 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
       const hasInlineComments = inlineComments && inlineComments.length > 0;
 
       if (reviewState === 'CHANGES_REQUESTED') {
-        // Explicit change request — always treat as needing fixes
         log.info('Review state: CHANGES_REQUESTED — entering fix phase');
       } else if (reviewState === 'COMMENTED' && !hasInlineComments) {
-        // General comment with no code-level feedback — treat as passing
         log.info('COMMENTED with no inline code comments — treating as passed ✅');
         return;
       } else if (!hasInlineComments) {
-        // Any other state (PENDING, null, etc.) with no inline comments — treat as passing
         log.info('No inline code comments found — treating as passed ✅');
         return;
       } else {
-        // Has inline comments — treat as needing fixes
         log.info(`Found ${inlineComments.length} inline code comment(s) — entering fix phase`);
       }
     }
 
     // AI says FIX, or structural fallback indicates issues
-
     log.blank();
     log.warn(`Received review feedback (round ${round}/${maxRounds})`);
 
     if (round >= maxRounds) {
-      log.warn(`Max fix rounds reached (${maxRounds})`);
-      const choice = await ask('Enter "merge" (force merge) / "fix" (one more round) / "skip" (skip):');
-      if (choice === 'fix') {
+      if (maxRounds < HARD_MAX_ROUNDS) {
+        // Auto-extend: give it one more round
         maxRounds++;
-      } else if (choice === 'skip') {
-        return;
+        log.warn(`Auto-extending fix rounds to ${maxRounds}`);
       } else {
-        return; // merge
+        // Hard limit reached — cannot keep fixing forever
+        log.error(`Hard limit of ${HARD_MAX_ROUNDS} fix rounds reached — marking task as blocked`);
+        log.error('This task needs manual intervention to resolve review issues');
+        task.status = 'blocked';
+        return;
       }
     }
 
-    // Let AI fix
+    // Let AI fix based on the specific review feedback
     await fixPhase(projectDir, task, feedback, round, providerId);
 
     // Step: Fix applied
@@ -422,10 +433,12 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
       git.pushBranch(projectDir, task.branch);
       log.info('Fix pushed, waiting for next review round...');
       // Brief wait for review bot to react
-      await sleep(10000);
+      await sleep(15000);
     } else {
-      // No actual changes were made by the fix — the AI determined nothing needed fixing
-      log.info('No changes needed after review — proceeding to merge ✅');
+      // AI fix produced no code changes — it cannot resolve this issue
+      log.error('AI fix produced no changes — marking task as blocked');
+      log.error('This task needs manual code changes to resolve review issues');
+      task.status = 'blocked';
       return;
     }
   }
@@ -491,15 +504,34 @@ ${feedback}
 async function mergePhase(projectDir, task, prInfo, baseBranch, checkpoint) {
   log.step('Phase 4/4: Merge PR');
 
+  // Skip merge if task was blocked during review
+  if (task.status === 'blocked') {
+    log.warn(`Task #${task.id} is blocked — skipping merge`);
+    return;
+  }
+
   log.info(`Auto-merging PR #${prInfo.number}...`);
 
-  try {
-    github.mergePR(projectDir, prInfo.number);
-    log.info(`PR #${prInfo.number} merged ✅`);
-  } catch (err) {
-    log.error(`Merge failed: ${err.message}`);
-    log.warn('Please merge manually, then press Enter to continue');
-    await ask('Continue...');
+  let merged = false;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      github.mergePR(projectDir, prInfo.number);
+      log.info(`PR #${prInfo.number} merged ✅`);
+      merged = true;
+      break;
+    } catch (err) {
+      log.warn(`Merge attempt ${attempt}/3 failed: ${err.message}`);
+      if (attempt < 3) {
+        log.info('Retrying in 10s...');
+        await sleep(10000);
+      }
+    }
+  }
+
+  if (!merged) {
+    log.error('Merge failed after 3 attempts — marking task as blocked');
+    task.status = 'blocked';
+    return;
   }
 
   checkpoint.saveStep(task.id, 'merge', 'merged', {