create-claude-workspace 1.1.151 → 2.0.0

package/dist/scheduler/git/release.mjs

@@ -0,0 +1,117 @@
+// ─── Version bumping, CHANGELOG.md generation, git tagging ───
+// Deterministic — reads tasks, writes markdown, calls git. No AI tokens.
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createTag, getLatestTag } from './manager.mjs';
+export function parseSemVer(version) {
+    const match = version.match(/^v?(\d+)\.(\d+)\.(\d+)$/);
+    if (!match)
+        return null;
+    return {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
+    };
+}
+export function formatSemVer(v) {
+    return `v${v.major}.${v.minor}.${v.patch}`;
+}
+export function bumpVersion(current, bump) {
+    switch (bump) {
+        case 'major': return { major: current.major + 1, minor: 0, patch: 0 };
+        case 'minor': return { major: current.major, minor: current.minor + 1, patch: 0 };
+        case 'patch': return { major: current.major, minor: current.minor, patch: current.patch + 1 };
+    }
+}
+/**
+ * Determine bump type from completed tasks.
+ */
+export function determineBumpType(tasks) {
+    if (tasks.some(t => t.changelog === 'breaking'))
+        return 'major';
+    if (tasks.some(t => t.changelog === 'added' || t.changelog === 'changed'))
+        return 'minor';
+    return 'patch';
+}
+// ─── CHANGELOG generation ───
+const CATEGORY_HEADINGS = {
+    breaking: 'Breaking Changes',
+    added: 'Added',
+    changed: 'Changed',
+    fixed: 'Fixed',
+    none: '',
+};
+const CATEGORY_ORDER = ['breaking', 'added', 'changed', 'fixed'];
+export function generateChangelogEntry(info) {
+    const lines = [];
+    lines.push(`## [${info.version}] - ${info.date}`);
+    for (const category of CATEGORY_ORDER) {
+        const entries = info.entries.get(category);
+        if (!entries || entries.length === 0)
+            continue;
+        lines.push(`### ${CATEGORY_HEADINGS[category]}`);
+        for (const entry of entries) {
+            lines.push(`- ${entry}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function prependChangelog(projectDir, entry) {
+    const changelogPath = resolve(projectDir, 'CHANGELOG.md');
+    if (existsSync(changelogPath)) {
+        const existing = readFileSync(changelogPath, 'utf-8');
+        // Insert after the # Changelog heading
+        const headingEnd = existing.indexOf('\n');
+        if (headingEnd >= 0 && existing.startsWith('# ')) {
+            const before = existing.slice(0, headingEnd + 1);
+            const after = existing.slice(headingEnd + 1);
+            writeFileSync(changelogPath, `${before}\n${entry}\n${after}`, 'utf-8');
+        }
+        else {
+            writeFileSync(changelogPath, `# Changelog\n\n${entry}\n${existing}`, 'utf-8');
+        }
+    }
+    else {
+        writeFileSync(changelogPath, `# Changelog\n\n${entry}\n`, 'utf-8');
+    }
+}
+// ─── Release flow ───
+/**
+ * Create a release: bump version, generate changelog, create git tag.
+ */
+export function createRelease(projectDir, completedTasks, phase, bumpOverride) {
+    const changeableTasks = completedTasks.filter(t => t.changelog !== 'none');
+    if (changeableTasks.length === 0)
+        return null;
+    // Determine version
+    const latestTag = getLatestTag(projectDir);
+    const currentVersion = latestTag ? parseSemVer(latestTag) : { major: 0, minor: 0, patch: 0 };
+    if (!currentVersion)
+        return null;
+    const bump = bumpOverride ?? determineBumpType(completedTasks);
+    const newVersion = bumpVersion(currentVersion, bump);
+    const versionStr = formatSemVer(newVersion);
+    // Build changelog entries
+    const entries = new Map();
+    for (const task of changeableTasks) {
+        const list = entries.get(task.changelog) ?? [];
+        const marker = task.issueMarker ? ` (${task.issueMarker})` : '';
+        list.push(`${task.title}${marker}`);
+        entries.set(task.changelog, list);
+    }
+    const date = new Date().toISOString().split('T')[0];
+    const info = {
+        version: versionStr,
+        previousVersion: latestTag,
+        phase,
+        date,
+        entries,
+    };
+    // Write changelog
+    const entry = generateChangelogEntry(info);
+    prependChangelog(projectDir, entry);
+    // Create git tag
+    createTag(projectDir, versionStr, `Release ${versionStr} (Phase ${phase})`);
+    return info;
+}

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

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseSemVer, formatSemVer, bumpVersion, determineBumpType, generateChangelogEntry, prependChangelog, createRelease, } from './release.mjs';
+// ─── Version parsing ───
+describe('parseSemVer', () => {
+    it('parses version with v prefix', () => {
+        expect(parseSemVer('v1.2.3')).toEqual({ major: 1, minor: 2, patch: 3 });
+    });
+    it('parses version without v prefix', () => {
+        expect(parseSemVer('0.1.0')).toEqual({ major: 0, minor: 1, patch: 0 });
+    });
+    it('returns null for invalid version', () => {
+        expect(parseSemVer('not-a-version')).toBeNull();
+        expect(parseSemVer('1.2')).toBeNull();
+    });
+});
+describe('formatSemVer', () => {
+    it('formats version with v prefix', () => {
+        expect(formatSemVer({ major: 1, minor: 2, patch: 3 })).toBe('v1.2.3');
+    });
+});
+// ─── Version bumping ───
+describe('bumpVersion', () => {
+    const v = { major: 1, minor: 2, patch: 3 };
+    it('bumps major: resets minor and patch', () => {
+        expect(bumpVersion(v, 'major')).toEqual({ major: 2, minor: 0, patch: 0 });
+    });
+    it('bumps minor: resets patch', () => {
+        expect(bumpVersion(v, 'minor')).toEqual({ major: 1, minor: 3, patch: 0 });
+    });
+    it('bumps patch', () => {
+        expect(bumpVersion(v, 'patch')).toEqual({ major: 1, minor: 2, patch: 4 });
+    });
+});
+// ─── determineBumpType ───
+describe('determineBumpType', () => {
+    const makeTask = (changelog) => ({
+        id: 'p0-1', title: 'Test', phase: 0, type: 'backend', complexity: 'S',
+        status: 'done', dependsOn: [], issueMarker: null, kitUpgrade: false,
+        lineNumber: 1, changelog,
+    });
+    it('returns major when breaking changes exist', () => {
+        expect(determineBumpType([makeTask('added'), makeTask('breaking')])).toBe('major');
+    });
+    it('returns minor for added features', () => {
+        expect(determineBumpType([makeTask('added')])).toBe('minor');
+    });
+    it('returns minor for changed features', () => {
+        expect(determineBumpType([makeTask('changed')])).toBe('minor');
+    });
+    it('returns patch for fixes only', () => {
+        expect(determineBumpType([makeTask('fixed')])).toBe('patch');
+    });
+    it('returns patch for none-only tasks', () => {
+        expect(determineBumpType([makeTask('none')])).toBe('patch');
+    });
+});
+// ─── generateChangelogEntry ───
+describe('generateChangelogEntry', () => {
+    it('generates formatted changelog entry', () => {
+        const entries = new Map();
+        entries.set('added', ['User registration (#5)', 'Login form (#6)']);
+        entries.set('fixed', ['Redirect loop (#8)']);
+        const info = {
+            version: 'v0.1.0',
+            previousVersion: null,
+            phase: 1,
+            date: '2026-03-24',
+            entries,
+        };
+        const entry = generateChangelogEntry(info);
+        expect(entry).toContain('## [v0.1.0] - 2026-03-24');
+        expect(entry).toContain('### Added');
+        expect(entry).toContain('- User registration (#5)');
+        expect(entry).toContain('- Login form (#6)');
+        expect(entry).toContain('### Fixed');
+        expect(entry).toContain('- Redirect loop (#8)');
+        expect(entry).not.toContain('### Breaking');
+    });
+    it('orders sections correctly: breaking, added, changed, fixed', () => {
+        const entries = new Map();
+        entries.set('fixed', ['Fix A']);
+        entries.set('breaking', ['Break B']);
+        entries.set('added', ['Add C']);
+        const info = {
+            version: 'v1.0.0', previousVersion: 'v0.9.0', phase: 2, date: '2026-03-24', entries,
+        };
+        const entry = generateChangelogEntry(info);
+        const breakIdx = entry.indexOf('### Breaking');
+        const addIdx = entry.indexOf('### Added');
+        const fixIdx = entry.indexOf('### Fixed');
+        expect(breakIdx).toBeLessThan(addIdx);
+        expect(addIdx).toBeLessThan(fixIdx);
+    });
+});
+// ─── prependChangelog ───
+describe('prependChangelog', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = mkdtempSync(join(tmpdir(), 'release-test-'));
+    });
+    afterEach(() => {
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    it('creates CHANGELOG.md if it does not exist', () => {
+        prependChangelog(testDir, '## [v0.1.0] - 2026-03-24\n### Added\n- Feature\n');
+        const content = readFileSync(resolve(testDir, 'CHANGELOG.md'), 'utf-8');
+        expect(content).toContain('# Changelog');
+        expect(content).toContain('## [v0.1.0]');
+    });
+    it('prepends to existing CHANGELOG.md', () => {
+        writeFileSync(resolve(testDir, 'CHANGELOG.md'), '# Changelog\n\n## [v0.1.0] - 2026-03-20\n### Added\n- First\n');
+        prependChangelog(testDir, '## [v0.2.0] - 2026-03-24\n### Added\n- Second\n');
+        const content = readFileSync(resolve(testDir, 'CHANGELOG.md'), 'utf-8');
+        const v02Idx = content.indexOf('[v0.2.0]');
+        const v01Idx = content.indexOf('[v0.1.0]');
+        expect(v02Idx).toBeLessThan(v01Idx);
+    });
+});
+// ─── createRelease (integration with git) ───
+describe('createRelease', () => {
+    let repoDir;
+    beforeEach(() => {
+        repoDir = mkdtempSync(join(tmpdir(), 'release-git-test-'));
+        execSync('git init -b main', { cwd: repoDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: repoDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: repoDir, stdio: 'pipe' });
+        writeFileSync(resolve(repoDir, 'file.txt'), 'init');
+        execSync('git add . && git commit -m "init"', { cwd: repoDir, stdio: 'pipe' });
+    });
+    afterEach(() => {
+        rmSync(repoDir, { recursive: true, force: true });
+    });
+    it('creates a release with changelog and tag', () => {
+        const tasks = [
+            { id: 'p1-1', title: 'User auth', phase: 1, type: 'backend', complexity: 'M', status: 'done', dependsOn: [], issueMarker: '#5', kitUpgrade: false, lineNumber: 1, changelog: 'added' },
+            { id: 'p1-2', title: 'Login form', phase: 1, type: 'frontend', complexity: 'S', status: 'done', dependsOn: [], issueMarker: '#6', kitUpgrade: false, lineNumber: 2, changelog: 'added' },
+        ];
+        // Need to commit changelog before tagging
+        const info = createRelease(repoDir, tasks, 1);
+        expect(info).not.toBeNull();
+        expect(info.version).toBe('v0.1.0'); // First release: 0.0.0 → 0.1.0
+        expect(existsSync(resolve(repoDir, 'CHANGELOG.md'))).toBe(true);
+        const changelog = readFileSync(resolve(repoDir, 'CHANGELOG.md'), 'utf-8');
+        expect(changelog).toContain('User auth (#5)');
+        expect(changelog).toContain('Login form (#6)');
+    });
+    it('returns null when no changeable tasks', () => {
+        const tasks = [
+            { id: 'p0-1', title: 'Chore', phase: 0, type: 'backend', complexity: 'S', status: 'done', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 1, changelog: 'none' },
+        ];
+        expect(createRelease(repoDir, tasks, 0)).toBeNull();
+    });
+    it('bumps from existing tag', () => {
+        execSync('git tag -a v1.0.0 -m "v1"', { cwd: repoDir, stdio: 'pipe' });
+        writeFileSync(resolve(repoDir, 'new.txt'), 'change');
+        execSync('git add . && git commit -m "change"', { cwd: repoDir, stdio: 'pipe' });
+        const tasks = [
+            { id: 'p2-1', title: 'Fix bug', phase: 2, type: 'backend', complexity: 'S', status: 'done', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 1, changelog: 'fixed' },
+        ];
+        const info = createRelease(repoDir, tasks, 2);
+        expect(info.version).toBe('v1.0.1'); // patch bump
+        expect(info.previousVersion).toBe('v1.0.0');
+    });
+    it('respects bump override', () => {
+        const tasks = [
+            { id: 'p1-1', title: 'Small fix', phase: 1, type: 'backend', complexity: 'S', status: 'done', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 1, changelog: 'fixed' },
+        ];
+        const info = createRelease(repoDir, tasks, 1, 'major');
+        expect(info.version).toBe('v1.0.0'); // forced major
+    });
+});

package/dist/scheduler/index.mjs

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+// ─── Multi-agent scheduler entry point ───
+// Replaces the single-orchestrator autonomous loop with parallel agent execution.
+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 { emptyState, readState, writeState, appendEvent, createEvent } from './state/state.mjs';
+import { WorkerPool } from './agents/worker-pool.mjs';
+import { OrchestratorClient } from './agents/orchestrator.mjs';
+import { runIteration } from './loop.mjs';
+import { checkAuth } from './agents/health-checker.mjs';
+import { pollForNewWork } from './util/idle-poll.mjs';
+import { TUI } from './ui/tui.mjs';
+// ─── Args ───
+export function parseSchedulerArgs(argv) {
+    const opts = { ...SCHEDULER_DEFAULTS };
+    const mutable = opts;
+    const numFlag = (flag, i) => {
+        const val = argv[i + 1];
+        if (!val || val.startsWith('--')) {
+            console.error(`${flag} requires a value`);
+            process.exit(1);
+        }
+        const n = parseInt(val, 10);
+        if (isNaN(n) || n < 0) {
+            console.error(`${flag} must be a non-negative number`);
+            process.exit(1);
+        }
+        return n;
+    };
+    const strFlag = (flag, i) => {
+        const val = argv[i + 1];
+        if (!val || val.startsWith('--')) {
+            console.error(`${flag} requires a value`);
+            process.exit(1);
+        }
+        return val;
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            printSchedulerHelp();
+            process.exit(0);
+        }
+        if (arg === '--skip-permissions') {
+            mutable.skipPermissions = true;
+            continue;
+        }
+        if (arg === '--no-lock') {
+            mutable.noLock = true;
+            continue;
+        }
+        if (arg === '--no-pull') {
+            mutable.noPull = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            mutable.dryRun = true;
+            continue;
+        }
+        if (arg === '--resume') {
+            mutable.resume = true;
+            continue;
+        }
+        if (arg === '--interactive' || arg === '-i') {
+            mutable.interactive = true;
+            continue;
+        }
+        if (arg === '--concurrency') {
+            mutable.concurrency = numFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg === '--max-iterations') {
+            mutable.maxIterations = numFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg === '--max-turns') {
+            mutable.maxTurns = numFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg === '--delay') {
+            mutable.delay = numFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg === '--cooldown') {
+            mutable.cooldown = numFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg === '--project-dir') {
+            mutable.projectDir = resolve(strFlag(arg, i));
+            i++;
+            continue;
+        }
+        if (arg === '--notify-command') {
+            mutable.notifyCommand = strFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg === '--log-file') {
+            mutable.logFile = strFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg === '--resume-session') {
+            mutable.resumeSession = strFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg === '--idle-poll') {
+            mutable.idlePollInterval = numFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg === '--max-idle') {
+            mutable.maxIdleTime = numFlag(arg, i);
+            i++;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            console.error(`Unknown option: ${arg}`);
+            process.exit(1);
+        }
+    }
+    return opts;
+}
+function printSchedulerHelp() {
+    console.log(`
+Multi-agent scheduler for autonomous development.
+
+Usage: npx create-claude-workspace scheduler [options]
+
+Options:
+  --concurrency <n>          Max parallel agents (default: 1)
+  --max-iterations <n>       Max iterations (default: 50)
+  --max-turns <n>            Max turns per agent invocation (default: 50)
+  --delay <ms>               Pause between iterations (default: 5000)
+  --cooldown <ms>            Wait after error (default: 60000)
+  --project-dir <path>       Project directory (default: cwd)
+  --skip-permissions         Bypass all permission checks
+  --resume                   Resume from saved state
+  --resume-session <id>      Resume specific Claude session
+  --notify-command <cmd>     Shell command on critical events
+  --log-file <path>          Log file path
+  --no-lock                  Disable lock file
+  --no-pull                  Skip auto git pull
+  --idle-poll <ms>           Poll interval when idle (default: 300000)
+  --max-idle <ms>            Max idle time before exit (default: 0 = unlimited)
+  --interactive, -i          Interactive TUI with input prompt
+  --dry-run                  Validate prerequisites only
+  --help                     Show this message
+`);
+}
+// ─── Helpers ───
+function sleep(ms, ref) {
+    return new Promise(r => {
+        const t = setTimeout(r, ms);
+        const check = setInterval(() => {
+            if (ref.value) {
+                clearTimeout(t);
+                clearInterval(check);
+                r();
+            }
+        }, 500);
+    });
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(0)}s`;
+    return `${(ms / 60_000).toFixed(1)}min`;
+}
+// ─── Main ───
+export async function runScheduler(opts) {
+    dotenvConfig({ path: resolve(opts.projectDir, '.env'), override: false, quiet: true });
+    // Ensure scheduler directory exists
+    const schedulerDir = resolve(opts.projectDir, '.claude/scheduler');
+    if (!existsSync(schedulerDir))
+        mkdirSync(schedulerDir, { recursive: true });
+    const logPath = resolve(opts.projectDir, opts.logFile);
+    const tui = new TUI(logPath, opts.interactive);
+    tui.setTopAgent('scheduler');
+    const logger = {
+        info: (m) => tui.info(m),
+        warn: (m) => tui.warn(m),
+        error: (m) => tui.error(m),
+        debug: () => { },
+    };
+    tui.banner();
+    logger.info(`Project: ${opts.projectDir}`);
+    logger.info(`Concurrency: ${opts.concurrency} │ Max iterations: ${opts.maxIterations}`);
+    // Auth check
+    if (!checkAuth()) {
+        logger.error('Not authenticated. Set ANTHROPIC_API_KEY or run `claude login`');
+        process.exit(1);
+    }
+    logger.info('Authentication verified');
+    if (opts.dryRun) {
+        logger.info('Dry run complete. All checks passed.');
+        tui.destroy();
+        return;
+    }
+    // State
+    let state;
+    const existing = readState(opts.projectDir);
+    if (opts.resume && existing) {
+        state = existing;
+        logger.info(`Resuming from iteration ${state.iteration}`);
+    }
+    else {
+        state = emptyState(opts.concurrency);
+    }
+    // Worker pool
+    const pool = new WorkerPool({
+        concurrency: opts.concurrency,
+        maxTurns: opts.maxTurns,
+        skipPermissions: opts.skipPermissions,
+        logger,
+    });
+    // Orchestrator client
+    const orchestrator = new OrchestratorClient({
+        pool,
+        projectDir: opts.projectDir,
+        logger,
+    });
+    // Signal handling
+    let stopping = false;
+    const stoppingRef = { value: false };
+    const cleanup = () => {
+        stopping = true;
+        stoppingRef.value = true;
+        writeState(opts.projectDir, state);
+        appendEvent(opts.projectDir, createEvent('health_check', { detail: 'Interrupted — state saved' }));
+        logger.warn('Interrupted. State saved.');
+        pool.killAll().finally(() => {
+            tui.destroy();
+            process.exit(0);
+        });
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    // ─── Loop ───
+    for (let i = state.iteration; i < opts.maxIterations && !stopping; i++) {
+        appendEvent(opts.projectDir, createEvent('health_check', { detail: `Iteration ${i + 1}` }));
+        try {
+            const workDone = await runIteration({
+                pool,
+                orchestrator,
+                state,
+                opts,
+                logger,
+            });
+            if (!workDone) {
+                // No work → idle polling
+                logger.info('No work available. Entering idle polling...');
+                const idleStart = Date.now();
+                while (!stopping) {
+                    const poll = await pollForNewWork(opts.projectDir, logger);
+                    if (poll.hasWork) {
+                        logger.info(`New work detected (${poll.source}). Resuming...`);
+                        break;
+                    }
+                    if (opts.maxIdleTime > 0 && Date.now() - idleStart >= opts.maxIdleTime) {
+                        logger.info('Max idle time reached. Exiting.');
+                        stopping = true;
+                        break;
+                    }
+                    await sleep(opts.idlePollInterval, stoppingRef);
+                }
+                continue;
+            }
+        }
+        catch (err) {
+            logger.error(`Iteration error: ${err.message}`);
+            appendEvent(opts.projectDir, createEvent('error', { detail: err.message }));
+            logger.warn(`Cooling down ${formatDuration(opts.cooldown)}...`);
+            await sleep(opts.cooldown, stoppingRef);
+        }
+        writeState(opts.projectDir, state);
+        // Pause support
+        while (tui.isPaused() && !stopping) {
+            await sleep(1000, stoppingRef);
+        }
+        if (!stopping && i < opts.maxIterations - 1) {
+            logger.info(`Next iteration in ${formatDuration(opts.delay)}...`);
+            await sleep(opts.delay, stoppingRef);
+        }
+    }
+    // End
+    writeState(opts.projectDir, state);
+    logger.info(`Scheduler ended after ${state.iteration} iterations.`);
+    logger.info(`Completed: ${state.completedTasks.length} │ Skipped: ${state.skippedTasks.length}`);
+    tui.destroy();
+}
+// ─── CLI entry ───
+const isDirectRun = process.argv[1]?.replace(/\\/g, '/').endsWith('scheduler.mjs');
+if (isDirectRun) {
+    const opts = parseSchedulerArgs(process.argv.slice(2));
+    runScheduler(opts).catch(err => {
+        console.error('Fatal:', err);
+        process.exit(1);
+    });
+}

package/dist/scheduler/index.spec.js

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest';
+import { parseSchedulerArgs } from './index.mjs';
+import { SCHEDULER_DEFAULTS } from './types.mjs';
+describe('parseSchedulerArgs', () => {
+    it('returns defaults for empty args', () => {
+        const opts = parseSchedulerArgs([]);
+        expect(opts.concurrency).toBe(SCHEDULER_DEFAULTS.concurrency);
+        expect(opts.maxIterations).toBe(SCHEDULER_DEFAULTS.maxIterations);
+        expect(opts.maxTurns).toBe(SCHEDULER_DEFAULTS.maxTurns);
+        expect(opts.skipPermissions).toBe(false);
+        expect(opts.resume).toBe(false);
+    });
+    it('parses --concurrency', () => {
+        const opts = parseSchedulerArgs(['--concurrency', '3']);
+        expect(opts.concurrency).toBe(3);
+    });
+    it('parses --max-iterations', () => {
+        const opts = parseSchedulerArgs(['--max-iterations', '100']);
+        expect(opts.maxIterations).toBe(100);
+    });
+    it('parses --max-turns', () => {
+        const opts = parseSchedulerArgs(['--max-turns', '25']);
+        expect(opts.maxTurns).toBe(25);
+    });
+    it('parses boolean flags', () => {
+        const opts = parseSchedulerArgs(['--skip-permissions', '--no-lock', '--no-pull', '--dry-run', '--resume', '-i']);
+        expect(opts.skipPermissions).toBe(true);
+        expect(opts.noLock).toBe(true);
+        expect(opts.noPull).toBe(true);
+        expect(opts.dryRun).toBe(true);
+        expect(opts.resume).toBe(true);
+        expect(opts.interactive).toBe(true);
+    });
+    it('parses --delay and --cooldown', () => {
+        const opts = parseSchedulerArgs(['--delay', '10000', '--cooldown', '30000']);
+        expect(opts.delay).toBe(10000);
+        expect(opts.cooldown).toBe(30000);
+    });
+    it('parses --project-dir', () => {
+        const opts = parseSchedulerArgs(['--project-dir', '/tmp/project']);
+        expect(opts.projectDir).toContain('project');
+    });
+    it('parses --notify-command', () => {
+        const opts = parseSchedulerArgs(['--notify-command', 'echo done']);
+        expect(opts.notifyCommand).toBe('echo done');
+    });
+    it('parses --log-file', () => {
+        const opts = parseSchedulerArgs(['--log-file', '/tmp/log.txt']);
+        expect(opts.logFile).toBe('/tmp/log.txt');
+    });
+    it('parses --idle-poll and --max-idle', () => {
+        const opts = parseSchedulerArgs(['--idle-poll', '60000', '--max-idle', '300000']);
+        expect(opts.idlePollInterval).toBe(60000);
+        expect(opts.maxIdleTime).toBe(300000);
+    });
+    it('parses --resume-session', () => {
+        const opts = parseSchedulerArgs(['--resume-session', 'abc-123']);
+        expect(opts.resumeSession).toBe('abc-123');
+    });
+    it('handles multiple flags together', () => {
+        const opts = parseSchedulerArgs([
+            '--concurrency', '2',
+            '--max-iterations', '10',
+            '--skip-permissions',
+            '--no-pull',
+        ]);
+        expect(opts.concurrency).toBe(2);
+        expect(opts.maxIterations).toBe(10);
+        expect(opts.skipPermissions).toBe(true);
+        expect(opts.noPull).toBe(true);
+    });
+});