create-claude-workspace 2.3.12 → 2.3.13

package/dist/scheduler/loop.mjs

@@ -676,7 +676,7 @@ function isRefactoringTask(task) {
 }
 // ─── Orphaned worktree recovery ───
 /** Mark issue as done on the platform after a successful recovery merge */
-function closeRecoveredIssue(projectDir, branch, logger) {
+export function closeRecoveredIssue(projectDir, branch, logger) {
     const platform = detectCIPlatform(projectDir);
     if (platform === 'none')
         return;
@@ -698,7 +698,7 @@ function closeRecoveredIssue(projectDir, branch, logger) {
  * This does NOT spawn custom recovery agents — it just figures out the
  * right pipeline step and lets runTaskPipeline do the real work.
  */
-async function recoverOrphanedWorktrees(projectDir, state, logger, _deps) {
+export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps) {
     const knownPaths = Object.values(state.pipelines).map(p => p.worktreePath);
     const orphans = listOrphanedWorktrees(projectDir, knownPaths);
     const ciPlatform = detectCIPlatform(projectDir);
@@ -767,7 +767,7 @@ async function recoverOrphanedWorktrees(projectDir, state, logger, _deps) {
     }
 }
 /** Diagnose which pipeline step a recovered worktree should resume from */
-function diagnoseStep(projectDir, branch, ciPlatform) {
+export function diagnoseStep(projectDir, branch, ciPlatform) {
     // Check if there's an open MR/PR for this branch
     if (ciPlatform !== 'none') {
         try {
@@ -791,7 +791,7 @@ function diagnoseStep(projectDir, branch, ciPlatform) {
     return 'review';
 }
 /** Re-inject open MRs that have no local worktree into the pipeline */
-function recoverOpenMRs(projectDir, platform, state, logger) {
+export function recoverOpenMRs(projectDir, platform, state, logger) {
     try {
         const openMRs = getOpenMRs(projectDir, platform);
         if (openMRs.length === 0)
@@ -864,7 +864,7 @@ function recoverOpenMRs(projectDir, platform, state, logger) {
         logger.warn(`[recovery] MR scan failed: ${err.message?.split('\n')[0]}`);
     }
 }
-function getOpenMRs(projectDir, platform) {
+export 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();
@@ -997,7 +997,7 @@ function extractIssueNumber(marker) {
     return match ? parseInt(match[1], 10) : null;
 }
 /** Extract issue number from branch name like "feat/#94-description" or "feat/94-description" */
-function extractIssueFromBranch(branch) {
+export function extractIssueFromBranch(branch) {
     const match = branch.match(/#?(\d+)/);
     return match ? parseInt(match[1], 10) : null;
 }

package/dist/scheduler/loop.spec.js

@@ -139,3 +139,156 @@ describe('pipeline state tracking', () => {
         expect(pipeline.reviewCycles < 5).toBe(true);
     });
 });
+// ─── Test exports of recovery functions ───
+describe('recovery function exports', () => {
+    it('exports diagnoseStep', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.diagnoseStep).toBe('function');
+    });
+    it('exports recoverOrphanedWorktrees', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.recoverOrphanedWorktrees).toBe('function');
+    });
+    it('exports recoverOpenMRs', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.recoverOpenMRs).toBe('function');
+    });
+    it('exports getOpenMRs', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.getOpenMRs).toBe('function');
+    });
+    it('exports extractIssueFromBranch', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.extractIssueFromBranch).toBe('function');
+    });
+    it('exports closeRecoveredIssue', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.closeRecoveredIssue).toBe('function');
+    });
+});
+// ─── Test shouldSkip pattern used in runTaskPipeline ───
+describe('shouldSkip pattern (pipeline resume logic)', () => {
+    const stepOrder = ['plan', 'implement', 'test', 'review', 'rework', 'commit', 'pr-create', 'pr-watch', 'merge'];
+    function shouldSkip(step, resumeFrom) {
+        const skipToIndex = stepOrder.indexOf(resumeFrom);
+        return stepOrder.indexOf(step) < skipToIndex;
+    }
+    it('fresh pipeline (plan) skips nothing', () => {
+        for (const step of stepOrder) {
+            expect(shouldSkip(step, 'plan')).toBe(false);
+        }
+    });
+    it('resuming at "implement" skips only plan', () => {
+        expect(shouldSkip('plan', 'implement')).toBe(true);
+        expect(shouldSkip('implement', 'implement')).toBe(false);
+        expect(shouldSkip('test', 'implement')).toBe(false);
+    });
+    it('resuming at "review" skips plan, implement, test', () => {
+        expect(shouldSkip('plan', 'review')).toBe(true);
+        expect(shouldSkip('implement', 'review')).toBe(true);
+        expect(shouldSkip('test', 'review')).toBe(true);
+        expect(shouldSkip('review', 'review')).toBe(false);
+        expect(shouldSkip('commit', 'review')).toBe(false);
+        expect(shouldSkip('merge', 'review')).toBe(false);
+    });
+    it('resuming at "merge" skips everything before merge', () => {
+        for (const step of stepOrder.slice(0, -1)) {
+            expect(shouldSkip(step, 'merge')).toBe(true);
+        }
+        expect(shouldSkip('merge', 'merge')).toBe(false);
+    });
+    it('steps not in stepOrder return -1 index (treated as "skip nothing")', () => {
+        // 'done' and 'failed' are not in stepOrder, so indexOf returns -1
+        // This means skipToIndex = -1, and all steps have index >= 0, so nothing is skipped
+        // unless the step itself is also not in the list
+        const skipToIndex = stepOrder.indexOf('done');
+        expect(skipToIndex).toBe(-1);
+    });
+});
+// ─── Test extractIssueFromBranch pattern ───
+describe('extractIssueFromBranch pattern', () => {
+    // Mirrors the actual implementation: branch.match(/#?(\d+)/)
+    function extractIssueFromBranch(branch) {
+        const match = branch.match(/#?(\d+)/);
+        return match ? parseInt(match[1], 10) : null;
+    }
+    it('extracts from "feat/#42-auth"', () => {
+        expect(extractIssueFromBranch('feat/#42-auth')).toBe(42);
+    });
+    it('extracts from "feat/42-auth"', () => {
+        expect(extractIssueFromBranch('feat/42-auth')).toBe(42);
+    });
+    it('returns null for "feat/add-login"', () => {
+        expect(extractIssueFromBranch('feat/add-login')).toBeNull();
+    });
+    it('extracts first number from "feat/#42-fix-issue-99"', () => {
+        expect(extractIssueFromBranch('feat/#42-fix-issue-99')).toBe(42);
+    });
+    it('handles plain number branches like "42-auth"', () => {
+        expect(extractIssueFromBranch('42-auth')).toBe(42);
+    });
+});
+// ─── Test recovered pipeline identification pattern ───
+describe('recovered pipeline identification', () => {
+    it('identifies recovered pipelines by workerId === -1', () => {
+        const state = emptyState(1);
+        state.pipelines['#42'] = {
+            taskId: '#42',
+            workerId: -1,
+            worktreePath: '/wt/feat-42',
+            step: 'review',
+            architectPlan: null,
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: null,
+            reviewCycles: 0,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: null,
+            prState: null,
+        };
+        state.pipelines['p1-1'] = {
+            taskId: 'p1-1',
+            workerId: 0,
+            worktreePath: '/wt/feat-p1-1',
+            step: 'implement',
+            architectPlan: null,
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: null,
+            reviewCycles: 0,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: null,
+            prState: null,
+        };
+        const recoveredIds = Object.keys(state.pipelines).filter(id => {
+            const p = state.pipelines[id];
+            return p.workerId === -1 && p.step !== 'done' && p.step !== 'failed';
+        });
+        expect(recoveredIds).toEqual(['#42']);
+    });
+    it('excludes done and failed pipelines from recovery', () => {
+        const state = emptyState(1);
+        state.pipelines['#50'] = {
+            taskId: '#50',
+            workerId: -1,
+            worktreePath: '/wt/feat-50',
+            step: 'done',
+            architectPlan: null,
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: null,
+            reviewCycles: 0,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: null,
+            prState: null,
+        };
+        const recoveredIds = Object.keys(state.pipelines).filter(id => {
+            const p = state.pipelines[id];
+            return p.workerId === -1 && p.step !== 'done' && p.step !== 'failed';
+        });
+        expect(recoveredIds).toHaveLength(0);
+    });
+});

package/dist/scheduler/recovery.spec.js

@@ -0,0 +1,121 @@
+// ─── Recovery & git workflow tests ───
+// Tests for diagnoseStep, extractIssueFromBranch, getOpenMRs,
+// closeRecoveredIssue, and shouldSkip pipeline resume logic.
+//
+// Pure function tests — no mocks needed.
+// @ts-ignore bun:test
+import { describe, it, expect } from 'bun:test';
+import { diagnoseStep, extractIssueFromBranch, getOpenMRs, } from './loop.mjs';
+// ─── diagnoseStep ───
+// Note: diagnoseStep calls getPRStatus which calls execFileSync.
+// For unit tests we test the logic indirectly — the function falls back
+// to 'review' when getPRStatus throws (which happens when not in a real repo).
+describe('diagnoseStep', () => {
+    it('returns "review" when CI platform is "none"', () => {
+        expect(diagnoseStep('/nonexistent', 'feat/42-auth', 'none')).toBe('review');
+    });
+    it('returns "review" when getPRStatus throws (no PR/no repo)', () => {
+        // /nonexistent is not a repo, so getPRStatus will throw
+        expect(diagnoseStep('/nonexistent', 'feat/42-auth', 'github')).toBe('review');
+    });
+    it('returns "review" for gitlab when no PR exists', () => {
+        expect(diagnoseStep('/nonexistent', 'feat/42-auth', 'gitlab')).toBe('review');
+    });
+});
+// ─── extractIssueFromBranch ───
+describe('extractIssueFromBranch', () => {
+    it('extracts number from "feat/#94-description"', () => {
+        expect(extractIssueFromBranch('feat/#94-user-auth')).toBe(94);
+    });
+    it('extracts number from "feat/94-description"', () => {
+        expect(extractIssueFromBranch('feat/94-add-login')).toBe(94);
+    });
+    it('returns null for branches without numbers', () => {
+        expect(extractIssueFromBranch('feat/add-login-page')).toBeNull();
+    });
+    it('extracts first number from branch with multiple numbers', () => {
+        expect(extractIssueFromBranch('feat/#42-fix-issue-99')).toBe(42);
+    });
+    it('extracts number from simple format', () => {
+        expect(extractIssueFromBranch('#7')).toBe(7);
+    });
+    it('returns null for empty string', () => {
+        expect(extractIssueFromBranch('')).toBeNull();
+    });
+});
+// ─── getOpenMRs ───
+describe('getOpenMRs', () => {
+    it('returns empty array when CLI not available', () => {
+        // /nonexistent is not a repo, so CLI will fail
+        expect(getOpenMRs('/nonexistent', 'github')).toEqual([]);
+    });
+    it('returns empty array for gitlab when CLI not available', () => {
+        expect(getOpenMRs('/nonexistent', 'gitlab')).toEqual([]);
+    });
+});
+// ─── shouldSkip pipeline resume (unit test of the pattern) ───
+describe('shouldSkip pipeline resume', () => {
+    // Replicate the exact shouldSkip logic from runTaskPipeline
+    const stepOrder = ['plan', 'implement', 'test', 'review', 'rework', 'commit', 'pr-create', 'pr-watch', 'merge'];
+    function shouldSkip(step, resumeStep) {
+        const skipToIndex = stepOrder.indexOf(resumeStep);
+        return stepOrder.indexOf(step) < skipToIndex;
+    }
+    it('pipeline at "review" skips plan, implement, test', () => {
+        expect(shouldSkip('plan', 'review')).toBe(true);
+        expect(shouldSkip('implement', 'review')).toBe(true);
+        expect(shouldSkip('test', 'review')).toBe(true);
+        expect(shouldSkip('review', 'review')).toBe(false);
+        expect(shouldSkip('commit', 'review')).toBe(false);
+    });
+    it('pipeline at "rework" skips plan through review', () => {
+        expect(shouldSkip('plan', 'rework')).toBe(true);
+        expect(shouldSkip('implement', 'rework')).toBe(true);
+        expect(shouldSkip('test', 'rework')).toBe(true);
+        expect(shouldSkip('review', 'rework')).toBe(true);
+        expect(shouldSkip('rework', 'rework')).toBe(false);
+    });
+    it('pipeline at "merge" skips everything before merge', () => {
+        expect(shouldSkip('plan', 'merge')).toBe(true);
+        expect(shouldSkip('commit', 'merge')).toBe(true);
+        expect(shouldSkip('pr-watch', 'merge')).toBe(true);
+        expect(shouldSkip('merge', 'merge')).toBe(false);
+    });
+    it('pipeline at "plan" skips nothing (fresh)', () => {
+        expect(shouldSkip('plan', 'plan')).toBe(false);
+        expect(shouldSkip('implement', 'plan')).toBe(false);
+        expect(shouldSkip('review', 'plan')).toBe(false);
+    });
+    it('pipeline at "pr-watch" skips through pr-create', () => {
+        expect(shouldSkip('pr-create', 'pr-watch')).toBe(true);
+        expect(shouldSkip('pr-watch', 'pr-watch')).toBe(false);
+        expect(shouldSkip('merge', 'pr-watch')).toBe(false);
+    });
+    it('pipeline at "commit" skips through rework', () => {
+        expect(shouldSkip('rework', 'commit')).toBe(true);
+        expect(shouldSkip('commit', 'commit')).toBe(false);
+    });
+    it('step not in stepOrder is treated as before all steps (indexOf=-1)', () => {
+        // 'done' is not in stepOrder, indexOf returns -1, which is < any skipToIndex
+        expect(shouldSkip('done', 'review')).toBe(true);
+        // But if resumeStep is 'plan' (index 0), -1 < 0 is true
+        expect(shouldSkip('done', 'plan')).toBe(true);
+    });
+});
+// ─── Recovered pipeline identification ───
+describe('recovered pipeline identification', () => {
+    it('workerId=-1 identifies recovered pipelines', () => {
+        const pipelines = {
+            '#1': { workerId: -1, step: 'review' },
+            '#2': { workerId: 0, step: 'implement' },
+            '#3': { workerId: -1, step: 'done' },
+            '#4': { workerId: -1, step: 'failed' },
+            '#5': { workerId: -1, step: 'rework' },
+        };
+        const recoveredIds = Object.keys(pipelines).filter(id => {
+            const p = pipelines[id];
+            return p.workerId === -1 && p.step !== 'done' && p.step !== 'failed';
+        });
+        expect(recoveredIds).toEqual(['#1', '#5']);
+    });
+});

package/package.json

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