create-claude-workspace 1.1.151 → 2.0.0

package/dist/scheduler/state/state.mjs

@@ -0,0 +1,102 @@
+// ─── State persistence: scheduler-state.json + scheduler-log.ndjson ───
+// Atomic writes via tmp+rename. Append-only event log with rotation.
+import { readFileSync, writeFileSync, renameSync, unlinkSync, appendFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+const STATE_DIR = '.claude/scheduler';
+const STATE_FILE = 'state.json';
+const LOG_FILE = 'log.ndjson';
+const MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB
+// ─── State ───
+export function emptyWorker(id) {
+    return {
+        id,
+        status: 'idle',
+        taskId: null,
+        sessionId: null,
+        pid: null,
+        startedAt: null,
+        agentType: null,
+        step: null,
+    };
+}
+export function emptyState(concurrency) {
+    return {
+        version: 1,
+        startedAt: Date.now(),
+        iteration: 0,
+        currentPhase: 0,
+        workers: Array.from({ length: concurrency }, (_, i) => emptyWorker(i)),
+        pipelines: {},
+        completedTasks: [],
+        skippedTasks: [],
+        sessionMap: {},
+        kitVersion: null,
+    };
+}
+export function readState(projectDir) {
+    const path = resolve(projectDir, STATE_DIR, STATE_FILE);
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeState(projectDir, state) {
+    const dir = resolve(projectDir, STATE_DIR);
+    const path = resolve(dir, STATE_FILE);
+    const tmp = path + '.tmp';
+    try {
+        writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+        renameSync(tmp, path);
+    }
+    catch {
+        try {
+            unlinkSync(tmp);
+        }
+        catch { /* ignore */ }
+    }
+}
+// ─── Event log ───
+export function appendEvent(projectDir, event) {
+    const path = resolve(projectDir, STATE_DIR, LOG_FILE);
+    const line = JSON.stringify(event) + '\n';
+    try {
+        appendFileSync(path, line, 'utf-8');
+    }
+    catch { /* ignore — log is best-effort */ }
+}
+export function createEvent(type, fields) {
+    return { timestamp: Date.now(), type, ...fields };
+}
+export function rotateLog(projectDir) {
+    const path = resolve(projectDir, STATE_DIR, LOG_FILE);
+    try {
+        const stats = statSync(path);
+        if (stats.size < MAX_LOG_SIZE)
+            return false;
+        const archive = resolve(projectDir, STATE_DIR, `log.${Date.now()}.ndjson`);
+        renameSync(path, archive);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Log reader (for recovery/debugging) ───
+export function readRecentEvents(projectDir, maxLines = 50) {
+    const path = resolve(projectDir, STATE_DIR, LOG_FILE);
+    try {
+        const content = readFileSync(path, 'utf-8');
+        const lines = content.trim().split('\n').filter(l => l.length > 0);
+        const recent = lines.slice(-maxLines);
+        return recent.map(line => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/scheduler/state/state.spec.js

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { emptyState, emptyWorker, readState, writeState, appendEvent, createEvent, rotateLog, readRecentEvents, } from './state.mjs';
+let testDir;
+beforeEach(() => {
+    testDir = mkdtempSync(join(tmpdir(), 'scheduler-state-test-'));
+    mkdirSync(resolve(testDir, '.claude/scheduler'), { recursive: true });
+});
+afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+});
+// ─── emptyState ───
+describe('emptyState', () => {
+    it('creates state with correct concurrency', () => {
+        const state = emptyState(3);
+        expect(state.workers).toHaveLength(3);
+        expect(state.workers[0].id).toBe(0);
+        expect(state.workers[1].id).toBe(1);
+        expect(state.workers[2].id).toBe(2);
+    });
+    it('initializes all workers as idle', () => {
+        const state = emptyState(2);
+        for (const w of state.workers) {
+            expect(w.status).toBe('idle');
+            expect(w.taskId).toBeNull();
+            expect(w.pid).toBeNull();
+        }
+    });
+    it('starts at iteration 0, phase 0', () => {
+        const state = emptyState(1);
+        expect(state.iteration).toBe(0);
+        expect(state.currentPhase).toBe(0);
+        expect(state.version).toBe(1);
+    });
+    it('has empty task lists', () => {
+        const state = emptyState(1);
+        expect(state.completedTasks).toEqual([]);
+        expect(state.skippedTasks).toEqual([]);
+        expect(state.pipelines).toEqual({});
+        expect(state.sessionMap).toEqual({});
+    });
+});
+// ─── emptyWorker ───
+describe('emptyWorker', () => {
+    it('creates an idle worker with correct id', () => {
+        const w = emptyWorker(5);
+        expect(w.id).toBe(5);
+        expect(w.status).toBe('idle');
+        expect(w.step).toBeNull();
+    });
+});
+// ─── writeState / readState ───
+describe('writeState / readState', () => {
+    it('round-trips state through write and read', () => {
+        const state = emptyState(2);
+        state.iteration = 5;
+        state.currentPhase = 1;
+        state.completedTasks = ['p0-1', 'p0-2'];
+        writeState(testDir, state);
+        const loaded = readState(testDir);
+        expect(loaded).not.toBeNull();
+        expect(loaded.iteration).toBe(5);
+        expect(loaded.currentPhase).toBe(1);
+        expect(loaded.completedTasks).toEqual(['p0-1', 'p0-2']);
+        expect(loaded.workers).toHaveLength(2);
+    });
+    it('returns null when no state file exists', () => {
+        expect(readState(testDir)).toBeNull();
+    });
+    it('returns null for corrupt state file', () => {
+        writeFileSync(resolve(testDir, '.claude/scheduler/state.json'), 'not json');
+        expect(readState(testDir)).toBeNull();
+    });
+    it('returns null for wrong version', () => {
+        writeFileSync(resolve(testDir, '.claude/scheduler/state.json'), '{"version": 99}');
+        expect(readState(testDir)).toBeNull();
+    });
+    it('atomic write survives — no .tmp file left on success', () => {
+        const state = emptyState(1);
+        writeState(testDir, state);
+        expect(existsSync(resolve(testDir, '.claude/scheduler/state.json.tmp'))).toBe(false);
+        expect(existsSync(resolve(testDir, '.claude/scheduler/state.json'))).toBe(true);
+    });
+    it('preserves pipeline and session data', () => {
+        const state = emptyState(1);
+        state.pipelines['p1-1'] = {
+            taskId: 'p1-1',
+            workerId: 0,
+            worktreePath: '/tmp/worktree',
+            step: 'implement',
+            architectPlan: 'Build users endpoint',
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: null,
+            reviewCycles: 1,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: 'backend-ts-architect',
+        };
+        state.sessionMap['p1-1'] = 'session-abc-123';
+        writeState(testDir, state);
+        const loaded = readState(testDir);
+        expect(loaded.pipelines['p1-1'].step).toBe('implement');
+        expect(loaded.pipelines['p1-1'].architectPlan).toBe('Build users endpoint');
+        expect(loaded.sessionMap['p1-1']).toBe('session-abc-123');
+    });
+});
+// ─── appendEvent / readRecentEvents ───
+describe('appendEvent / readRecentEvents', () => {
+    it('appends events to log file', () => {
+        const event1 = createEvent('task_started', { taskId: 'p1-1', agentType: 'backend' });
+        const event2 = createEvent('agent_completed', { taskId: 'p1-1' });
+        appendEvent(testDir, event1);
+        appendEvent(testDir, event2);
+        const events = readRecentEvents(testDir);
+        expect(events).toHaveLength(2);
+        expect(events[0].type).toBe('task_started');
+        expect(events[0].taskId).toBe('p1-1');
+        expect(events[1].type).toBe('agent_completed');
+    });
+    it('returns empty array when no log file', () => {
+        expect(readRecentEvents(testDir)).toEqual([]);
+    });
+    it('limits to maxLines most recent events', () => {
+        for (let i = 0; i < 10; i++) {
+            appendEvent(testDir, createEvent('step_changed', { detail: `step-${i}` }));
+        }
+        const recent = readRecentEvents(testDir, 3);
+        expect(recent).toHaveLength(3);
+        expect(recent[0].detail).toBe('step-7');
+        expect(recent[2].detail).toBe('step-9');
+    });
+});
+// ─── createEvent ───
+describe('createEvent', () => {
+    it('creates event with timestamp', () => {
+        const before = Date.now();
+        const event = createEvent('health_check');
+        const after = Date.now();
+        expect(event.timestamp).toBeGreaterThanOrEqual(before);
+        expect(event.timestamp).toBeLessThanOrEqual(after);
+        expect(event.type).toBe('health_check');
+    });
+    it('merges optional fields', () => {
+        const event = createEvent('agent_spawned', { taskId: 'p1-1', agentType: 'ui-engineer', workerId: 2 });
+        expect(event.taskId).toBe('p1-1');
+        expect(event.agentType).toBe('ui-engineer');
+        expect(event.workerId).toBe(2);
+    });
+});
+// ─── rotateLog ───
+describe('rotateLog', () => {
+    it('does not rotate small log files', () => {
+        appendEvent(testDir, createEvent('health_check'));
+        expect(rotateLog(testDir)).toBe(false);
+    });
+    it('returns false when log does not exist', () => {
+        expect(rotateLog(testDir)).toBe(false);
+    });
+    it('rotates large log files', () => {
+        const logPath = resolve(testDir, '.claude/scheduler/log.ndjson');
+        // Write ~11MB of data
+        const bigLine = JSON.stringify({ timestamp: 0, type: 'health_check', detail: 'x'.repeat(1000) }) + '\n';
+        const count = Math.ceil((10 * 1024 * 1024) / bigLine.length) + 10;
+        const chunks = [];
+        for (let i = 0; i < count; i++)
+            chunks.push(bigLine);
+        writeFileSync(logPath, chunks.join(''));
+        expect(rotateLog(testDir)).toBe(true);
+        // Original should no longer exist (renamed)
+        expect(existsSync(logPath)).toBe(false);
+    });
+});

package/dist/scheduler/tasks/inbox.mjs

@@ -0,0 +1,98 @@
+// ─── File-based inbox for runtime user input ───
+// User writes to .claude/scheduler/inbox.json, scheduler reads each iteration.
+// Processed messages are archived to inbox-archive.ndjson.
+import { readFileSync, writeFileSync, appendFileSync, existsSync, unlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+const INBOX_DIR = '.claude/scheduler';
+const INBOX_FILE = 'inbox.json';
+const ARCHIVE_FILE = 'inbox-archive.ndjson';
+// ─── Read inbox ───
+export function readInbox(projectDir) {
+    const path = resolve(projectDir, INBOX_DIR, INBOX_FILE);
+    if (!existsSync(path))
+        return [];
+    try {
+        const raw = readFileSync(path, 'utf-8').trim();
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        // Support both single message and array
+        const messages = Array.isArray(parsed) ? parsed : [parsed];
+        return messages.filter(isValidMessage);
+    }
+    catch {
+        return [];
+    }
+}
+// ─── Process and archive ───
+export function processInbox(projectDir) {
+    const messages = readInbox(projectDir);
+    if (messages.length === 0)
+        return [];
+    // Archive processed messages
+    const archivePath = resolve(projectDir, INBOX_DIR, ARCHIVE_FILE);
+    for (const msg of messages) {
+        const entry = { ...msg, processedAt: Date.now() };
+        appendFileSync(archivePath, JSON.stringify(entry) + '\n', 'utf-8');
+    }
+    // Clear inbox
+    clearInbox(projectDir);
+    return messages;
+}
+export function clearInbox(projectDir) {
+    const path = resolve(projectDir, INBOX_DIR, INBOX_FILE);
+    try {
+        unlinkSync(path);
+    }
+    catch { /* file may not exist */ }
+}
+// ─── Write to inbox (for programmatic use / CLI helper) ───
+export function writeToInbox(projectDir, messages) {
+    const path = resolve(projectDir, INBOX_DIR, INBOX_FILE);
+    const existing = readInbox(projectDir);
+    const all = [...existing, ...messages.map(m => ({ ...m, timestamp: m.timestamp ?? Date.now() }))];
+    writeFileSync(path, JSON.stringify(all, null, 2) + '\n', 'utf-8');
+}
+// ─── Convert inbox message to Task ───
+export function addTaskMessageToTask(msg, phase, nextId) {
+    return {
+        id: nextId,
+        title: msg.title,
+        phase: msg.phase ?? phase,
+        type: msg.taskType ?? 'fullstack',
+        complexity: msg.complexity ?? 'M',
+        status: 'todo',
+        dependsOn: msg.dependsOn ?? [],
+        issueMarker: null,
+        kitUpgrade: false,
+        lineNumber: 0,
+        changelog: 'added',
+    };
+}
+// ─── Validation ───
+function isValidMessage(obj) {
+    if (typeof obj !== 'object' || obj === null)
+        return false;
+    const msg = obj;
+    if (typeof msg.type !== 'string')
+        return false;
+    const validTypes = ['add-task', 'prioritize', 'pause', 'resume', 'stop', 'message'];
+    if (!validTypes.includes(msg.type))
+        return false;
+    // Type-specific validation
+    if (msg.type === 'add-task' && typeof msg.title !== 'string')
+        return false;
+    if (msg.type === 'prioritize' && typeof msg.taskId !== 'string')
+        return false;
+    if (msg.type === 'message' && typeof msg.text !== 'string')
+        return false;
+    return true;
+}
+// ─── Template generators (for documentation / CLI help) ───
+export function exampleInbox() {
+    const examples = [
+        { type: 'add-task', title: 'Add dark mode toggle', taskType: 'frontend', complexity: 'S' },
+        { type: 'message', text: 'Focus on performance optimization for the API endpoints' },
+    ];
+    return JSON.stringify(examples, null, 2);
+}

package/dist/scheduler/tasks/inbox.spec.js

@@ -0,0 +1,168 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { readInbox, processInbox, clearInbox, writeToInbox, addTaskMessageToTask, exampleInbox, } from './inbox.mjs';
+let testDir;
+beforeEach(() => {
+    testDir = mkdtempSync(join(tmpdir(), 'inbox-test-'));
+    mkdirSync(resolve(testDir, '.claude/scheduler'), { recursive: true });
+});
+afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+});
+// ─── readInbox ───
+describe('readInbox', () => {
+    it('returns empty array when no inbox file', () => {
+        expect(readInbox(testDir)).toEqual([]);
+    });
+    it('returns empty array for empty file', () => {
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), '');
+        expect(readInbox(testDir)).toEqual([]);
+    });
+    it('reads a single message', () => {
+        const msg = { type: 'add-task', title: 'New feature' };
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), JSON.stringify(msg));
+        const messages = readInbox(testDir);
+        expect(messages).toHaveLength(1);
+        expect(messages[0].type).toBe('add-task');
+        expect(messages[0].title).toBe('New feature');
+    });
+    it('reads an array of messages', () => {
+        const msgs = [
+            { type: 'add-task', title: 'Task A' },
+            { type: 'message', text: 'Do this first' },
+            { type: 'pause' },
+        ];
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), JSON.stringify(msgs));
+        const messages = readInbox(testDir);
+        expect(messages).toHaveLength(3);
+    });
+    it('filters out invalid messages', () => {
+        const msgs = [
+            { type: 'add-task', title: 'Valid' },
+            { type: 'unknown-type' },
+            { type: 'add-task' }, // missing title
+            { noType: true },
+            { type: 'message', text: 'Valid too' },
+        ];
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), JSON.stringify(msgs));
+        const messages = readInbox(testDir);
+        expect(messages).toHaveLength(2);
+    });
+    it('handles corrupt JSON gracefully', () => {
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), '{broken');
+        expect(readInbox(testDir)).toEqual([]);
+    });
+});
+// ─── processInbox ───
+describe('processInbox', () => {
+    it('returns messages and clears inbox', () => {
+        const msgs = [{ type: 'add-task', title: 'Task A' }];
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), JSON.stringify(msgs));
+        const processed = processInbox(testDir);
+        expect(processed).toHaveLength(1);
+        expect(existsSync(resolve(testDir, '.claude/scheduler/inbox.json'))).toBe(false);
+    });
+    it('archives processed messages to ndjson', () => {
+        const msgs = [
+            { type: 'add-task', title: 'Task A' },
+            { type: 'message', text: 'Hello' },
+        ];
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), JSON.stringify(msgs));
+        processInbox(testDir);
+        const archivePath = resolve(testDir, '.claude/scheduler/inbox-archive.ndjson');
+        expect(existsSync(archivePath)).toBe(true);
+        const lines = readFileSync(archivePath, 'utf-8').trim().split('\n');
+        expect(lines).toHaveLength(2);
+        const archived = JSON.parse(lines[0]);
+        expect(archived.type).toBe('add-task');
+        expect(archived.processedAt).toBeDefined();
+    });
+    it('returns empty for empty inbox', () => {
+        expect(processInbox(testDir)).toEqual([]);
+    });
+    it('accumulates archive across multiple process calls', () => {
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), JSON.stringify([{ type: 'pause' }]));
+        processInbox(testDir);
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), JSON.stringify([{ type: 'resume' }]));
+        processInbox(testDir);
+        const archivePath = resolve(testDir, '.claude/scheduler/inbox-archive.ndjson');
+        const lines = readFileSync(archivePath, 'utf-8').trim().split('\n');
+        expect(lines).toHaveLength(2);
+    });
+});
+// ─── clearInbox ───
+describe('clearInbox', () => {
+    it('removes inbox file', () => {
+        writeFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), '[]');
+        clearInbox(testDir);
+        expect(existsSync(resolve(testDir, '.claude/scheduler/inbox.json'))).toBe(false);
+    });
+    it('does not throw when file does not exist', () => {
+        expect(() => clearInbox(testDir)).not.toThrow();
+    });
+});
+// ─── writeToInbox ───
+describe('writeToInbox', () => {
+    it('writes messages to inbox', () => {
+        writeToInbox(testDir, [
+            { type: 'add-task', title: 'New task' },
+        ]);
+        const messages = readInbox(testDir);
+        expect(messages).toHaveLength(1);
+        expect(messages[0].title).toBe('New task');
+    });
+    it('appends to existing inbox messages', () => {
+        writeToInbox(testDir, [{ type: 'pause' }]);
+        writeToInbox(testDir, [{ type: 'resume' }]);
+        const messages = readInbox(testDir);
+        expect(messages).toHaveLength(2);
+        expect(messages[0].type).toBe('pause');
+        expect(messages[1].type).toBe('resume');
+    });
+    it('adds timestamp if not provided', () => {
+        writeToInbox(testDir, [{ type: 'stop' }]);
+        const raw = JSON.parse(readFileSync(resolve(testDir, '.claude/scheduler/inbox.json'), 'utf-8'));
+        expect(raw[0].timestamp).toBeDefined();
+        expect(typeof raw[0].timestamp).toBe('number');
+    });
+});
+// ─── addTaskMessageToTask ───
+describe('addTaskMessageToTask', () => {
+    it('converts add-task message to Task with defaults', () => {
+        const msg = { type: 'add-task', title: 'Dark mode' };
+        const task = addTaskMessageToTask(msg, 1, 'p1-5');
+        expect(task.id).toBe('p1-5');
+        expect(task.title).toBe('Dark mode');
+        expect(task.phase).toBe(1);
+        expect(task.type).toBe('fullstack');
+        expect(task.complexity).toBe('M');
+        expect(task.status).toBe('todo');
+        expect(task.changelog).toBe('added');
+    });
+    it('respects explicit fields', () => {
+        const msg = {
+            type: 'add-task',
+            title: 'Fix API bug',
+            taskType: 'backend',
+            complexity: 'S',
+            phase: 2,
+            dependsOn: ['p1-1'],
+        };
+        const task = addTaskMessageToTask(msg, 1, 'p2-3');
+        expect(task.type).toBe('backend');
+        expect(task.complexity).toBe('S');
+        expect(task.phase).toBe(2);
+        expect(task.dependsOn).toEqual(['p1-1']);
+    });
+});
+// ─── exampleInbox ───
+describe('exampleInbox', () => {
+    it('generates valid JSON', () => {
+        const example = exampleInbox();
+        const parsed = JSON.parse(example);
+        expect(Array.isArray(parsed)).toBe(true);
+        expect(parsed.length).toBeGreaterThan(0);
+    });
+});