create-claude-workspace 2.3.16 → 2.3.18

package/dist/scheduler/git/pr-manager.mjs

@@ -23,18 +23,20 @@ export function createPR(opts) {
         ? `${opts.body}\n\nCloses #${opts.issueNumber}`
         : opts.body;
     if (opts.platform === 'github') {
-        const output = run('gh', [
+        // gh pr create outputs the PR URL on success
+        const url = run('gh', [
             'pr', 'create',
             '--title', opts.title,
             '--body', body,
             '--base', opts.baseBranch,
             '--head', opts.branch,
-            '--json', 'number,url',
         ], opts.cwd, WRITE_TIMEOUT);
-        const pr = JSON.parse(output);
+        // Extract PR number from URL: https://github.com/owner/repo/pull/123
+        const prNumMatch = url.match(/\/pull\/(\d+)/);
+        const prNumber = prNumMatch ? parseInt(prNumMatch[1], 10) : 0;
         return {
-            number: pr.number,
-            url: pr.url,
+            number: prNumber,
+            url: url.trim(),
             status: 'open',
             ciStatus: 'pending',
             approvals: 0,

package/dist/scheduler/loop.mjs

@@ -193,8 +193,55 @@ export async function runIteration(deps) {
     if (queued > 0) {
         logger.info(`Starting ${tasksToRun.length} tasks, ${queued} queued (waiting for workers)`);
     }
-    // Process recovered pipelines first (from recovery phase)
+    // ─── Phase A: Check active PR watches (non-blocking) ───
     let workDone = false;
+    const prWatchIds = Object.keys(state.pipelines).filter(id => state.pipelines[id].step === 'pr-watch');
+    for (const taskId of prWatchIds) {
+        const pipeline = state.pipelines[taskId];
+        const result = await checkPRWatch(taskId, pipeline, projectDir, agents, deps);
+        if (result === 'merged') {
+            let branch;
+            try {
+                branch = getCurrentBranch(pipeline.worktreePath);
+            }
+            catch {
+                branch = taskId;
+            }
+            logger.info(`[${taskId}] PR merged via platform`);
+            appendEvent(projectDir, createEvent('pr_merged', { taskId }));
+            syncMain(projectDir);
+            cleanupWorktree(projectDir, pipeline.worktreePath, branch);
+            deleteBranchRemote(projectDir, branch);
+            pipeline.step = 'done';
+            clearSession(state, taskId);
+            state.completedTasks.push(taskId);
+            delete state.pipelines[taskId];
+            if (state.taskMode === 'platform') {
+                const ciPlat = detectCIPlatform(projectDir);
+                if (ciPlat !== 'none') {
+                    const issueNum = extractIssueNumber(taskId);
+                    if (issueNum)
+                        updateIssueStatus(projectDir, ciPlat, issueNum, 'done');
+                }
+            }
+            appendEvent(projectDir, createEvent('task_completed', { taskId }));
+            workDone = true;
+        }
+        else if (result === 'failed') {
+            logger.error(`[${taskId}] PR failed — skipping task`);
+            pipeline.step = 'failed';
+            state.skippedTasks.push(taskId);
+            delete state.pipelines[taskId];
+            workDone = true;
+        }
+        else if (result === 'rework') {
+            // CI failed or comments — agent was spawned to fix, push done, back to watching
+            workDone = true;
+        }
+        // result === 'waiting' → still polling, do nothing
+        writeState(projectDir, state);
+    }
+    // ─── Phase B: Process recovered pipelines (from recovery phase) ───
     const recoveredIds = Object.keys(state.pipelines).filter(id => {
         const p = state.pipelines[id];
         return p.workerId === -1 && p.step !== 'done' && p.step !== 'failed';
@@ -227,7 +274,11 @@ export async function runIteration(deps) {
         try {
             const success = await runTaskPipeline(task, slot.id, agents, deps);
             workDone = true;
-            if (success) {
+            // If pipeline is in pr-watch, it's still active — don't mark done yet
+            if (state.pipelines[task.id]?.step === 'pr-watch') {
+                // PR watch is non-blocking, handled in Phase A next iteration
+            }
+            else if (success) {
                 task.status = 'done';
                 state.completedTasks.push(task.id);
                 if (state.taskMode === 'platform') {
@@ -265,7 +316,11 @@ export async function runIteration(deps) {
         try {
             const success = await runTaskPipeline(task, slot.id, agents, deps);
             workDone = true;
-            if (success) {
+            // If pipeline is in pr-watch, it's still active — don't mark done yet
+            if (state.pipelines[task.id]?.step === 'pr-watch') {
+                // PR watch is non-blocking, handled in Phase A next iteration
+            }
+            else if (success) {
                 task.status = 'done';
                 state.completedTasks.push(task.id);
                 if (state.taskMode === 'platform') {
@@ -541,24 +596,13 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                     pipeline.prState = { prNumber: prInfo.number, url: prInfo.url, issueNumber: issueNum };
                     logger.info(`[${task.id}] PR created: ${prInfo.url}`);
                     appendEvent(projectDir, createEvent('pr_created', { taskId: task.id, detail: prInfo.url }));
-                    // STEP 7: Poll PR status — CI, comments, mergeable
+                    // STEP 7: PR created — hand off to non-blocking PR watch
+                    // The main loop checks pr-watch pipelines each iteration
                     pipeline.step = 'pr-watch';
                     appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'pr-watch' }));
-                    const merged = await pollAndMergePR(task, pipeline, slug, ciPlatform, projectDir, worktreePath, agents, deps);
-                    if (merged) {
-                        logger.info(`[${task.id}] PR merged via platform`);
-                        appendEvent(projectDir, createEvent('pr_merged', { taskId: task.id }));
-                        // Sync main to get the merge commit
-                        syncMain(projectDir);
-                        cleanupWorktree(projectDir, worktreePath, slug);
-                        deleteBranchRemote(projectDir, slug);
-                        pipeline.step = 'done';
-                        clearSession(state, task.id);
-                        delete state.pipelines[task.id];
-                        return true;
-                    }
-                    // Fallback to local merge
-                    logger.warn(`[${task.id}] Platform merge failed — falling back to local merge`);
+                    logger.info(`[${task.id}] PR watching — releasing worker for other tasks`);
+                    writeState(projectDir, state);
+                    return true; // Task not failed, PR watch continues in main loop
                 }
                 catch (err) {
                     logger.warn(`[${task.id}] PR creation failed: ${err.message} — falling back to local merge`);
@@ -902,6 +946,111 @@ function loadTasksJson(path) {
 // ─── PR polling and merge ───
 const PR_POLL_INTERVAL = 15_000;
 const PR_MAX_POLL_TIME = 30 * 60_000;
+async function checkPRWatch(taskId, pipeline, projectDir, agents, deps) {
+    const { pool, logger, state, onMessage, onSpawnStart, onSpawnEnd } = deps;
+    const ciPlatform = detectCIPlatform(projectDir);
+    if (ciPlatform === 'none' || !pipeline.prState)
+        return 'failed';
+    const branch = getCurrentBranch(pipeline.worktreePath);
+    try {
+        const prStatus = getPRStatus(projectDir, ciPlatform, branch);
+        if (prStatus.status === 'merged')
+            return 'merged';
+        if (prStatus.status === 'closed')
+            return 'failed';
+        // Ready to merge
+        if (prStatus.mergeable) {
+            logger.info(`[${taskId}] PR mergeable — merging`);
+            const merged = mergePR(projectDir, ciPlatform, prStatus.number);
+            return merged ? 'merged' : 'failed';
+        }
+        // CI pending — keep waiting
+        if (prStatus.ciStatus === 'pending' || prStatus.ciStatus === 'not-found') {
+            logger.info(`[${taskId}] CI: ${prStatus.ciStatus} — waiting`);
+            return 'waiting';
+        }
+        // CI passed but not mergeable — waiting for approval
+        if (prStatus.ciStatus === 'passed' && !prStatus.mergeable) {
+            logger.info(`[${taskId}] CI passed, not mergeable — waiting`);
+            return 'waiting';
+        }
+        // CI failed — delegate fix to implementing agent
+        if (prStatus.ciStatus === 'failed') {
+            if (pipeline.ciFixes >= MAX_CI_FIXES) {
+                logger.error(`[${taskId}] CI fix limit (${MAX_CI_FIXES}) reached`);
+                return 'failed';
+            }
+            pipeline.ciFixes++;
+            logger.warn(`[${taskId}] CI failed — delegating to agent (${pipeline.ciFixes}/${MAX_CI_FIXES})`);
+            const slot = pool.idleSlot();
+            if (!slot) {
+                logger.info(`[${taskId}] No idle worker for CI fix — will retry next iteration`);
+                pipeline.ciFixes--; // Don't count this attempt
+                return 'waiting';
+            }
+            const logs = fetchFailureLogs(branch, ciPlatform === 'github' ? 'github' : 'gitlab', projectDir);
+            // Create a minimal task for agent spawning
+            const task = {
+                id: taskId, title: `Fix CI for ${taskId}`, phase: state.currentPhase,
+                type: 'fullstack', complexity: 'S', dependsOn: [], issueMarker: taskId,
+                kitUpgrade: false, lineNumber: 0, status: 'in-progress', changelog: 'fixed',
+            };
+            const fixResult = await spawnAgent(pool, slot.id, {
+                agent: pipeline.assignedAgent ?? undefined,
+                cwd: pipeline.worktreePath,
+                prompt: buildCIFixPrompt({ task, worktreePath: pipeline.worktreePath, projectDir }, logs ?? 'No CI logs available'),
+                model: getAgentModel(pipeline.assignedAgent, agents, task),
+            }, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd);
+            if (fixResult.success) {
+                const sha = commitInWorktree(pipeline.worktreePath, `fix: CI failure for ${taskId}`);
+                if (sha) {
+                    forcePushWorktree(pipeline.worktreePath);
+                    logger.info(`[${taskId}] Fix pushed — will check CI next iteration`);
+                    return 'rework';
+                }
+            }
+            return 'waiting'; // Agent didn't produce fix, retry next iteration
+        }
+        // Unresolved PR comments
+        const comments = getPRComments(projectDir, ciPlatform, prStatus.number);
+        const unresolved = comments.filter(c => !c.resolved);
+        if (unresolved.length > 0) {
+            const slot = pool.idleSlot();
+            if (!slot)
+                return 'waiting';
+            logger.info(`[${taskId}] ${unresolved.length} PR comments — delegating to agent`);
+            const commentText = unresolved
+                .map(c => `${c.path ?? 'general'}${c.line ? `:${c.line}` : ''} — ${c.author}: ${c.body}`)
+                .join('\n\n');
+            const task = {
+                id: taskId, title: `Address PR comments for ${taskId}`, phase: state.currentPhase,
+                type: 'fullstack', complexity: 'S', dependsOn: [], issueMarker: taskId,
+                kitUpgrade: false, lineNumber: 0, status: 'in-progress', changelog: 'fixed',
+            };
+            const result = await spawnAgent(pool, slot.id, {
+                agent: pipeline.assignedAgent ?? undefined,
+                cwd: pipeline.worktreePath,
+                prompt: buildPRCommentPrompt({ task, worktreePath: pipeline.worktreePath, projectDir }, commentText),
+                model: getAgentModel(pipeline.assignedAgent, agents, task),
+            }, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd);
+            if (result.success) {
+                const sha = commitInWorktree(pipeline.worktreePath, 'fix: address PR comments');
+                if (sha) {
+                    forcePushWorktree(pipeline.worktreePath);
+                    appendEvent(projectDir, createEvent('pr_comment_resolved', { taskId, detail: `${unresolved.length} comments` }));
+                    return 'rework';
+                }
+            }
+            return 'waiting';
+        }
+        return 'waiting';
+    }
+    catch (err) {
+        logger.error(`[${taskId}] PR watch error: ${err.message?.split('\n')[0]}`);
+        return 'waiting'; // Don't fail on transient errors
+    }
+}
+// ─── Legacy blocking PR poll (kept for local merge fallback) ───
 async function pollAndMergePR(task, pipeline, branch, platform, projectDir, worktreePath, agents, deps) {
     const { pool, logger, state, onMessage, onSpawnStart, onSpawnEnd } = deps;
     const startTime = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-workspace",
-  "version": "2.3.16",
+  "version": "2.3.18",
   "author": "",
   "repository": {
     "type": "git",