create-claude-workspace 2.2.0 → 2.2.2

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

@@ -26,12 +26,15 @@ export function createPR(opts) {
             comments: [],
         };
     }
-    // GitLab
-    const output = cli(`glab mr create --title "${escapedTitle}" --description "${escapedBody}" --target-branch "${opts.baseBranch}" --source-branch "${opts.branch}" --no-editor --json iid,web_url`, opts.cwd, WRITE_TIMEOUT);
-    const mr = JSON.parse(output);
+    // GitLab — glab mr create doesn't support --json, parse URL from output
+    const output = cli(`glab mr create --title "${escapedTitle}" --description "${escapedBody}" --target-branch "${opts.baseBranch}" --source-branch "${opts.branch}" --no-editor`, opts.cwd, WRITE_TIMEOUT);
+    // glab outputs the MR URL, e.g. "https://gitlab.com/group/repo/-/merge_requests/7"
+    const urlMatch = output.match(/https?:\/\/\S+merge_requests\/(\d+)/);
+    const mrIid = urlMatch ? parseInt(urlMatch[1], 10) : 0;
+    const mrUrl = urlMatch ? urlMatch[0] : output.trim();
     return {
-        number: mr.iid,
-        url: mr.web_url,
+        number: mrIid,
+        url: mrUrl,
         status: 'open',
         ciStatus: 'pending',
         approvals: 0,
@@ -83,7 +86,7 @@ function parseGitHubComments(comments) {
     }));
 }
 function getGitLabMRStatus(cwd, branch) {
-    const output = cli(`glab mr view "${branch}" --json iid,web_url,state,merge_status,head_pipeline,user_notes_count`, cwd);
+    const output = cli(`glab mr view "${branch}" --output json`, cwd);
     const mr = JSON.parse(output);
     const ciStatus = resolveGitLabCIStatus(mr.head_pipeline);
     const mergeable = mr.merge_status === 'can_be_merged' && ciStatus === 'passed';

package/dist/scheduler/loop.mjs

@@ -7,7 +7,7 @@ import { fetchOpenIssues, issueToTask, updateIssueStatus } from './tasks/issue-s
 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, evaluateDirtyMain, discardFiles, stashChanges, popStash, getMainBranch, } from './git/manager.mjs';
+import { createWorktree, commitInWorktree, getChangedFiles, cleanupWorktree, mergeToMain, syncMain, pushWorktree, forcePushWorktree, rebaseOnMain, evaluateDirtyMain, discardFiles, stashChanges, popStash, getMainBranch, listOrphanedWorktrees, isBranchMerged, getCurrentBranch, hasUncommittedChanges, } 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';
@@ -58,6 +58,10 @@ export async function runIteration(deps) {
             // Caller (scheduler.mts) handles pause state
         }
     }
+    // Recover orphaned worktrees from previous runs
+    if (state.iteration === 0) {
+        await recoverOrphanedWorktrees(projectDir, state, logger, deps);
+    }
     // Load tasks (dual mode: platform issues or local TODO.md)
     let tasks;
     if (state.taskMode === 'platform') {
@@ -507,6 +511,128 @@ function extractSection(output, section) {
     const match = output.match(pattern);
     return match ? match[1].trim() : null;
 }
+// ─── Orphaned worktree recovery ───
+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`);
+    for (const worktreePath of orphans) {
+        try {
+            const branch = getCurrentBranch(worktreePath);
+            const alreadyMerged = isBranchMerged(projectDir, branch);
+            if (alreadyMerged) {
+                // Already merged — just clean up
+                logger.info(`[recovery] ${branch} already merged — cleaning up worktree`);
+                cleanupWorktree(projectDir, worktreePath, branch);
+                continue;
+            }
+            // Check if worktree has commits ahead of main
+            const hasChanges = hasUncommittedChanges(worktreePath);
+            const changedFromMain = getChangedFiles(worktreePath);
+            const hasCommits = changedFromMain.length > 0;
+            if (!hasCommits && !hasChanges) {
+                // No work done — clean up empty worktree
+                logger.info(`[recovery] ${branch} has no changes — cleaning up`);
+                cleanupWorktree(projectDir, worktreePath, branch);
+                continue;
+            }
+            if (hasChanges) {
+                // Uncommitted changes — commit them first
+                logger.info(`[recovery] ${branch} has uncommitted changes — committing`);
+                commitInWorktree(worktreePath, `wip: auto-commit from recovery`);
+            }
+            // Try to merge
+            logger.info(`[recovery] ${branch} has unmerged commits — attempting merge`);
+            // Clean dirty main before merge
+            const dirty = evaluateDirtyMain(projectDir);
+            if (dirty.trackingFiles.length > 0) {
+                discardFiles(projectDir, dirty.trackingFiles);
+            }
+            const stashed = dirty.userFiles.length > 0 ? stashChanges(projectDir) : false;
+            syncMain(projectDir);
+            // Try PR flow first if remote exists
+            const ciPlatform = detectCIPlatform(projectDir);
+            if (ciPlatform !== 'none') {
+                const pushed = pushWorktree(worktreePath);
+                if (pushed) {
+                    try {
+                        const mainBranch = getMainBranch(projectDir);
+                        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.`,
+                        });
+                        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);
+                            if (stashed)
+                                popStash(projectDir);
+                            continue;
+                        }
+                        // 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`);
+                    }
+                }
+            }
+            // 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}` }));
+            }
+            else if (mergeResult.conflict) {
+                // Try rebase
+                const rebaseResult = rebaseOnMain(worktreePath, projectDir);
+                if (rebaseResult.success) {
+                    const retryResult = mergeToMain(projectDir, branch);
+                    if (retryResult.success) {
+                        logger.info(`[recovery] ${branch} merged after rebase`);
+                    }
+                    else {
+                        logger.error(`[recovery] ${branch} merge failed after rebase — skipping`);
+                        if (stashed)
+                            popStash(projectDir);
+                        continue;
+                    }
+                }
+                else {
+                    logger.error(`[recovery] ${branch} has unresolvable conflicts — skipping`);
+                    if (stashed)
+                        popStash(projectDir);
+                    continue;
+                }
+            }
+            else {
+                logger.error(`[recovery] ${branch} merge failed: ${mergeResult.error} — skipping`);
+                if (stashed)
+                    popStash(projectDir);
+                continue;
+            }
+            cleanupWorktree(projectDir, worktreePath, branch);
+            if (stashed)
+                popStash(projectDir);
+        }
+        catch (err) {
+            logger.error(`[recovery] Failed to recover ${worktreePath}: ${err.message}`);
+        }
+    }
+}
 function loadTasksJson(path) {
     const content = readFileSync(path, 'utf-8');
     const data = JSON.parse(content);

package/package.json

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