create-claude-workspace 2.1.11 → 2.2.0

package/dist/scheduler/agents/prompt-builder.mjs

@@ -178,6 +178,27 @@ export function buildCIFixPrompt(ctx, ciLogs) {
         `- Run build/lint/tests locally to verify the fix`,
     ].join('\n');
 }
+// ─── PR comment resolution prompt ───
+export function buildPRCommentPrompt(ctx, comments) {
+    return [
+        `Address the following code review comments on your PR/MR.`,
+        ``,
+        `## Task`,
+        `**${ctx.task.title}**`,
+        ``,
+        `## Working Directory`,
+        ctx.worktreePath,
+        ``,
+        `## Review Comments`,
+        comments,
+        ``,
+        `## Instructions`,
+        `- Address each comment by making the requested changes`,
+        `- If a comment is incorrect or unnecessary, add a brief explanation in the code`,
+        `- Run build/lint/tests locally to verify your changes`,
+        `- Do NOT dismiss or ignore valid feedback`,
+    ].join('\n');
+}
 // ─── Phase transition prompt (for product-owner re-evaluation) ───
 export function buildPhaseTransitionPrompt(completedPhase, nextPhase) {
     return [

package/dist/scheduler/git/manager.mjs

@@ -219,6 +219,84 @@ export function pushTags(projectDir) {
         return false;
     }
 }
+export function rebaseOnMain(worktreePath, projectDir) {
+    try {
+        const main = getMainBranch(projectDir);
+        git(`fetch origin "${main}"`, worktreePath, PUSH_TIMEOUT);
+        git(`rebase "origin/${main}"`, worktreePath, PUSH_TIMEOUT);
+        return { success: true, conflict: false };
+    }
+    catch (err) {
+        // Check if rebase is in progress (conflict)
+        try {
+            const status = git('status --porcelain', worktreePath);
+            if (status.includes('UU ') || status.includes('AA ') || status.includes('DD ')) {
+                git('rebase --abort', worktreePath);
+                return { success: false, conflict: true, error: err.message };
+            }
+        }
+        catch { /* ignore */ }
+        // Abort any in-progress rebase
+        try {
+            git('rebase --abort', worktreePath);
+        }
+        catch { /* ignore */ }
+        return { success: false, conflict: false, error: err.message };
+    }
+}
+// ─── Stash operations ───
+export function stashChanges(dir) {
+    const status = git('status --porcelain', dir);
+    if (!status)
+        return false;
+    try {
+        git('stash --include-untracked', dir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function popStash(dir) {
+    try {
+        git('stash pop', dir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Dirty main evaluation ───
+const TRACKING_FILES = new Set(['TODO.md', 'MEMORY.md']);
+export function evaluateDirtyMain(projectDir) {
+    const status = git('status --porcelain', projectDir);
+    if (!status)
+        return { trackingFiles: [], userFiles: [] };
+    const trackingFiles = [];
+    const userFiles = [];
+    for (const line of status.split('\n')) {
+        // Format: "XY filename" where XY is 2-char status
+        const file = line.slice(3).trim();
+        if (!file)
+            continue;
+        if (TRACKING_FILES.has(file)) {
+            trackingFiles.push(file);
+        }
+        else {
+            userFiles.push(file);
+        }
+    }
+    return { trackingFiles, userFiles };
+}
+export function discardFiles(dir, files) {
+    if (files.length === 0)
+        return;
+    const fileArgs = files.map(f => `"${f}"`).join(' ');
+    try {
+        git(`checkout -- ${fileArgs}`, dir);
+    }
+    catch { /* file may not exist in index */ }
+}
 // ─── Helpers ───
 function escapeMsg(msg) {
     return msg.replace(/"/g, '\\"').replace(/\n/g, '\\n');

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

@@ -4,7 +4,7 @@ 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';
+import { createWorktree, cleanupWorktree, listWorktrees, listOrphanedWorktrees, commitInWorktree, getChangedFiles, hasUncommittedChanges, mergeToMain, getMainBranch, getCurrentBranch, branchExists, isBranchMerged, hasGitIdentity, createTag, getLatestTag, rebaseOnMain, stashChanges, popStash, evaluateDirtyMain, discardFiles, } from './manager.mjs';
 let repoDir;
 function gitCmd(args, cwd) {
     return execSync(`git ${args}`, { cwd: cwd ?? repoDir, encoding: 'utf-8', stdio: 'pipe' }).trim();
@@ -196,3 +196,65 @@ describe('createTag / getLatestTag', () => {
         expect(getLatestTag(repoDir)).toBe('v0.2.0');
     });
 });
+describe('rebaseOnMain', () => {
+    it('rebases worktree onto main successfully', () => {
+        // Create worktree with a commit
+        const wtPath = createWorktree(repoDir, 'feat/rebase-test');
+        writeFileSync(resolve(wtPath, 'feature.ts'), 'export const x = 1;');
+        commitInWorktree(wtPath, 'feat: add feature');
+        // Add a commit on main to create divergence
+        writeFileSync(resolve(repoDir, 'main-change.ts'), 'export const y = 2;');
+        gitCmd('add .', repoDir);
+        gitCmd('commit -m "main: parallel change"', repoDir);
+        const result = rebaseOnMain(wtPath, repoDir);
+        // May fail without remote — test the interface
+        expect(result).toHaveProperty('success');
+        expect(result).toHaveProperty('conflict');
+    });
+});
+describe('stashChanges / popStash', () => {
+    it('stashes and pops changes', () => {
+        writeFileSync(resolve(repoDir, 'dirty.txt'), 'uncommitted');
+        expect(stashChanges(repoDir)).toBe(true);
+        expect(hasUncommittedChanges(repoDir)).toBe(false);
+        expect(popStash(repoDir)).toBe(true);
+        expect(hasUncommittedChanges(repoDir)).toBe(true);
+        // Cleanup
+        gitCmd('checkout -- .', repoDir);
+    });
+    it('returns false when nothing to stash', () => {
+        expect(stashChanges(repoDir)).toBe(false);
+    });
+});
+describe('evaluateDirtyMain', () => {
+    it('returns empty when clean', () => {
+        const result = evaluateDirtyMain(repoDir);
+        expect(result.trackingFiles).toEqual([]);
+        expect(result.userFiles).toEqual([]);
+    });
+    it('separates tracking files from user files', () => {
+        writeFileSync(resolve(repoDir, 'TODO.md'), '# TODO');
+        writeFileSync(resolve(repoDir, 'MEMORY.md'), '# Memory');
+        writeFileSync(resolve(repoDir, 'custom.ts'), 'code');
+        gitCmd('add .', repoDir);
+        const result = evaluateDirtyMain(repoDir);
+        expect(result.trackingFiles).toContain('TODO.md');
+        expect(result.trackingFiles).toContain('MEMORY.md');
+        expect(result.userFiles).toContain('custom.ts');
+        // Cleanup
+        gitCmd('reset HEAD .', repoDir);
+        gitCmd('checkout -- .', repoDir);
+    });
+});
+describe('discardFiles', () => {
+    it('discards specific files', () => {
+        writeFileSync(resolve(repoDir, 'README.md'), '# Modified');
+        expect(hasUncommittedChanges(repoDir)).toBe(true);
+        discardFiles(repoDir, ['README.md']);
+        expect(hasUncommittedChanges(repoDir)).toBe(false);
+    });
+    it('does nothing for empty file list', () => {
+        discardFiles(repoDir, []);
+        expect(hasUncommittedChanges(repoDir)).toBe(false);
+    });
+});

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

@@ -0,0 +1,214 @@
+// ─── PR/MR lifecycle management ───
+// Deterministic TS, zero AI tokens. Uses gh/glab CLI.
+import { execSync } from 'node:child_process';
+const READ_TIMEOUT = 30_000;
+const WRITE_TIMEOUT = 60_000;
+function cli(cmd, cwd, timeout = READ_TIMEOUT) {
+    return execSync(cmd, { cwd, timeout, stdio: 'pipe', encoding: 'utf-8' }).trim();
+}
+export function createPR(opts) {
+    const body = opts.issueNumber
+        ? `${opts.body}\n\nCloses #${opts.issueNumber}`
+        : opts.body;
+    // Escape body for shell — write to temp approach avoided, use stdin-like quoting
+    const escapedBody = body.replace(/"/g, '\\"').replace(/\n/g, '\\n');
+    const escapedTitle = opts.title.replace(/"/g, '\\"');
+    if (opts.platform === 'github') {
+        const output = cli(`gh pr create --title "${escapedTitle}" --body "${escapedBody}" --base "${opts.baseBranch}" --head "${opts.branch}" --json number,url`, opts.cwd, WRITE_TIMEOUT);
+        const pr = JSON.parse(output);
+        return {
+            number: pr.number,
+            url: pr.url,
+            status: 'open',
+            ciStatus: 'pending',
+            approvals: 0,
+            mergeable: false,
+            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);
+    return {
+        number: mr.iid,
+        url: mr.web_url,
+        status: 'open',
+        ciStatus: 'pending',
+        approvals: 0,
+        mergeable: false,
+        comments: [],
+    };
+}
+// ─── PR status ───
+export function getPRStatus(cwd, platform, branch) {
+    if (platform === 'github') {
+        return getGitHubPRStatus(cwd, branch);
+    }
+    return getGitLabMRStatus(cwd, branch);
+}
+function getGitHubPRStatus(cwd, branch) {
+    const output = cli(`gh pr view "${branch}" --json number,url,state,mergeable,reviewDecision,statusCheckRollup,comments`, cwd);
+    const pr = JSON.parse(output);
+    const ciStatus = resolveGitHubCIStatus(pr.statusCheckRollup ?? []);
+    const approvals = pr.reviewDecision === 'APPROVED' ? 1 : 0;
+    const mergeable = pr.mergeable === 'MERGEABLE' && ciStatus === 'passed';
+    return {
+        number: pr.number,
+        url: pr.url,
+        status: pr.state === 'MERGED' ? 'merged' : pr.state === 'CLOSED' ? 'closed' : 'open',
+        ciStatus,
+        approvals,
+        mergeable,
+        comments: parseGitHubComments(pr.comments ?? []),
+    };
+}
+function resolveGitHubCIStatus(checks) {
+    if (checks.length === 0)
+        return 'not-found';
+    const states = checks.map(c => c.state);
+    if (states.every(s => s === 'SUCCESS'))
+        return 'passed';
+    if (states.some(s => s === 'FAILURE' || s === 'ERROR'))
+        return 'failed';
+    if (states.some(s => s === 'PENDING' || s === 'EXPECTED'))
+        return 'pending';
+    return 'passed';
+}
+function parseGitHubComments(comments) {
+    return comments.map(c => ({
+        id: c.id,
+        author: c.author.login,
+        body: c.body,
+        resolved: false, // GitHub PR comments don't have resolved state (only review threads do)
+    }));
+}
+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 mr = JSON.parse(output);
+    const ciStatus = resolveGitLabCIStatus(mr.head_pipeline);
+    const mergeable = mr.merge_status === 'can_be_merged' && ciStatus === 'passed';
+    return {
+        number: mr.iid,
+        url: mr.web_url,
+        status: mr.state === 'merged' ? 'merged' : mr.state === 'closed' ? 'closed' : 'open',
+        ciStatus,
+        approvals: 0, // Would need separate API call; scheduler handles via mergeable check
+        mergeable,
+        comments: [], // Fetched separately via getPRComments
+    };
+}
+function resolveGitLabCIStatus(pipeline) {
+    if (!pipeline)
+        return 'not-found';
+    switch (pipeline.status) {
+        case 'success': return 'passed';
+        case 'failed': return 'failed';
+        case 'canceled': return 'canceled';
+        default: return 'pending';
+    }
+}
+// ─── PR comments ───
+export function getPRComments(cwd, platform, prNumber) {
+    if (platform === 'github') {
+        return getGitHubPRComments(cwd, prNumber);
+    }
+    return getGitLabMRComments(cwd, prNumber);
+}
+function getGitHubPRComments(cwd, prNumber) {
+    try {
+        const output = cli(`gh api repos/{owner}/{repo}/pulls/${prNumber}/reviews --jq '.[] | select(.state != "APPROVED") | {id: .id, user: .user.login, body: .body, state: .state}'`, cwd);
+        if (!output)
+            return [];
+        return output.split('\n').filter(Boolean).map(line => {
+            const review = JSON.parse(line);
+            return {
+                id: review.id,
+                author: review.user,
+                body: review.body,
+                resolved: review.state === 'DISMISSED',
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function getGitLabMRComments(cwd, mrIid) {
+    try {
+        const output = cli(`glab api projects/:id/merge_requests/${mrIid}/notes --paginate`, cwd);
+        if (!output)
+            return [];
+        const notes = JSON.parse(output);
+        return notes
+            .filter(n => n.resolvable)
+            .map(n => ({
+            id: n.id,
+            author: n.author.username,
+            body: n.body,
+            resolved: n.resolved,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+// ─── Merge PR ───
+export function mergePR(cwd, platform, prNumber, method = 'merge') {
+    try {
+        if (platform === 'github') {
+            const flag = method === 'squash' ? '--squash' : method === 'rebase' ? '--rebase' : '--merge';
+            cli(`gh pr merge ${prNumber} ${flag} --delete-branch`, cwd, WRITE_TIMEOUT);
+        }
+        else {
+            const flag = method === 'squash' ? '--squash' : '';
+            cli(`glab mr merge ${mrIid(prNumber)} ${flag} --remove-source-branch --yes`, cwd, WRITE_TIMEOUT);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function mrIid(n) {
+    return String(n);
+}
+// ─── Issue label management ───
+export function updateIssueLabels(cwd, platform, issueNumber, add, remove) {
+    try {
+        if (platform === 'github') {
+            if (remove.length > 0) {
+                for (const label of remove) {
+                    try {
+                        cli(`gh issue edit ${issueNumber} --remove-label "${label}"`, cwd);
+                    }
+                    catch { /* label may not exist */ }
+                }
+            }
+            if (add.length > 0) {
+                cli(`gh issue edit ${issueNumber} --add-label "${add.join(',')}"`, cwd);
+            }
+        }
+        else {
+            // GitLab: comma-separated labels
+            if (remove.length > 0) {
+                cli(`glab issue update ${issueNumber} --unlabel "${remove.join(',')}"`, cwd);
+            }
+            if (add.length > 0) {
+                cli(`glab issue update ${issueNumber} --label "${add.join(',')}"`, cwd);
+            }
+        }
+    }
+    catch { /* best-effort label update */ }
+}
+// ─── Close PR ───
+export function closePR(cwd, platform, prNumber) {
+    try {
+        if (platform === 'github') {
+            cli(`gh pr close ${prNumber}`, cwd);
+        }
+        else {
+            cli(`glab mr close ${prNumber}`, cwd);
+        }
+    }
+    catch { /* best-effort */ }
+}

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

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+// These tests verify the internal parsing/mapping logic.
+// CLI-dependent functions (createPR, mergePR, etc.) require a real remote
+// and are tested via integration tests.
+// Since the module uses execSync directly, we test the exported types and behavior
+// that can be validated without a real remote. For full coverage, see integration tests.
+describe('PR manager types', () => {
+    it('PRInfo has expected shape', async () => {
+        // Verify type compatibility
+        const info = {
+            number: 42,
+            url: 'https://github.com/owner/repo/pull/42',
+            status: 'open',
+            ciStatus: 'passed',
+            approvals: 1,
+            mergeable: true,
+            comments: [],
+        };
+        expect(info.number).toBe(42);
+        expect(info.status).toBe('open');
+    });
+    it('PRComment has expected shape', async () => {
+        const comment = {
+            id: 1,
+            author: 'reviewer',
+            body: 'Fix this',
+            resolved: false,
+            path: 'src/auth.ts',
+            line: 42,
+        };
+        expect(comment.resolved).toBe(false);
+        expect(comment.path).toBe('src/auth.ts');
+    });
+});

package/dist/scheduler/index.mjs

@@ -5,6 +5,8 @@ import { resolve } from 'node:path';
 import { existsSync, mkdirSync } from 'node:fs';
 import { config as dotenvConfig } from '@dotenvx/dotenvx';
 import { SCHEDULER_DEFAULTS } from './types.mjs';
+import { detectCIPlatform } from './git/ci-watcher.mjs';
+import { fetchOpenIssues } from './tasks/issue-source.mjs';
 import { emptyState, readState, writeState, appendEvent, createEvent } from './state/state.mjs';
 import { WorkerPool } from './agents/worker-pool.mjs';
 import { OrchestratorClient } from './agents/orchestrator.mjs';
@@ -122,6 +124,16 @@ export function parseSchedulerArgs(argv) {
             i++;
             continue;
         }
+        if (arg === '--task-mode') {
+            const val = strFlag(arg, i);
+            if (val !== 'local' && val !== 'platform') {
+                console.error(`--task-mode must be 'local' or 'platform'`);
+                process.exit(1);
+            }
+            mutable.taskMode = val;
+            i++;
+            continue;
+        }
         if (arg.startsWith('--')) {
             console.error(`Unknown option: ${arg}`);
             process.exit(1);
@@ -129,6 +141,19 @@ export function parseSchedulerArgs(argv) {
     }
     return opts;
 }
+function detectTaskMode(projectDir) {
+    const platform = detectCIPlatform(projectDir);
+    if (platform === 'none')
+        return 'local';
+    try {
+        const issues = fetchOpenIssues(projectDir, platform);
+        const hasStatusLabels = issues.some(i => i.labels.some(l => l.startsWith('status::')));
+        if (hasStatusLabels)
+            return 'platform';
+    }
+    catch { /* CLI not available or no issues */ }
+    return 'local';
+}
 function printSchedulerHelp() {
     console.log(`
 Multi-agent scheduler for autonomous development.
@@ -220,6 +245,21 @@ export async function runScheduler(opts) {
     else {
         state = emptyState(opts.concurrency);
     }
+    // Task mode detection
+    if (opts.taskMode) {
+        state.taskMode = opts.taskMode;
+    }
+    else if (!existing) {
+        // Auto-detect: platform mode if remote has issues with status:: labels
+        state.taskMode = detectTaskMode(opts.projectDir);
+        logger.info(`Task mode auto-detected: ${state.taskMode}`);
+    }
+    // If resuming existing state, keep the stored taskMode
+    // Platform mode: shorter idle poll interval (30s vs 5min)
+    const mutableOpts = opts;
+    if (state.taskMode === 'platform' && !opts.taskMode && opts.idlePollInterval === SCHEDULER_DEFAULTS.idlePollInterval) {
+        mutableOpts.idlePollInterval = 30_000;
+    }
     // Worker pool
     const pool = new WorkerPool({
         concurrency: opts.concurrency,
@@ -276,7 +316,7 @@ export async function runScheduler(opts) {
                 logger.info('No work available. Entering idle polling...');
                 const idleStart = Date.now();
                 while (!stopping) {
-                    const poll = await pollForNewWork(opts.projectDir, logger);
+                    const poll = await pollForNewWork(opts.projectDir, logger, state.taskMode, state.completedTasks);
                     if (poll.hasWork) {
                         logger.info(`New work detected (${poll.source}). Resuming...`);
                         break;

package/dist/scheduler/integration.spec.js

@@ -54,6 +54,7 @@ describe('State + Session integration', () => {
             ciFixes: 0,
             buildFixes: 0,
             assignedAgent: 'backend-ts-architect',
+            prState: null,
         };
         writeState(testDir, state);
         const loaded = readState(testDir);