create-claude-workspace 2.3.10 → 2.3.11

package/dist/scheduler/git/manager.mjs

@@ -55,13 +55,16 @@ export function listOrphanedWorktrees(projectDir, knownWorktrees) {
     return actual.filter(p => !knownSet.has(normalizePath(resolve(p))));
 }
 // ─── Commit operations ───
-export function commitInWorktree(worktreePath, message) {
+export function commitInWorktree(worktreePath, message, skipHooks = false) {
     git(['add', '-A'], worktreePath);
     // Check if there's anything to commit
     const status = git(['status', '--porcelain'], worktreePath);
     if (!status)
         return '';
-    git(['commit', '-m', message], worktreePath);
+    const args = ['commit', '-m', message];
+    if (skipHooks)
+        args.push('--no-verify');
+    git(args, worktreePath);
     return git(['rev-parse', 'HEAD'], worktreePath);
 }
 export function getChangedFiles(worktreePath) {

package/dist/scheduler/loop.mjs

@@ -1,13 +1,14 @@
 // ─── Main orchestration loop: pipeline state machine ───
 // Picks tasks, assigns to workers, advances through plan→implement→test→review→commit→merge.
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { resolve } from 'node:path';
 import { parseTodoMd, updateTaskCheckbox } from './tasks/parser.mjs';
 import { fetchOpenIssues, issueToTask, updateIssueStatus } from './tasks/issue-source.mjs';
 import { buildGraph, getParallelBatches, isPhaseComplete, getNextPhase, isProjectComplete } from './tasks/queue.mjs';
 import { writeState, appendEvent, createEvent, rotateLog } from './state/state.mjs';
 import { recordSession, getSession, clearSession } from './state/session.mjs';
-import { createWorktree, commitInWorktree, getChangedFiles, cleanupWorktree, mergeToMain, syncMain, pushWorktree, forcePushWorktree, rebaseOnMain, cleanMainForMerge, popStash, getMainBranch, listOrphanedWorktrees, isBranchMerged, getCurrentBranch, hasUncommittedChanges, abortMerge, deleteBranchRemote, } from './git/manager.mjs';
+import { createWorktree, commitInWorktree, getChangedFiles, cleanupWorktree, mergeToMain, syncMain, pushWorktree, forcePushWorktree, rebaseOnMain, cleanMainForMerge, popStash, getMainBranch, listWorktrees, listOrphanedWorktrees, isBranchMerged, getCurrentBranch, hasUncommittedChanges, abortMerge, deleteBranchRemote, } from './git/manager.mjs';
 import { createPR, getPRStatus, getPRComments, mergePR } from './git/pr-manager.mjs';
 import { scanAgents } from './agents/health-checker.mjs';
 import { detectCIPlatform, fetchFailureLogs } from './git/ci-watcher.mjs';
@@ -63,7 +64,7 @@ export async function runIteration(deps) {
         if (hasUncommittedChanges(projectDir)) {
             logger.warn('Uncommitted changes on main — auto-committing before starting work');
             try {
-                commitInWorktree(projectDir, 'chore: auto-commit uncommitted changes before scheduler start');
+                commitInWorktree(projectDir, 'chore: auto-commit uncommitted changes before scheduler start', true);
                 logger.info('Uncommitted changes committed on main');
             }
             catch (err) {
@@ -593,166 +594,135 @@ function closeRecoveredIssue(projectDir, branch, logger) {
 async function recoverOrphanedWorktrees(projectDir, state, logger, deps) {
     const knownPaths = Object.values(state.pipelines).map(p => p.worktreePath);
     const orphans = listOrphanedWorktrees(projectDir, knownPaths);
-    if (orphans.length === 0)
-        return;
-    logger.info(`Found ${orphans.length} orphaned worktree(s) — attempting recovery`);
+    const ciPlatform = detectCIPlatform(projectDir);
+    if (orphans.length === 0) {
+        logger.info('[recovery] No orphaned worktrees found');
+    }
+    else {
+        logger.info(`[recovery] Found ${orphans.length} orphaned worktree(s)`);
+    }
+    // Phase 1: Handle orphaned worktrees
     for (const worktreePath of orphans) {
         try {
             const branch = getCurrentBranch(worktreePath);
+            logger.info(`[recovery] Processing worktree: ${branch}`);
             const alreadyMerged = isBranchMerged(projectDir, branch);
             if (alreadyMerged) {
-                // Already merged — just clean up
-                logger.info(`[recovery] ${branch} already merged — cleaning up worktree`);
+                logger.info(`[recovery] ${branch} already merged — cleaning up`);
                 cleanupWorktree(projectDir, worktreePath, branch);
                 deleteBranchRemote(projectDir, branch);
                 closeRecoveredIssue(projectDir, branch, logger);
                 continue;
             }
-            // Check if worktree has commits ahead of main
             const hasChanges = hasUncommittedChanges(worktreePath);
             const changedFromMain = getChangedFiles(worktreePath);
             const hasCommits = changedFromMain.length > 0;
+            logger.info(`[recovery] ${branch}: uncommitted=${hasChanges}, commits ahead=${hasCommits} (${changedFromMain.length} files)`);
             if (!hasCommits && !hasChanges) {
-                // No work done — clean up empty worktree
                 logger.info(`[recovery] ${branch} has no changes — cleaning up`);
                 cleanupWorktree(projectDir, worktreePath, branch);
+                deleteBranchRemote(projectDir, branch);
                 continue;
             }
             if (hasChanges) {
-                // Uncommitted changes — commit them first
                 logger.info(`[recovery] ${branch} has uncommitted changes — committing`);
-                commitInWorktree(worktreePath, `wip: auto-commit from recovery`);
+                commitInWorktree(worktreePath, 'wip: auto-commit from recovery', true);
+            }
+            // Delegate to AI agent: rebase onto main, fix any issues, then commit
+            logger.info(`[recovery] Spawning AI agent to finalize ${branch}`);
+            const slot = deps.pool.idleSlot();
+            if (!slot) {
+                logger.warn(`[recovery] No idle worker — skipping ${branch} for now`);
+                continue;
             }
-            // Try to merge
-            logger.info(`[recovery] ${branch} has unmerged commits — attempting merge`);
-            // Clean dirty main before merge
-            // Clean main: abort any in-progress merge/rebase, stash uncommitted changes
+            deps.onSpawnStart?.(`recovery-${branch}`);
+            try {
+                await deps.pool.spawn(slot.id, {
+                    cwd: worktreePath,
+                    prompt: [
+                        `You are in a git worktree for branch "${branch}".`,
+                        `This branch was interrupted and needs to be finalized for merge into main.`,
+                        ``,
+                        `Do the following:`,
+                        `1. Run: git fetch origin main && git rebase origin/main`,
+                        `2. If rebase has conflicts, resolve them sensibly (prefer feature branch intent)`,
+                        `3. After rebase, run the project's build/lint to check for errors:`,
+                        `   - Look at package.json for available scripts (build, lint, test)`,
+                        `   - Fix any build or lint errors in the code`,
+                        `4. Commit fixes: git add -A && git commit --no-verify -m "fix: resolve issues for merge"`,
+                        `5. Do NOT merge into main — just make the branch clean and ready`,
+                        ``,
+                        `Changed files in this branch: ${changedFromMain.join(', ')}`,
+                    ].join('\n'),
+                    model: 'claude-sonnet-4-6',
+                    onMessage: deps.onMessage,
+                });
+            }
+            finally {
+                deps.onSpawnEnd?.();
+            }
+            // Now try to merge
+            logger.info(`[recovery] Agent done — attempting merge of ${branch}`);
             const stashed = cleanMainForMerge(projectDir);
             syncMain(projectDir);
-            // Try PR flow first if remote exists
-            const ciPlatform = detectCIPlatform(projectDir);
+            // Try platform merge (PR/MR) first
+            let merged = false;
             if (ciPlatform !== 'none') {
-                const pushed = pushWorktree(worktreePath);
+                const pushed = pushWorktree(worktreePath) || forcePushWorktree(worktreePath);
                 if (pushed) {
                     try {
                         const mainBranch = getMainBranch(projectDir);
+                        const issueNum = extractIssueFromBranch(branch);
                         const prInfo = createPR({
                             cwd: projectDir,
                             platform: ciPlatform,
                             branch,
                             baseBranch: mainBranch,
-                            title: `feat: ${branch} (recovered)`,
-                            body: `Auto-recovered from orphaned worktree.\n\nThis PR was created by the scheduler to complete a previously interrupted task.`,
+                            title: `feat: ${branch}`,
+                            body: 'Recovered and finalized by scheduler.',
+                            issueNumber: issueNum ?? undefined,
                         });
-                        logger.info(`[recovery] PR created for ${branch}: ${prInfo.url}`);
-                        // Try to merge immediately if possible
-                        const status = getPRStatus(projectDir, ciPlatform, branch);
-                        if (status.mergeable) {
-                            mergePR(projectDir, ciPlatform, status.number);
-                            logger.info(`[recovery] ${branch} merged via platform`);
-                            syncMain(projectDir);
-                            cleanupWorktree(projectDir, worktreePath, branch);
-                            deleteBranchRemote(projectDir, branch);
-                            closeRecoveredIssue(projectDir, branch, logger);
-                            if (stashed)
-                                popStash(projectDir);
-                            continue;
+                        logger.info(`[recovery] PR: ${prInfo.url}`);
+                        if (prInfo.status === 'merged') {
+                            logger.info(`[recovery] ${branch} already merged via platform`);
+                            merged = true;
+                        }
+                        else {
+                            const prStatus = getPRStatus(projectDir, ciPlatform, branch);
+                            if (prStatus.mergeable) {
+                                merged = mergePR(projectDir, ciPlatform, prStatus.number);
+                                if (merged)
+                                    logger.info(`[recovery] ${branch} merged via platform`);
+                            }
+                            else {
+                                logger.info(`[recovery] PR for ${branch} not yet mergeable (CI: ${prStatus.ciStatus}) — leaving open`);
+                            }
                         }
-                        // PR created but not yet mergeable — leave it for next iteration
-                        logger.info(`[recovery] PR for ${branch} not yet mergeable — will retry`);
-                        if (stashed)
-                            popStash(projectDir);
-                        continue;
                     }
                     catch (err) {
-                        logger.warn(`[recovery] PR creation failed for ${branch}: ${err.message} — trying local merge`);
+                        logger.warn(`[recovery] PR flow failed for ${branch}: ${err.message?.split('\n')[0]}`);
                     }
                 }
             }
             // Local merge fallback
-            const mergeResult = mergeToMain(projectDir, branch);
-            if (mergeResult.success) {
-                logger.info(`[recovery] ${branch} merged locally (${mergeResult.sha?.slice(0, 7)})`);
-                appendEvent(projectDir, createEvent('merge_completed', { detail: `recovery: ${branch}` }));
-                closeRecoveredIssue(projectDir, branch, logger);
-            }
-            else if (mergeResult.conflict) {
-                // mergeToMain already aborted the merge internally
-                // Delegate conflict resolution to orchestrator AI
-                logger.info(`[recovery] ${branch} has merge conflicts — delegating to AI`);
-                let resolved = false;
-                try {
-                    const conflictDecision = await deps.orchestrator.handleMergeConflict(branch, mergeResult.conflictFiles ?? []);
-                    if (conflictDecision.action === 'resolve') {
-                        // Spawn agent to resolve conflicts in the worktree via rebase
-                        logger.info(`[recovery] Spawning agent to resolve conflicts in ${branch}`);
-                        const conflictPrompt = [
-                            `You are in a worktree for branch "${branch}".`,
-                            `Rebase this branch onto main and resolve all merge conflicts.`,
-                            ``,
-                            `Steps:`,
-                            `1. Run: git rebase main`,
-                            `2. For each conflict, read the conflicting files and resolve them sensibly`,
-                            `3. After resolving each file: git add <file>`,
-                            `4. Continue rebase: git rebase --continue`,
-                            `5. Repeat until rebase is complete`,
-                            ``,
-                            `Conflicting files: ${(mergeResult.conflictFiles ?? []).join(', ') || 'unknown'}`,
-                            ``,
-                            `Important: preserve the intent of both sides. When in doubt, prefer the feature branch changes.`,
-                        ].join('\n');
-                        const slot = deps.pool.idleSlot();
-                        if (slot) {
-                            await deps.pool.spawn(slot.id, {
-                                cwd: worktreePath,
-                                prompt: conflictPrompt,
-                                model: 'claude-sonnet-4-6',
-                                onMessage: deps.onMessage,
-                            });
-                            // Retry merge after agent resolved conflicts
-                            const retryResult = mergeToMain(projectDir, branch);
-                            if (retryResult.success) {
-                                logger.info(`[recovery] ${branch} merged after AI conflict resolution`);
-                                appendEvent(projectDir, createEvent('merge_completed', { detail: `recovery-ai-resolve: ${branch}` }));
-                                resolved = true;
-                            }
-                        }
-                    }
-                    else if (conflictDecision.action === 'rebase') {
-                        const rebaseResult = rebaseOnMain(worktreePath, projectDir);
-                        if (rebaseResult.success) {
-                            const retryResult = mergeToMain(projectDir, branch);
-                            if (retryResult.success) {
-                                logger.info(`[recovery] ${branch} merged after rebase`);
-                                resolved = true;
-                            }
-                        }
-                    }
-                    // action === 'skip' → resolved stays false
-                }
-                catch (err) {
-                    logger.warn(`[recovery] AI conflict resolution failed for ${branch}: ${err.message}`);
-                    abortMerge(projectDir);
+            if (!merged) {
+                const mergeResult = mergeToMain(projectDir, branch);
+                if (mergeResult.success) {
+                    logger.info(`[recovery] ${branch} merged locally (${mergeResult.sha?.slice(0, 7)})`);
+                    merged = true;
                 }
-                if (!resolved) {
-                    logger.error(`[recovery] ${branch} has unresolvable conflicts — skipping`);
+                else {
+                    logger.error(`[recovery] ${branch} merge failed: ${mergeResult.error ?? 'unknown'}`);
                     abortMerge(projectDir);
-                    if (stashed)
-                        popStash(projectDir);
-                    continue;
                 }
             }
-            else {
-                logger.error(`[recovery] ${branch} merge failed: ${mergeResult.error} — skipping`);
-                abortMerge(projectDir);
-                if (stashed)
-                    popStash(projectDir);
-                continue;
+            if (merged) {
+                syncMain(projectDir);
+                cleanupWorktree(projectDir, worktreePath, branch);
+                deleteBranchRemote(projectDir, branch);
+                closeRecoveredIssue(projectDir, branch, logger);
+                appendEvent(projectDir, createEvent('merge_completed', { detail: `recovery: ${branch}` }));
             }
-            // Post-merge cleanup: worktree + local branch + remote branch + close issue
-            cleanupWorktree(projectDir, worktreePath, branch);
-            deleteBranchRemote(projectDir, branch);
-            closeRecoveredIssue(projectDir, branch, logger);
             if (stashed)
                 popStash(projectDir);
         }
@@ -760,6 +730,69 @@ async function recoverOrphanedWorktrees(projectDir, state, logger, deps) {
             logger.error(`[recovery] Failed to recover ${worktreePath}: ${err.message}`);
         }
     }
+    // Phase 2: Check for open MRs/PRs without local worktrees
+    if (ciPlatform !== 'none') {
+        await recoverOpenMRs(projectDir, ciPlatform, state, logger);
+    }
+}
+/** Find open MRs/PRs that don't have local worktrees and try to merge them */
+async function recoverOpenMRs(projectDir, platform, state, logger) {
+    try {
+        // Get all open MRs
+        const openMRs = getOpenMRs(projectDir, platform);
+        if (openMRs.length === 0)
+            return;
+        const existingBranches = new Set(listWorktrees(projectDir).map(wt => {
+            try {
+                return getCurrentBranch(wt);
+            }
+            catch {
+                return '';
+            }
+        }));
+        for (const mr of openMRs) {
+            if (existingBranches.has(mr.branch))
+                continue; // Handled in phase 1
+            logger.info(`[recovery] Found open MR !${mr.number} for ${mr.branch} (no local worktree)`);
+            const prStatus = getPRStatus(projectDir, platform, mr.branch);
+            if (prStatus.status === 'merged') {
+                logger.info(`[recovery] MR !${mr.number} already merged`);
+                closeRecoveredIssue(projectDir, mr.branch, logger);
+                continue;
+            }
+            if (prStatus.mergeable) {
+                const merged = mergePR(projectDir, platform, prStatus.number);
+                if (merged) {
+                    logger.info(`[recovery] MR !${mr.number} merged via platform`);
+                    syncMain(projectDir);
+                    closeRecoveredIssue(projectDir, mr.branch, logger);
+                }
+            }
+            else {
+                logger.info(`[recovery] MR !${mr.number} not mergeable (CI: ${prStatus.ciStatus}) — leaving open`);
+            }
+        }
+    }
+    catch (err) {
+        logger.warn(`[recovery] MR scan failed: ${err.message?.split('\n')[0]}`);
+    }
+}
+function getOpenMRs(projectDir, platform) {
+    try {
+        if (platform === 'github') {
+            const output = execFileSync('gh', ['pr', 'list', '--json', 'number,headRefName', '--state', 'open'], { cwd: projectDir, encoding: 'utf-8', stdio: 'pipe', timeout: 30_000 }).trim();
+            const prs = JSON.parse(output);
+            return prs.map(p => ({ number: p.number, branch: p.headRefName }));
+        }
+        else {
+            const output = execFileSync('glab', ['mr', 'list', '--output', 'json'], { cwd: projectDir, encoding: 'utf-8', stdio: 'pipe', timeout: 30_000 }).trim();
+            const mrs = JSON.parse(output);
+            return mrs.map(m => ({ number: m.iid, branch: m.source_branch }));
+        }
+    }
+    catch {
+        return [];
+    }
 }
 function loadTasksJson(path) {
     const content = readFileSync(path, 'utf-8');

package/package.json

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