create-claude-workspace 1.1.151 → 2.0.0

package/dist/scheduler/integration.spec.js

@@ -0,0 +1,289 @@
+/**
+ * Integration tests for the scheduler.
+ * Tests that use real Claude SDK require ANTHROPIC_API_KEY or OAuth credentials.
+ * Skipped automatically when auth is not available.
+ */
+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 { execSync } from 'node:child_process';
+import { WorkerPool } from './agents/worker-pool.mjs';
+import { OrchestratorClient } from './agents/orchestrator.mjs';
+import { checkAuth } from './agents/health-checker.mjs';
+import { parseTodoMd } from './tasks/parser.mjs';
+import { buildGraph, isProjectComplete, isPhaseComplete } from './tasks/queue.mjs';
+import { emptyState, readState, writeState, appendEvent, createEvent } from './state/state.mjs';
+import { recordSession, getSession } from './state/session.mjs';
+import { createRelease } from './git/release.mjs';
+import { createWorktree, commitInWorktree, mergeToMain, cleanupWorktree, getChangedFiles } from './git/manager.mjs';
+const hasAuth = checkAuth();
+const mockLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+};
+// ─── Integration: Full pipeline state management ───
+describe('State + Session integration', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = mkdtempSync(join(tmpdir(), 'sched-integration-'));
+        mkdirSync(resolve(testDir, '.claude/scheduler'), { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    it('persists state with sessions through write/read cycle', () => {
+        const state = emptyState(2);
+        state.iteration = 5;
+        state.currentPhase = 1;
+        state.completedTasks = ['p0-1', 'p0-2'];
+        recordSession(state, 'p1-1', 'session-abc');
+        recordSession(state, 'p1-2', 'session-def');
+        state.pipelines['p1-1'] = {
+            taskId: 'p1-1',
+            workerId: 0,
+            worktreePath: '/tmp/wt1',
+            step: 'implement',
+            architectPlan: 'Plan for auth',
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: 'Test auth endpoint',
+            reviewCycles: 1,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: 'backend-ts-architect',
+        };
+        writeState(testDir, state);
+        const loaded = readState(testDir);
+        expect(loaded.iteration).toBe(5);
+        expect(loaded.completedTasks).toEqual(['p0-1', 'p0-2']);
+        expect(getSession(loaded, 'p1-1')).toBe('session-abc');
+        expect(loaded.pipelines['p1-1'].step).toBe('implement');
+        expect(loaded.pipelines['p1-1'].architectPlan).toBe('Plan for auth');
+    });
+    it('event log accumulates across multiple appends', () => {
+        appendEvent(testDir, createEvent('health_check', { detail: 'start' }));
+        appendEvent(testDir, createEvent('task_started', { taskId: 'p0-1' }));
+        appendEvent(testDir, createEvent('agent_spawned', { taskId: 'p0-1', agentType: 'backend' }));
+        appendEvent(testDir, createEvent('agent_completed', { taskId: 'p0-1' }));
+        appendEvent(testDir, createEvent('task_completed', { taskId: 'p0-1' }));
+        const logPath = resolve(testDir, '.claude/scheduler/log.ndjson');
+        const lines = readFileSync(logPath, 'utf-8').trim().split('\n');
+        expect(lines).toHaveLength(5);
+        const events = lines.map(l => JSON.parse(l));
+        expect(events[0].type).toBe('health_check');
+        expect(events[1].taskId).toBe('p0-1');
+        expect(events[4].type).toBe('task_completed');
+    });
+});
+// ─── Integration: TODO parsing → dependency graph → task queue ───
+describe('TODO → Graph → Queue pipeline', () => {
+    it('parses TODO, builds graph, resolves runnable tasks correctly', () => {
+        const todo = `# TODO.md
+
+## Phase 0: Foundation
+
+- [x] **Init workspace** — scaffolding
+  - Type: fullstack
+  - Complexity: S
+  - Depends on: nothing
+
+- [x] **Configure ESLint** — code quality
+  - Type: fullstack
+  - Complexity: S
+  - Depends on: nothing
+
+## Phase 1: Auth
+
+- [ ] **Auth types** — interfaces
+  - Type: backend
+  - Complexity: S
+  - Depends on: Phase 0
+
+- [ ] **Login API** — endpoint
+  - Type: backend
+  - Complexity: M
+  - Depends on: Auth types
+
+- [ ] **Login form** — UI
+  - Type: frontend
+  - Complexity: S
+  - Depends on: Auth types
+`;
+        const tasks = parseTodoMd(todo);
+        expect(tasks).toHaveLength(5);
+        const graph = buildGraph(tasks);
+        expect(graph.findCycle()).toBeNull();
+        // Phase 0 is complete
+        expect(isPhaseComplete(tasks, 0)).toBe(true);
+        expect(isPhaseComplete(tasks, 1)).toBe(false);
+        // Auth types is runnable (Phase 0 deps are done)
+        const runnable = graph.runnable();
+        expect(runnable.map(t => t.title)).toContain('Auth types');
+        // Login API is blocked (depends on Auth types which is todo)
+        expect(runnable.map(t => t.title)).not.toContain('Login API');
+        // Login form is also blocked
+        expect(runnable.map(t => t.title)).not.toContain('Login form');
+    });
+    it('handles project completion detection', () => {
+        const allDone = `## Phase 0: X
+- [x] **Task A** — done
+  - Type: backend
+  - Complexity: S
+- [~] **Task B** — skipped
+  - Type: backend
+  - Complexity: S
+`;
+        const tasks = parseTodoMd(allDone);
+        expect(isProjectComplete(tasks)).toBe(true);
+    });
+});
+// ─── Integration: Git worktree → commit → merge → cleanup ───
+describe('Git worktree lifecycle', () => {
+    let repoDir;
+    beforeEach(() => {
+        repoDir = mkdtempSync(join(tmpdir(), 'git-integration-'));
+        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, 'README.md'), '# Test');
+        execSync('git add . && git commit -m "init"', { cwd: repoDir, stdio: 'pipe' });
+    });
+    afterEach(() => {
+        try {
+            const output = execSync('git worktree list --porcelain', { cwd: repoDir, encoding: 'utf-8', stdio: 'pipe' });
+            for (const line of output.split('\n')) {
+                if (line.startsWith('worktree ') && !line.includes(repoDir.replace(/\\/g, '/'))) {
+                    const path = line.slice('worktree '.length).trim();
+                    try {
+                        execSync(`git worktree remove "${path}" --force`, { cwd: repoDir, stdio: 'pipe' });
+                    }
+                    catch { /**/ }
+                }
+            }
+        }
+        catch { /**/ }
+        rmSync(repoDir, { recursive: true, force: true });
+    });
+    it('full lifecycle: create worktree → add files → commit → get changes → merge → cleanup', () => {
+        // Create
+        const wtPath = createWorktree(repoDir, 'feat/p1-1-auth-types');
+        expect(existsSync(wtPath)).toBe(true);
+        // Add files
+        writeFileSync(resolve(wtPath, 'auth.ts'), 'export interface User { id: string; }');
+        writeFileSync(resolve(wtPath, 'session.ts'), 'export interface Session { token: string; }');
+        // Commit
+        const sha = commitInWorktree(wtPath, 'feat: add auth types (#5)');
+        expect(sha).toMatch(/^[0-9a-f]{40}$/);
+        // Get changes
+        const changed = getChangedFiles(wtPath);
+        expect(changed).toContain('auth.ts');
+        expect(changed).toContain('session.ts');
+        // Merge
+        const result = mergeToMain(repoDir, 'feat/p1-1-auth-types');
+        expect(result.success).toBe(true);
+        expect(existsSync(resolve(repoDir, 'auth.ts'))).toBe(true);
+        // Cleanup
+        cleanupWorktree(repoDir, wtPath, 'feat/p1-1-auth-types');
+        expect(existsSync(wtPath)).toBe(false);
+    });
+});
+// ─── Integration: Release manager with git ───
+describe('Release manager integration', () => {
+    let repoDir;
+    beforeEach(() => {
+        repoDir = mkdtempSync(join(tmpdir(), 'release-integration-'));
+        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 release with changelog, correct version bump, and git 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: 'Fix redirect', phase: 1, type: 'backend', complexity: 'S', status: 'done', dependsOn: [], issueMarker: '#8', kitUpgrade: false, lineNumber: 2, changelog: 'fixed' },
+        ];
+        const info = createRelease(repoDir, tasks, 1);
+        expect(info).not.toBeNull();
+        expect(info.version).toBe('v0.1.0');
+        // Check changelog
+        const changelog = readFileSync(resolve(repoDir, 'CHANGELOG.md'), 'utf-8');
+        expect(changelog).toContain('### Added');
+        expect(changelog).toContain('User auth (#5)');
+        expect(changelog).toContain('### Fixed');
+        expect(changelog).toContain('Fix redirect (#8)');
+        // Check tag
+        const tags = execSync('git tag', { cwd: repoDir, encoding: 'utf-8' }).trim();
+        expect(tags).toContain('v0.1.0');
+    });
+    it('increments from existing tag', () => {
+        execSync('git tag -a v1.2.0 -m "v1.2.0"', { cwd: repoDir, stdio: 'pipe' });
+        writeFileSync(resolve(repoDir, 'new.txt'), 'x');
+        execSync('git add . && git commit -m "change"', { cwd: repoDir, stdio: 'pipe' });
+        const tasks = [
+            { id: 'p2-1', title: 'Breaking change', phase: 2, type: 'backend', complexity: 'M', status: 'done', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 1, changelog: 'breaking' },
+        ];
+        const info = createRelease(repoDir, tasks, 2);
+        expect(info.version).toBe('v2.0.0');
+        expect(info.previousVersion).toBe('v1.2.0');
+    });
+});
+// ─── Integration: Real SDK (skipped without auth) ───
+describe.skipIf(!hasAuth)('Real SDK integration', () => {
+    it('spawns a Claude process and gets a response', async () => {
+        const pool = new WorkerPool({
+            concurrency: 1,
+            maxTurns: 3,
+            skipPermissions: true,
+            logger: mockLogger,
+        });
+        const result = await pool.spawn(0, {
+            cwd: process.cwd(),
+            prompt: 'Respond with exactly: "SCHEDULER_TEST_OK". Nothing else.',
+            model: 'claude-haiku-4-5-20251001',
+        });
+        expect(result.success).toBe(true);
+        expect(result.sessionId).toBeTruthy();
+        expect(result.output).toContain('SCHEDULER_TEST_OK');
+        expect(result.duration).toBeGreaterThan(0);
+    }, 60_000);
+    it('orchestrator client routes a task to an agent', async () => {
+        const pool = new WorkerPool({
+            concurrency: 1,
+            maxTurns: 3,
+            skipPermissions: true,
+            logger: mockLogger,
+        });
+        const orchestrator = new OrchestratorClient({
+            pool,
+            projectDir: process.cwd(),
+            logger: mockLogger,
+        });
+        const task = {
+            id: 'p1-1',
+            title: 'Create REST API endpoint',
+            phase: 1,
+            type: 'backend',
+            complexity: 'M',
+            status: 'todo',
+            dependsOn: [],
+            issueMarker: null,
+            kitUpgrade: false,
+            lineNumber: 1,
+            changelog: 'added',
+        };
+        const agents = [
+            { name: 'backend-ts-architect', description: 'Backend TypeScript specialist', model: 'opus', steps: ['plan', 'implement'], prompt: '' },
+            { name: 'ui-engineer', description: 'Frontend specialist', model: 'opus', steps: ['plan', 'implement'], prompt: '' },
+        ];
+        const decision = await orchestrator.routeTask(task, 'plan', agents);
+        expect(decision.agent).toBe('backend-ts-architect');
+        expect(decision.reason).toBeTruthy();
+    }, 60_000);
+});