create-claude-workspace 1.1.45 → 1.1.46

package/dist/index.js

@@ -91,10 +91,11 @@ ${C.b}Examples:${C.n}
 
 ${C.b}What it creates:${C.n}
   .claude/agents/        10 specialist agents (orchestrator, architects, etc.)
-  .claude/scripts/       Autonomous loop + Docker runner
   .claude/templates/     CLAUDE.md template for project initialization
+  .claude/profiles/      Frontend framework profiles (Angular, React, Vue, Svelte)
   .claude/CLAUDE.md      Agent routing instructions
   .claude/docker/        Docker config (Dockerfile, compose, entrypoint)
+  .claude/.kit-version   Kit version (for upgrade detection)
 `);
 }
 // ─── Prompts ───
@@ -113,22 +114,37 @@ async function confirm(question) {
     return answer === '' || answer.toLowerCase().startsWith('y');
 }
 // ─── File operations ───
-function listFiles(dir, base = dir) {
+function listFiles(dir, base = dir, skipDirs = []) {
     const results = [];
     for (const entry of readdirSync(dir)) {
         const full = join(dir, entry);
+        const rel = relative(base, full);
         if (statSync(full).isDirectory()) {
-            results.push(...listFiles(full, base));
+            if (skipDirs.some(s => rel.replace(/\\/g, '/').startsWith(s)))
+                continue;
+            results.push(...listFiles(full, base, skipDirs));
         }
         else {
-            results.push(relative(base, full));
+            results.push(rel);
         }
     }
     return results;
 }
+function writeKitVersion(targetDir) {
+    const pkgPath = resolve(__dirname, '..', 'package.json');
+    if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        const versionFile = join(targetDir, '.claude', '.kit-version');
+        const dir = dirname(versionFile);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(versionFile, pkg.version);
+        info(`Kit version: ${pkg.version}`);
+    }
+}
 function ensureGitignore(targetDir) {
     const gitignorePath = join(targetDir, '.gitignore');
-    const entries = ['.npmrc', '.docker-compose.auth.yml', '.claude/autonomous.log', '.claude/autonomous.lock', '.claude/autonomous-state.json', '.worktrees/'];
+    const entries = ['.npmrc', '.docker-compose.auth.yml', '.claude/autonomous.log', '.claude/autonomous.lock', '.claude/autonomous-state.json', '.claude/.kit-version', '.worktrees/'];
     if (existsSync(gitignorePath)) {
         let content = readFileSync(gitignorePath, 'utf-8');
         const added = [];
@@ -148,7 +164,11 @@ function ensureGitignore(targetDir) {
 }
 // ─── Run ───
 function runAutonomous(targetDir, docker, extraArgs = []) {
-    const script = docker ? '.claude/scripts/docker-run.mjs' : '.claude/scripts/autonomous.mjs';
+    // Run scripts from the package itself, not from .claude/scripts/ in target dir
+    const scriptsDir = resolve(__dirname, 'scripts');
+    const script = docker
+        ? resolve(scriptsDir, 'docker-run.mjs')
+        : resolve(scriptsDir, 'autonomous.mjs');
     const args = docker ? [script, ...extraArgs] : [script, '--skip-permissions', ...extraArgs];
     if (docker) {
         info('Starting Docker-based autonomous development...');
@@ -214,7 +234,8 @@ async function main() {
     if (!existsSync(targetDir)) {
         mkdirSync(targetDir, { recursive: true });
     }
-    const files = listFiles(TEMPLATE_DIR);
+    // Scripts run from the package (node_modules), not from .claude/scripts/ in the target
+    const files = listFiles(TEMPLATE_DIR, TEMPLATE_DIR, ['.claude/scripts']);
     let copied = 0;
     let skipped = 0;
     for (const file of files) {
@@ -235,6 +256,8 @@ async function main() {
         info(`Copied ${copied} files`);
     if (skipped > 0)
         info(`Skipped ${skipped} existing files`);
+    // Write kit version for orchestrator to detect upgrades
+    writeKitVersion(targetDir);
     ensureGitignore(targetDir);
     console.log('');
     info(`${C.b}Done!${C.n} Your project now has Claude Code agents.`);

package/dist/{template/.claude/scripts → scripts}/autonomous.mjs

@@ -131,7 +131,6 @@ function printHelp() {
 Autonomous development loop for Claude Code.
 
 Usage: npx create-claude-workspace run [options]
-       node .claude/scripts/autonomous.mjs [options]
 
 Options:
   --max-iterations <n>         Max iterations (default: 50)

package/dist/scripts/autonomous.spec.js

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { parseArgs } from './autonomous.mjs';
+describe('parseArgs', () => {
+    it('returns defaults for empty args', () => {
+        const opts = parseArgs([]);
+        expect(opts.maxIterations).toBe(50);
+        expect(opts.maxTurns).toBe(50);
+        expect(opts.skipPermissions).toBe(false);
+        expect(opts.dryRun).toBe(false);
+        expect(opts.resume).toBe(false);
+    });
+    it('parses boolean flags', () => {
+        const opts = parseArgs(['--skip-permissions', '--dry-run', '--resume', '--no-lock', '--no-pull']);
+        expect(opts.skipPermissions).toBe(true);
+        expect(opts.dryRun).toBe(true);
+        expect(opts.resume).toBe(true);
+        expect(opts.noLock).toBe(true);
+        expect(opts.noPull).toBe(true);
+    });
+    it('parses numeric flags', () => {
+        const opts = parseArgs(['--max-iterations', '10', '--max-turns', '20', '--delay', '1000']);
+        expect(opts.maxIterations).toBe(10);
+        expect(opts.maxTurns).toBe(20);
+        expect(opts.delay).toBe(1000);
+    });
+    it('parses string flags', () => {
+        const opts = parseArgs(['--project-dir', '/tmp/proj', '--notify-command', 'echo hi', '--log-file', 'custom.log']);
+        expect(opts.projectDir).toContain('proj');
+        expect(opts.notifyCommand).toBe('echo hi');
+        expect(opts.logFile).toBe('custom.log');
+    });
+    it('sets help flag', () => {
+        expect(parseArgs(['--help']).help).toBe(true);
+        expect(parseArgs(['-h']).help).toBe(true);
+    });
+});

package/dist/{template/.claude/scripts → scripts}/docker-run.mjs

@@ -3,11 +3,10 @@
 // Single cross-platform script. Builds container, sets up auth, runs autonomous loop.
 import { spawnSync } from 'node:child_process';
 import { existsSync, writeFileSync, unlinkSync } from 'node:fs';
-import { join, resolve, dirname } from 'node:path';
+import { join } from 'node:path';
 import { homedir, platform as osPlatform, tmpdir } from 'node:os';
-import { fileURLToPath } from 'node:url';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const PROJECT_DIR = resolve(__dirname, '../..');
+// PROJECT_DIR = target project (set by index.ts via cwd), not the npm package
+const PROJECT_DIR = process.cwd();
 const DOCKER_DIR = join(PROJECT_DIR, '.claude', 'docker');
 const AUTH_COMPOSE = join(tmpdir(), 'claude-starter-kit-auth-compose.yml');
 const IS_WIN = osPlatform() === 'win32';
@@ -120,7 +119,6 @@ One command to start safe, isolated autonomous development.
 
 Usage:
   npx create-claude-workspace docker [options]
-  node .claude/scripts/docker-run.mjs [options]
 
 Options:
   --shell              Interactive shell instead of autonomous loop
@@ -342,7 +340,7 @@ function main() {
         info('Autonomous mode — isolated in Docker, --skip-permissions is safe.');
         info('Press Ctrl+C to stop after current iteration.');
         console.log('');
-        compose(['run', '--rm', '-T', 'claude', '-c', `node .claude/scripts/autonomous.mjs ${escaped.join(' ')}`]);
+        compose(['run', '--rm', '-T', 'claude', '-c', `npx create-claude-workspace run ${escaped.join(' ')}`]);
     }
 }
 export { main as runDockerLoop, parseArgs, printHelp };

package/dist/scripts/integration.spec.js

@@ -0,0 +1,297 @@
+// ─── Integration tests: real Claude CLI invocations ───
+// These tests call the actual Claude CLI. They require:
+// - Claude CLI installed and on PATH
+// - Valid authentication (API key or OAuth)
+// - Network access to Anthropic API
+//
+// Run OUTSIDE Claude Code session (CLAUDECODE env var blocks nested sessions):
+//   npx vitest run src/scripts/integration.spec.ts --config vitest.integration.config.ts
+//
+// Or unset CLAUDECODE first:
+//   CLAUDECODE= npx vitest run src/scripts/integration.spec.ts --config vitest.integration.config.ts
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execSync, spawnSync } from 'node:child_process';
+import { mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runClaude } from './lib/claude-runner.mjs';
+import { checkClaudeInstalled, checkAuth } from './lib/utils.mjs';
+import { DEFAULTS } from './lib/types.mjs';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = resolve(__dirname, '../..');
+const TEST_DIR = resolve(__dirname, '__integration_tmp__');
+const SHELL = process.platform === 'win32' ? 'cmd.exe' : '/bin/sh';
+// Detect nested Claude Code session — CLI refuses to launch inside another session
+const isNestedSession = !!process.env.CLAUDECODE;
+const nopLog = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+};
+const captureLog = () => {
+    const lines = [];
+    return {
+        lines,
+        log: {
+            info: (m) => lines.push(`[INFO] ${m}`),
+            warn: (m) => lines.push(`[WARN] ${m}`),
+            error: (m) => lines.push(`[ERROR] ${m}`),
+            debug: (m) => lines.push(`[DEBUG] ${m}`),
+        },
+    };
+};
+function makeOpts(overrides = {}) {
+    return {
+        ...DEFAULTS,
+        projectDir: TEST_DIR,
+        maxTurns: 1,
+        processTimeout: 60_000,
+        activityTimeout: 30_000,
+        postResultTimeout: 10_000,
+        skipPermissions: true,
+        noLock: true,
+        noPull: true,
+        ...overrides,
+    };
+}
+// ─── Pre-check: skip all if Claude not available ───
+let claudeAvailable = false;
+beforeAll(() => {
+    claudeAvailable = checkClaudeInstalled() && checkAuth();
+    if (!claudeAvailable) {
+        console.warn('⚠ Claude CLI not available or not authenticated — skipping integration tests');
+    }
+    if (isNestedSession) {
+        console.warn('⚠ Running inside Claude Code session — Claude invocation tests will be skipped');
+        console.warn('  Run outside Claude Code or unset CLAUDECODE to enable full integration tests');
+    }
+});
+// ─── 1. Pre-flight checks ───
+describe('pre-flight checks (real CLI)', () => {
+    it('detects Claude CLI installation', () => {
+        const installed = checkClaudeInstalled();
+        expect(typeof installed).toBe('boolean');
+    });
+    it('checks auth status', () => {
+        const authed = checkAuth();
+        expect(typeof authed).toBe('boolean');
+    });
+    it('claude --version returns valid output', () => {
+        if (!claudeAvailable)
+            return;
+        const result = spawnSync('claude', ['--version'], { shell: SHELL, encoding: 'utf-8', timeout: 10_000 });
+        expect(result.status).toBe(0);
+        expect(result.stdout || result.stderr).toBeTruthy();
+    });
+});
+// ─── 2. runClaude — real invocation with simple prompt ───
+// These tests require running OUTSIDE a Claude Code session
+describe('runClaude (real CLI)', () => {
+    beforeAll(() => {
+        mkdirSync(resolve(TEST_DIR, '.claude'), { recursive: true });
+        writeFileSync(resolve(TEST_DIR, '.claude', 'CLAUDE.md'), '# Test Project\nThis is a test.\n');
+    });
+    it('spawns Claude, gets structured result', async () => {
+        if (!claudeAvailable || isNestedSession)
+            return;
+        const opts = makeOpts({ maxTurns: 2 });
+        const output = await runClaude(opts, nopLog, {
+            resumePrompt: 'Respond with a structured result. Set status to "completed", action to "test", message to "integration test passed". Do nothing else.',
+        });
+        expect(output.durationMs).toBeGreaterThan(0);
+        expect(output.code).not.toBeNull();
+        expect(['none', 'max_turns', 'activity_timeout']).toContain(output.errorCategory);
+    }, 120_000);
+    it('handles max-turns correctly (1 turn)', async () => {
+        if (!claudeAvailable || isNestedSession)
+            return;
+        const opts = makeOpts({ maxTurns: 1 });
+        const output = await runClaude(opts, nopLog, {
+            resumePrompt: 'Say hello.',
+        });
+        expect(['none', 'max_turns']).toContain(output.errorCategory);
+        expect(output.durationMs).toBeGreaterThan(0);
+    }, 120_000);
+    it('captures session ID from stream', async () => {
+        if (!claudeAvailable || isNestedSession)
+            return;
+        const opts = makeOpts({ maxTurns: 1 });
+        const output = await runClaude(opts, nopLog, {
+            resumePrompt: 'Say "ok".',
+        });
+        if (output.errorCategory === 'none' || output.errorCategory === 'max_turns') {
+            expect(output.sessionId).toBeTruthy();
+        }
+    }, 120_000);
+    it('respects process timeout', async () => {
+        if (!claudeAvailable || isNestedSession)
+            return;
+        const opts = makeOpts({
+            maxTurns: 100,
+            processTimeout: 5_000,
+        });
+        const output = await runClaude(opts, nopLog, {
+            resumePrompt: 'Write a very long essay about the history of computing. Take your time.',
+        });
+        expect(output.durationMs).toBeLessThan(30_000);
+        expect(['none', 'max_turns', 'process_timeout']).toContain(output.errorCategory);
+    }, 60_000);
+    it('stream parsing produces display output', async () => {
+        if (!claudeAvailable || isNestedSession)
+            return;
+        const { log, lines } = captureLog();
+        const opts = makeOpts({ maxTurns: 1 });
+        await runClaude(opts, log, {
+            resumePrompt: 'Say "hello integration test".',
+        });
+        expect(lines.length).toBeGreaterThanOrEqual(0);
+    }, 120_000);
+    it('detects nested session and returns cli_crash', async () => {
+        if (!claudeAvailable || !isNestedSession)
+            return;
+        const opts = makeOpts({ maxTurns: 1 });
+        const output = await runClaude(opts, nopLog, {
+            resumePrompt: 'Say hello.',
+        });
+        // Inside a Claude Code session, Claude refuses to start
+        expect(output.errorCategory).toBe('cli_crash');
+        expect(output.stderr).toContain('cannot be launched inside another Claude Code session');
+    }, 30_000);
+});
+// ─── 3. Structured result parsing ───
+describe('structured result (real CLI)', () => {
+    it('parses structured JSON result from Claude', async () => {
+        if (!claudeAvailable || isNestedSession)
+            return;
+        const opts = makeOpts({ maxTurns: 3 });
+        const output = await runClaude(opts, nopLog, {
+            resumePrompt: 'Return your structured result now. Status: completed. Action: none. Message: "Integration test successful". Do not use any tools. Just return the result immediately.',
+        });
+        if (output.result) {
+            expect(['completed', 'needs_input', 'blocked', 'error']).toContain(output.result.status);
+            expect(typeof output.result.action).toBe('string');
+            expect(typeof output.result.message).toBe('string');
+        }
+        expect(output.code).not.toBeNull();
+    }, 120_000);
+});
+// ─── 4. Loop continuation — real CLI, two consecutive invocations ───
+// This is the exact scenario that hangs on Windows: first task completes,
+// second invocation should start immediately without getting stuck.
+describe('loop continuation (real CLI, two consecutive runClaude calls)', () => {
+    const skipReason = !claudeAvailable ? 'Claude CLI not available' : isNestedSession ? 'nested Claude session' : '';
+    it.skipIf(!!skipReason)('second runClaude starts and completes after first one finishes', async () => {
+        const opts = makeOpts({ maxTurns: 3 });
+        // ── First invocation (simulates iteration 1) ──
+        const output1 = await runClaude(opts, nopLog, {
+            resumePrompt: 'Return your structured result immediately. Status: completed. Action: commit. Message: "Task T-1 done". task_completed: "T-1". next_task: "T-2". Do not use any tools.',
+        });
+        expect(output1.code).not.toBeNull();
+        expect(['none', 'max_turns']).toContain(output1.errorCategory);
+        // ── Second invocation (simulates iteration 2) ──
+        // This is where the Windows bug manifests — the second spawn hangs
+        // because orphan child processes from the first invocation hold locks.
+        const output2 = await runClaude(opts, nopLog, {
+            resumePrompt: 'Return your structured result immediately. Status: completed. Action: commit. Message: "Task T-2 done". task_completed: "T-2". next_task: "T-3". Do not use any tools.',
+        });
+        expect(output2.code).not.toBeNull();
+        expect(['none', 'max_turns']).toContain(output2.errorCategory);
+        expect(output2.durationMs).toBeGreaterThan(0);
+        // Both invocations should have session IDs (proves they actually ran)
+        if (output1.errorCategory === 'none')
+            expect(output1.sessionId).toBeTruthy();
+        if (output2.errorCategory === 'none')
+            expect(output2.sessionId).toBeTruthy();
+        // Session IDs must differ (proves second is a NEW process, not a stale one)
+        if (output1.sessionId && output2.sessionId) {
+            expect(output2.sessionId).not.toBe(output1.sessionId);
+        }
+    }, 180_000); // 3 min timeout — generous for two real Claude calls
+    it.skipIf(!!skipReason)('three consecutive invocations all complete (sustained loop)', async () => {
+        const opts = makeOpts({ maxTurns: 2 });
+        const sessionIds = [];
+        for (let i = 1; i <= 3; i++) {
+            const output = await runClaude(opts, nopLog, {
+                resumePrompt: `Return structured result. Status: completed. Action: done. Message: "Iteration ${i}". Do not use tools.`,
+            });
+            expect(output.code).not.toBeNull();
+            expect(['none', 'max_turns']).toContain(output.errorCategory);
+            sessionIds.push(output.sessionId);
+        }
+        // All sessions should be unique (each is a fresh process)
+        const unique = new Set(sessionIds.filter(Boolean));
+        expect(unique.size).toBe(sessionIds.filter(Boolean).length);
+    }, 300_000); // 5 min for three real calls
+});
+// ─── 5. Scaffolding end-to-end ───
+// (Section 4 is "Loop continuation" above)
+describe('scaffold end-to-end', () => {
+    const scaffoldDir = resolve(TEST_DIR, 'scaffold-test');
+    it('scaffolds .claude/ directory into target', () => {
+        mkdirSync(scaffoldDir, { recursive: true });
+        const result = spawnSync('node', [resolve(PROJECT_ROOT, 'dist', 'index.js'), scaffoldDir, '--update'], {
+            encoding: 'utf-8',
+            timeout: 30_000,
+        });
+        expect(result.status).toBe(0);
+        // Verify key files exist
+        expect(existsSync(resolve(scaffoldDir, '.claude', 'CLAUDE.md'))).toBe(true);
+        expect(existsSync(resolve(scaffoldDir, '.claude', 'agents', 'orchestrator.md'))).toBe(true);
+        expect(existsSync(resolve(scaffoldDir, '.claude', 'agents', 'project-initializer.md'))).toBe(true);
+        expect(existsSync(resolve(scaffoldDir, '.claude', 'scripts', 'autonomous.mjs'))).toBe(true);
+        expect(existsSync(resolve(scaffoldDir, '.claude', 'scripts', 'docker-run.mjs'))).toBe(true);
+        expect(existsSync(resolve(scaffoldDir, '.claude', 'scripts', 'lib', 'claude-runner.mjs'))).toBe(true);
+        expect(existsSync(resolve(scaffoldDir, '.claude', 'templates', 'PLAN.md'))).toBe(true);
+        expect(existsSync(resolve(scaffoldDir, '.claude', 'profiles', 'angular.md'))).toBe(true);
+        expect(existsSync(resolve(scaffoldDir, '.claude', 'profiles', 'react.md'))).toBe(true);
+        // Verify no spec files leaked into template
+        const libDir = resolve(scaffoldDir, '.claude', 'scripts', 'lib');
+        if (existsSync(libDir)) {
+            const files = execSync(`ls "${libDir}"`, { encoding: 'utf-8' }).trim().split('\n');
+            const specFiles = files.filter(f => f.includes('.spec.'));
+            expect(specFiles).toEqual([]);
+        }
+    });
+    it('scaffolded autonomous.mjs is valid JavaScript', () => {
+        const autonomousPath = resolve(scaffoldDir, '.claude', 'scripts', 'autonomous.mjs');
+        if (!existsSync(autonomousPath))
+            return;
+        const result = spawnSync('node', ['--check', autonomousPath], { encoding: 'utf-8', timeout: 10_000 });
+        expect(result.status).toBe(0);
+    });
+    it('scaffolded scripts have no vitest imports', () => {
+        const autonomousPath = resolve(scaffoldDir, '.claude', 'scripts', 'autonomous.mjs');
+        if (!existsSync(autonomousPath))
+            return;
+        const content = readFileSync(autonomousPath, 'utf-8');
+        expect(content).not.toContain('vitest');
+        expect(content).not.toContain('.spec.');
+    });
+});
+// ─── 6. Dry-run validation ───
+describe('dry-run mode', () => {
+    it('autonomous --dry-run validates prerequisites without spawning Claude', () => {
+        if (!claudeAvailable)
+            return;
+        const dryRunDir = resolve(TEST_DIR, 'dry-run-test');
+        mkdirSync(resolve(dryRunDir, '.claude'), { recursive: true });
+        spawnSync('git', ['init'], { cwd: dryRunDir, stdio: 'ignore' });
+        spawnSync('git', ['config', 'user.name', 'Test'], { cwd: dryRunDir, stdio: 'ignore' });
+        spawnSync('git', ['config', 'user.email', 'test@test.com'], { cwd: dryRunDir, stdio: 'ignore' });
+        const result = spawnSync('node', [
+            resolve(PROJECT_ROOT, 'dist', 'scripts', 'autonomous.mjs'),
+            '--dry-run', '--no-pull', '--project-dir', dryRunDir,
+        ], {
+            encoding: 'utf-8',
+            timeout: 30_000,
+        });
+        expect(result.status).toBe(0);
+        const output = result.stdout + result.stderr;
+        expect(output).toContain('Dry run complete');
+    }, 30_000);
+});
+// ─── Cleanup ───
+afterAll(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+});