@jojonax/codex-copilot 1.2.2 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jojonax/codex-copilot",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "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', {
@@ -302,8 +318,6 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
     log.info('Checking for review feedback...');
 
     // Always proactively check for existing reviews first.
-    // This handles: resume after restart, review arrived before polling starts,
-    // or any case where the review is already available.
     let gotReview = false;
     const existingReviews = github.getReviews(projectDir, prInfo.number);
     const existingComments = github.getIssueComments(projectDir, prInfo.number);
@@ -322,14 +336,17 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
     }
 
     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', {
@@ -370,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
@@ -415,14 +429,17 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
 
     // Push fix — only if there are actual changes
     if (!git.isClean(projectDir)) {
-      git.commitAll(projectDir, `fix(task-${task.id}): address review comments (round ${round})`);
+      const skipCI = github.isPrivateRepo(projectDir) ? ' [skip ci]' : '';
+      git.commitAll(projectDir, `fix(task-${task.id}): address review comments (round ${round})${skipCI}`);
       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;
     }
   }
@@ -488,15 +505,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', {

package/src/utils/github.js

@@ -292,9 +292,23 @@ export function collectReviewFeedback(cwd, prNumber) {
   return feedback.trim();
 }
 
+/**
+ * Check if the current repo is private
+ * @returns {boolean} true if private, false if public or unknown
+ */
+export function isPrivateRepo(cwd) {
+  try {
+    const result = ghJSON('repo view --json isPrivate', cwd);
+    return result?.isPrivate === true;
+  } catch {
+    return false; // Default to public behavior if detection fails
+  }
+}
+
 export const github = {
   checkGhAuth, createPR, createPRWithRecovery, findExistingPR,
   ensureRemoteBranch, hasCommitsBetween,
   getReviews, getReviewComments, getIssueComments,
   getLatestReviewState, mergePR, collectReviewFeedback,
+  isPrivateRepo,
 };