create-claude-workspace 1.1.151 → 2.0.0

package/dist/scheduler/agents/worker-pool.spec.js

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi } from 'vitest';
+import { WorkerPool } from './worker-pool.mjs';
+const mockLogger = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+};
+// ─── Unit tests (no real SDK calls) ───
+describe('WorkerPool', () => {
+    it('initializes with correct number of workers', () => {
+        const pool = new WorkerPool({ concurrency: 3, maxTurns: 50, skipPermissions: false, logger: mockLogger });
+        expect(pool.slots).toHaveLength(3);
+        expect(pool.activeCount()).toBe(0);
+    });
+    it('all workers start idle', () => {
+        const pool = new WorkerPool({ concurrency: 2, maxTurns: 50, skipPermissions: false, logger: mockLogger });
+        for (const slot of pool.slots) {
+            expect(slot.status).toBe('idle');
+            expect(slot.taskId).toBeNull();
+        }
+    });
+    it('finds idle slot', () => {
+        const pool = new WorkerPool({ concurrency: 2, maxTurns: 50, skipPermissions: false, logger: mockLogger });
+        const idle = pool.idleSlot();
+        expect(idle).not.toBeNull();
+        expect(idle.id).toBe(0);
+    });
+    it('gets slot by id', () => {
+        const pool = new WorkerPool({ concurrency: 3, maxTurns: 50, skipPermissions: false, logger: mockLogger });
+        expect(pool.getSlot(0)?.id).toBe(0);
+        expect(pool.getSlot(2)?.id).toBe(2);
+        expect(pool.getSlot(99)).toBeNull();
+    });
+    it('rejects spawn on invalid slot', async () => {
+        const pool = new WorkerPool({ concurrency: 1, maxTurns: 50, skipPermissions: false, logger: mockLogger });
+        await expect(pool.spawn(99, { cwd: '/tmp', prompt: 'test' })).rejects.toThrow('Invalid worker slot');
+    });
+    it('resets all workers', () => {
+        const pool = new WorkerPool({ concurrency: 2, maxTurns: 50, skipPermissions: false, logger: mockLogger });
+        pool.reset();
+        expect(pool.slots).toHaveLength(2);
+        expect(pool.activeCount()).toBe(0);
+    });
+});

package/dist/scheduler/git/ci-watcher.mjs

@@ -0,0 +1,93 @@
+// ─── CI pipeline status polling ───
+// Uses gh/glab CLI to watch pipeline status after push.
+import { execSync } from 'node:child_process';
+const POLL_INTERVAL = 15_000;
+const MAX_POLL_TIME = 30 * 60_000; // 30 minutes
+export function detectCIPlatform(projectDir) {
+    try {
+        const remote = execSync('git remote get-url origin', { cwd: projectDir, encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (remote.includes('github.com') || remote.includes('github:'))
+            return 'github';
+        if (remote.includes('gitlab.com') || remote.includes('gitlab:') || remote.includes('gitlab'))
+            return 'gitlab';
+    }
+    catch { /* ignore */ }
+    return 'none';
+}
+export async function watchPipeline(branch, platform, projectDir, logger, signal) {
+    if (platform === 'none') {
+        return { status: 'not-found' };
+    }
+    const startTime = Date.now();
+    while (Date.now() - startTime < MAX_POLL_TIME) {
+        if (signal?.stopped)
+            return { status: 'canceled' };
+        const status = platform === 'github'
+            ? pollGitHub(branch, projectDir)
+            : pollGitLab(branch, projectDir);
+        if (status === 'passed' || status === 'failed' || status === 'canceled') {
+            const logs = status === 'failed'
+                ? fetchFailureLogs(branch, platform, projectDir)
+                : undefined;
+            return { status, logs };
+        }
+        logger.info(`CI: ${status}, waiting ${POLL_INTERVAL / 1000}s...`);
+        await sleep(POLL_INTERVAL);
+    }
+    return { status: 'timeout' };
+}
+function pollGitHub(branch, cwd) {
+    try {
+        const output = execSync(`gh run list --branch "${branch}" --limit 1 --json status,conclusion`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 15_000 }).trim();
+        const runs = JSON.parse(output);
+        if (!runs.length)
+            return 'not-found';
+        const run = runs[0];
+        if (run.status === 'completed') {
+            return run.conclusion === 'success' ? 'passed' : 'failed';
+        }
+        return 'pending';
+    }
+    catch {
+        return 'not-found';
+    }
+}
+function pollGitLab(branch, cwd) {
+    try {
+        const output = execSync(`glab ci list --branch "${branch}" --output json`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 15_000 }).trim();
+        const pipelines = JSON.parse(output);
+        if (!pipelines.length)
+            return 'not-found';
+        const pipeline = pipelines[0];
+        switch (pipeline.status) {
+            case 'success': return 'passed';
+            case 'failed': return 'failed';
+            case 'canceled': return 'canceled';
+            default: return 'pending';
+        }
+    }
+    catch {
+        return 'not-found';
+    }
+}
+export function fetchFailureLogs(branch, platform, cwd) {
+    try {
+        if (platform === 'github') {
+            // Get the latest failed run ID and fetch logs
+            const runsOutput = execSync(`gh run list --branch "${branch}" --limit 1 --json databaseId,conclusion`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 15_000 }).trim();
+            const runs = JSON.parse(runsOutput);
+            if (!runs.length)
+                return undefined;
+            const runId = runs[0].databaseId;
+            return execSync(`gh run view ${runId} --log-failed`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 30_000 }).trim();
+        }
+        if (platform === 'gitlab') {
+            return execSync(`glab ci trace --branch "${branch}"`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 30_000 }).trim();
+        }
+    }
+    catch { /* ignore */ }
+    return undefined;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/scheduler/git/ci-watcher.spec.js

@@ -0,0 +1,35 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { detectCIPlatform } from './ci-watcher.mjs';
+let testDir;
+beforeEach(() => {
+    testDir = mkdtempSync(join(tmpdir(), 'ci-watcher-test-'));
+    execSync('git init -b main', { cwd: testDir, stdio: 'pipe' });
+    execSync('git config user.name "Test"', { cwd: testDir, stdio: 'pipe' });
+    execSync('git config user.email "test@test.com"', { cwd: testDir, stdio: 'pipe' });
+    writeFileSync(resolve(testDir, 'file.txt'), 'init');
+    execSync('git add . && git commit -m "init"', { cwd: testDir, stdio: 'pipe' });
+});
+afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+});
+describe('detectCIPlatform', () => {
+    it('returns none for repo without remote', () => {
+        expect(detectCIPlatform(testDir)).toBe('none');
+    });
+    it('detects github from remote URL', () => {
+        execSync('git remote add origin https://github.com/user/repo.git', { cwd: testDir, stdio: 'pipe' });
+        expect(detectCIPlatform(testDir)).toBe('github');
+    });
+    it('detects gitlab from remote URL', () => {
+        execSync('git remote add origin https://gitlab.com/user/repo.git', { cwd: testDir, stdio: 'pipe' });
+        expect(detectCIPlatform(testDir)).toBe('gitlab');
+    });
+    it('detects github from SSH URL', () => {
+        execSync('git remote add origin git@github.com:user/repo.git', { cwd: testDir, stdio: 'pipe' });
+        expect(detectCIPlatform(testDir)).toBe('github');
+    });
+});

package/dist/scheduler/git/manager.mjs

@@ -0,0 +1,228 @@
+// ─── Deterministic git operations ───
+// All operations use execSync — git is fast and must complete before the next step.
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+const GIT_TIMEOUT = 30_000;
+const PUSH_TIMEOUT = 60_000;
+function git(args, cwd, timeout = GIT_TIMEOUT) {
+    return execSync(`git ${args}`, { cwd, timeout, stdio: 'pipe', encoding: 'utf-8' }).trim();
+}
+// ─── Worktree operations ───
+export function createWorktree(projectDir, branchSlug, baseBranch) {
+    const worktreePath = resolve(projectDir, '.worktrees', branchSlug);
+    const base = baseBranch ?? getMainBranch(projectDir);
+    if (existsSync(worktreePath)) {
+        return worktreePath;
+    }
+    git(`worktree add "${worktreePath}" -b "${branchSlug}" "${base}"`, projectDir);
+    return worktreePath;
+}
+export function cleanupWorktree(projectDir, worktreePath, branch) {
+    try {
+        git(`worktree remove "${worktreePath}" --force`, projectDir);
+    }
+    catch { /* may already be removed */ }
+    try {
+        git(`branch -d "${branch}"`, projectDir);
+    }
+    catch { /* may already be deleted */ }
+}
+export function listWorktrees(projectDir) {
+    const output = git('worktree list --porcelain', projectDir);
+    const mainNorm = normalizePath(resolve(projectDir));
+    const paths = [];
+    for (const line of output.split('\n')) {
+        if (line.startsWith('worktree ')) {
+            const path = line.slice('worktree '.length).trim();
+            // Skip the main worktree (normalize for Windows path comparison)
+            if (normalizePath(path) !== mainNorm) {
+                paths.push(path);
+            }
+        }
+    }
+    return paths;
+}
+export function listOrphanedWorktrees(projectDir, knownWorktrees) {
+    const actual = listWorktrees(projectDir);
+    const knownSet = new Set(knownWorktrees.map(p => normalizePath(resolve(p))));
+    return actual.filter(p => !knownSet.has(normalizePath(resolve(p))));
+}
+// ─── Commit operations ───
+export function commitInWorktree(worktreePath, message) {
+    git('add -A', worktreePath);
+    // Check if there's anything to commit
+    const status = git('status --porcelain', worktreePath);
+    if (!status)
+        return '';
+    git(`commit -m "${escapeMsg(message)}"`, worktreePath);
+    return git('rev-parse HEAD', worktreePath);
+}
+export function getChangedFiles(worktreePath) {
+    try {
+        const mainBranch = getMainBranch(worktreePath);
+        const output = git(`diff --name-only "${mainBranch}"...HEAD`, worktreePath);
+        return output ? output.split('\n').filter(f => f.length > 0) : [];
+    }
+    catch {
+        // Fallback: diff against parent
+        try {
+            const output = git('diff --name-only HEAD~1', worktreePath);
+            return output ? output.split('\n').filter(f => f.length > 0) : [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+export function hasUncommittedChanges(dir) {
+    const status = git('status --porcelain', dir);
+    return status.length > 0;
+}
+// ─── Push operations ───
+export function pushWorktree(worktreePath) {
+    try {
+        const branch = git('rev-parse --abbrev-ref HEAD', worktreePath);
+        git(`push -u origin "${branch}"`, worktreePath, PUSH_TIMEOUT);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function forcePushWorktree(worktreePath) {
+    try {
+        const branch = git('rev-parse --abbrev-ref HEAD', worktreePath);
+        git(`push --force-with-lease -u origin "${branch}"`, worktreePath, PUSH_TIMEOUT);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function mergeToMain(projectDir, branch) {
+    const main = getMainBranch(projectDir);
+    try {
+        git(`merge "${branch}" --no-ff -m "Merge ${branch}"`, projectDir);
+        const sha = git('rev-parse HEAD', projectDir);
+        return { success: true, sha, conflict: false };
+    }
+    catch (err) {
+        const isConflict = hasConflicts(projectDir);
+        if (isConflict) {
+            git('merge --abort', projectDir);
+        }
+        return {
+            success: false,
+            sha: null,
+            conflict: isConflict,
+            error: err.message,
+        };
+    }
+}
+function hasConflicts(dir) {
+    try {
+        const status = git('status --porcelain', dir);
+        return status.includes('UU ') || status.includes('AA ') || status.includes('DD ');
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Branch / sync operations ───
+export function syncMain(projectDir) {
+    try {
+        git('fetch --quiet', projectDir);
+        git('pull --ff-only --quiet', projectDir, PUSH_TIMEOUT);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getMainBranch(projectDir) {
+    try {
+        // Check for remote HEAD
+        const ref = git('symbolic-ref refs/remotes/origin/HEAD', projectDir);
+        return ref.replace('refs/remotes/origin/', '');
+    }
+    catch {
+        // Fallback: check common names
+        try {
+            git('rev-parse --verify main', projectDir);
+            return 'main';
+        }
+        catch {
+            return 'master';
+        }
+    }
+}
+export function getCurrentBranch(dir) {
+    return git('rev-parse --abbrev-ref HEAD', dir);
+}
+export function branchExists(projectDir, branch) {
+    try {
+        git(`rev-parse --verify "${branch}"`, projectDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isBranchMerged(projectDir, branch) {
+    try {
+        const main = getMainBranch(projectDir);
+        // Check if branch tip is an ancestor of main (i.e., was merged)
+        git(`merge-base --is-ancestor "${branch}" "${main}"`, projectDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Git identity ───
+export function hasGitIdentity(projectDir) {
+    try {
+        git('config user.name', projectDir);
+        git('config user.email', projectDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Tag operations ───
+export function createTag(projectDir, tag, message) {
+    try {
+        const msgArg = message ? `-m "${escapeMsg(message)}"` : '';
+        git(`tag -a "${tag}" ${msgArg}`, projectDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getLatestTag(projectDir) {
+    try {
+        return git('describe --tags --abbrev=0', projectDir);
+    }
+    catch {
+        return null;
+    }
+}
+export function pushTags(projectDir) {
+    try {
+        git('push --tags', projectDir, PUSH_TIMEOUT);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Helpers ───
+function escapeMsg(msg) {
+    return msg.replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}
+function normalizePath(p) {
+    return p.replace(/\\/g, '/').toLowerCase();
+}

package/dist/scheduler/git/manager.spec.js

@@ -0,0 +1,198 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, existsSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { rmSync } from 'node:fs';
+import { createWorktree, cleanupWorktree, listWorktrees, listOrphanedWorktrees, commitInWorktree, getChangedFiles, hasUncommittedChanges, mergeToMain, getMainBranch, getCurrentBranch, branchExists, isBranchMerged, hasGitIdentity, createTag, getLatestTag, } from './manager.mjs';
+let repoDir;
+function gitCmd(args, cwd) {
+    return execSync(`git ${args}`, { cwd: cwd ?? repoDir, encoding: 'utf-8', stdio: 'pipe' }).trim();
+}
+beforeEach(() => {
+    repoDir = mkdtempSync(join(tmpdir(), 'git-manager-test-'));
+    // Initialize a git repo with an initial commit
+    gitCmd('init -b main');
+    gitCmd('config user.name "Test User"');
+    gitCmd('config user.email "test@example.com"');
+    writeFileSync(resolve(repoDir, 'README.md'), '# Test');
+    gitCmd('add .');
+    gitCmd('commit -m "initial commit"');
+});
+afterEach(() => {
+    // Clean up worktrees before removing the directory
+    try {
+        const worktrees = listWorktrees(repoDir);
+        for (const wt of worktrees) {
+            try {
+                gitCmd(`worktree remove "${wt}" --force`);
+            }
+            catch { /* */ }
+        }
+    }
+    catch { /* */ }
+    rmSync(repoDir, { recursive: true, force: true });
+});
+// ─── Main branch detection ───
+describe('getMainBranch', () => {
+    it('detects main branch', () => {
+        expect(getMainBranch(repoDir)).toBe('main');
+    });
+});
+// ─── getCurrentBranch ───
+describe('getCurrentBranch', () => {
+    it('returns current branch name', () => {
+        expect(getCurrentBranch(repoDir)).toBe('main');
+    });
+});
+// ─── Git identity ───
+describe('hasGitIdentity', () => {
+    it('returns true when identity is configured', () => {
+        expect(hasGitIdentity(repoDir)).toBe(true);
+    });
+});
+// ─── Worktree operations ───
+describe('createWorktree', () => {
+    it('creates a worktree with a new branch', () => {
+        const wtPath = createWorktree(repoDir, 'feat/test-feature');
+        expect(existsSync(wtPath)).toBe(true);
+        expect(getCurrentBranch(wtPath)).toBe('feat/test-feature');
+    });
+    it('returns existing path if worktree already exists', () => {
+        const path1 = createWorktree(repoDir, 'feat/existing');
+        const path2 = createWorktree(repoDir, 'feat/existing');
+        expect(path1).toBe(path2);
+    });
+});
+describe('listWorktrees', () => {
+    it('lists only non-main worktrees', () => {
+        createWorktree(repoDir, 'feat/a');
+        createWorktree(repoDir, 'feat/b');
+        const wts = listWorktrees(repoDir);
+        expect(wts).toHaveLength(2);
+    });
+    it('returns empty when no worktrees', () => {
+        expect(listWorktrees(repoDir)).toEqual([]);
+    });
+});
+describe('listOrphanedWorktrees', () => {
+    it('identifies orphaned worktrees', () => {
+        const wt1 = createWorktree(repoDir, 'feat/known');
+        createWorktree(repoDir, 'feat/orphan');
+        const orphans = listOrphanedWorktrees(repoDir, [wt1]);
+        expect(orphans).toHaveLength(1);
+    });
+});
+describe('cleanupWorktree', () => {
+    it('removes worktree and branch', () => {
+        const wtPath = createWorktree(repoDir, 'feat/to-remove');
+        cleanupWorktree(repoDir, wtPath, 'feat/to-remove');
+        expect(existsSync(wtPath)).toBe(false);
+        expect(branchExists(repoDir, 'feat/to-remove')).toBe(false);
+    });
+    it('handles already-removed worktree gracefully', () => {
+        expect(() => cleanupWorktree(repoDir, '/nonexistent', 'nonexistent')).not.toThrow();
+    });
+});
+// ─── Commit operations ───
+describe('commitInWorktree', () => {
+    it('commits changes and returns SHA', () => {
+        const wtPath = createWorktree(repoDir, 'feat/commit-test');
+        writeFileSync(resolve(wtPath, 'new-file.ts'), 'export const x = 1;');
+        const sha = commitInWorktree(wtPath, 'feat: add new file');
+        expect(sha).toMatch(/^[0-9a-f]{40}$/);
+    });
+    it('returns empty string when nothing to commit', () => {
+        const wtPath = createWorktree(repoDir, 'feat/empty-commit');
+        const sha = commitInWorktree(wtPath, 'empty');
+        expect(sha).toBe('');
+    });
+});
+describe('getChangedFiles', () => {
+    it('lists changed files relative to main', () => {
+        const wtPath = createWorktree(repoDir, 'feat/changes');
+        writeFileSync(resolve(wtPath, 'a.ts'), 'a');
+        writeFileSync(resolve(wtPath, 'b.ts'), 'b');
+        commitInWorktree(wtPath, 'add files');
+        const changed = getChangedFiles(wtPath);
+        expect(changed).toContain('a.ts');
+        expect(changed).toContain('b.ts');
+        expect(changed).not.toContain('README.md');
+    });
+});
+describe('hasUncommittedChanges', () => {
+    it('returns false for clean repo', () => {
+        expect(hasUncommittedChanges(repoDir)).toBe(false);
+    });
+    it('returns true when files are modified', () => {
+        writeFileSync(resolve(repoDir, 'dirty.txt'), 'dirty');
+        expect(hasUncommittedChanges(repoDir)).toBe(true);
+    });
+});
+// ─── Merge operations ───
+describe('mergeToMain', () => {
+    it('merges a branch into main', () => {
+        const wtPath = createWorktree(repoDir, 'feat/to-merge');
+        writeFileSync(resolve(wtPath, 'feature.ts'), 'export const feature = true;');
+        commitInWorktree(wtPath, 'feat: add feature');
+        const result = mergeToMain(repoDir, 'feat/to-merge');
+        expect(result.success).toBe(true);
+        expect(result.sha).toMatch(/^[0-9a-f]{40}$/);
+        expect(result.conflict).toBe(false);
+    });
+    it('detects merge conflicts', () => {
+        // Create conflicting changes
+        const wtPath = createWorktree(repoDir, 'feat/conflict');
+        writeFileSync(resolve(wtPath, 'README.md'), '# Conflicting change');
+        commitInWorktree(wtPath, 'feat: conflict branch');
+        // Modify same file on main
+        writeFileSync(resolve(repoDir, 'README.md'), '# Different change on main');
+        gitCmd('add .', repoDir);
+        gitCmd('commit -m "main change"', repoDir);
+        const result = mergeToMain(repoDir, 'feat/conflict');
+        expect(result.success).toBe(false);
+        expect(result.conflict).toBe(true);
+    });
+});
+// ─── Branch operations ───
+describe('branchExists', () => {
+    it('returns true for existing branch', () => {
+        expect(branchExists(repoDir, 'main')).toBe(true);
+    });
+    it('returns false for non-existing branch', () => {
+        expect(branchExists(repoDir, 'nonexistent')).toBe(false);
+    });
+});
+describe('isBranchMerged', () => {
+    it('returns true for merged branch', () => {
+        const wtPath = createWorktree(repoDir, 'feat/merged');
+        writeFileSync(resolve(wtPath, 'merged.ts'), 'done');
+        commitInWorktree(wtPath, 'feat: merged');
+        mergeToMain(repoDir, 'feat/merged');
+        expect(isBranchMerged(repoDir, 'feat/merged')).toBe(true);
+    });
+    it('returns false for unmerged branch', () => {
+        const wtPath = createWorktree(repoDir, 'feat/unmerged');
+        writeFileSync(resolve(wtPath, 'unmerged.ts'), 'pending');
+        commitInWorktree(wtPath, 'feat: unmerged');
+        expect(isBranchMerged(repoDir, 'feat/unmerged')).toBe(false);
+    });
+});
+// ─── Tags ───
+describe('createTag / getLatestTag', () => {
+    it('creates and retrieves a tag', () => {
+        expect(createTag(repoDir, 'v1.0.0', 'Release 1.0.0')).toBe(true);
+        expect(getLatestTag(repoDir)).toBe('v1.0.0');
+    });
+    it('returns null when no tags exist', () => {
+        expect(getLatestTag(repoDir)).toBeNull();
+    });
+    it('returns the latest tag', () => {
+        createTag(repoDir, 'v0.1.0', 'first');
+        writeFileSync(resolve(repoDir, 'after-tag.txt'), 'x');
+        gitCmd('add .', repoDir);
+        gitCmd('commit -m "after"', repoDir);
+        createTag(repoDir, 'v0.2.0', 'second');
+        expect(getLatestTag(repoDir)).toBe('v0.2.0');
+    });
+});