create-claude-workspace 1.1.120 → 1.1.122

package/dist/scripts/autonomous.mjs

@@ -2,11 +2,12 @@
 // ─── Autonomous development loop ───
 // Headless runner for Claude Code orchestrator using Agent SDK.
 import { resolve } from 'node:path';
-import { appendFileSync, existsSync, writeFileSync, unlinkSync, readFileSync } from 'node:fs';
+import { existsSync, writeFileSync, unlinkSync, readFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { DEFAULTS } from './lib/types.mjs';
 import { emptyCheckpoint, readCheckpoint, writeCheckpoint } from './lib/state.mjs';
 import { pollForNewWork } from './lib/idle-poll.mjs';
+import { Formatter } from './lib/formatter.mjs';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { config as dotenvConfig } from '@dotenvx/dotenvx';
 // ─── Args ───
@@ -164,16 +165,6 @@ Options:
 `);
 }
 // ─── Helpers ───
-let logPath = '';
-function log(msg) {
-    const line = `[${new Date().toISOString()}] ${msg}`;
-    console.log(line);
-    if (logPath)
-        try {
-            appendFileSync(logPath, line + '\n');
-        }
-        catch { /* */ }
-}
 function sleep(ms, ref) {
     return new Promise(r => {
         const t = setTimeout(r, ms);
@@ -200,7 +191,6 @@ function notify(cmd, type, message, iteration) {
     catch { /* */ }
 }
 function checkAuth() {
-    // Check if Claude Code has credentials (API key or OAuth session)
     if (process.env.ANTHROPIC_API_KEY)
         return true;
     try {
@@ -215,10 +205,10 @@ function checkAuth() {
     catch { /* */ }
     return false;
 }
-function acquireLock(dir) {
+function acquireLock(dir, fmt) {
     const lockFile = resolve(dir, '.claude/autonomous.lock');
     if (existsSync(lockFile)) {
-        log('Lock file exists. Another instance running?');
+        fmt.warn('Lock file exists. Another instance running?');
         return false;
     }
     try {
@@ -275,27 +265,33 @@ async function main() {
         process.exit(0);
     }
     dotenvConfig({ path: resolve(opts.projectDir, '.env'), override: false, quiet: true });
-    logPath = resolve(opts.projectDir, opts.logFile);
-    log('Autonomous development loop starting.');
-    log(`Project: ${opts.projectDir}`);
-    log(`Iterations: ${opts.maxIterations} | Turns: ${opts.maxTurns}`);
+    const logPath = resolve(opts.projectDir, opts.logFile);
+    const fmt = new Formatter(logPath);
+    fmt.banner();
+    fmt.info(`Project: ${opts.projectDir}`);
+    fmt.info(`Max iterations: ${opts.maxIterations} │ Max turns: ${opts.maxTurns}`);
     // Auth check
     if (!checkAuth()) {
-        log('ERROR: Not authenticated. Either:');
-        log('  1. Set ANTHROPIC_API_KEY env var (API billing), or');
-        log('  2. Run `claude login` to authenticate with Claude Max plan');
-        log('  For Docker: mount ~/.claude/.credentials.json into the container');
+        fmt.error('Not authenticated. Either:');
+        fmt.error('  1. Set ANTHROPIC_API_KEY env var (API billing)');
+        fmt.error('  2. Run `claude login` to authenticate with Claude Max plan');
+        fmt.error('  For Docker: mount ~/.claude/.credentials.json into the container');
         process.exit(1);
     }
+    fmt.success('Authentication verified');
     // Lock
-    if (!opts.noLock && !acquireLock(opts.projectDir)) {
+    if (!opts.noLock && !acquireLock(opts.projectDir, fmt)) {
         process.exit(1);
     }
     // Git pull
-    if (!opts.noPull)
-        gitPull(opts.projectDir);
+    if (!opts.noPull) {
+        if (gitPull(opts.projectDir))
+            fmt.info('Git: pulled latest changes');
+        else
+            fmt.warn('Git: pull failed or not a git repo');
+    }
     if (opts.dryRun) {
-        log('Dry run complete.');
+        fmt.success('Dry run complete. All checks passed.');
         if (!opts.noLock)
             releaseLock(opts.projectDir);
         process.exit(0);
@@ -305,7 +301,7 @@ async function main() {
     const existing = readCheckpoint(opts.projectDir);
     if (opts.resume && existing) {
         checkpoint = existing;
-        log(`Resuming from iteration ${checkpoint.iteration}`);
+        fmt.info(`Resuming from iteration ${checkpoint.iteration}`);
     }
     else {
         checkpoint = emptyCheckpoint();
@@ -317,12 +313,11 @@ async function main() {
         if (!opts.noLock)
             releaseLock(opts.projectDir);
         writeCheckpoint(opts.projectDir, checkpoint);
-        log('Stopped.');
+        fmt.warn('Interrupted. State saved.');
         process.exit(0);
     };
     process.on('SIGINT', cleanup);
     process.on('SIGTERM', cleanup);
-    log('---');
     // ─── Loop ───
     for (let i = checkpoint.iteration + 1; i <= opts.maxIterations && !stopping; i++) {
         // Check completion → idle polling
@@ -331,23 +326,22 @@ async function main() {
             if (!checkpoint.completionVerified) {
                 checkpoint.completionVerified = true;
                 writeCheckpoint(opts.projectDir, checkpoint);
-                // Fall through to run one more iteration (orchestrator verifies)
             }
             else {
-                log('Project complete. Entering idle polling...');
+                fmt.info('Project complete. Entering idle polling...');
                 let foundWork = false;
                 const idleStart = Date.now();
                 while (!stopping) {
-                    const poll = await pollForNewWork(opts.projectDir, { info: log, warn: log, error: log, debug: () => { } });
+                    const poll = await pollForNewWork(opts.projectDir, { info: (m) => fmt.info(m), warn: (m) => fmt.warn(m), error: (m) => fmt.error(m), debug: () => { } });
                     if (poll.hasWork) {
-                        log(`New work detected (${poll.source}). Resuming...`);
+                        fmt.success(`New work detected (${poll.source}). Resuming...`);
                         checkpoint.completionVerified = false;
                         writeCheckpoint(opts.projectDir, checkpoint);
                         foundWork = true;
                         break;
                     }
                     if (opts.maxIdleTime > 0 && Date.now() - idleStart >= opts.maxIdleTime) {
-                        log('Max idle time reached. Exiting.');
+                        fmt.info('Max idle time reached. Exiting.');
                         break;
                     }
                     await sleep(opts.idlePollInterval, stoppingRef);
@@ -357,13 +351,14 @@ async function main() {
                 continue;
             }
         }
-        log(`Iteration ${i}/${opts.maxIterations}`);
+        fmt.iterationStart(i, opts.maxIterations);
+        fmt.resetAgentStack();
         // Run Claude via Agent SDK
         try {
             const resumeOpts = {};
             if (opts.resumeSession) {
                 resumeOpts.resume = opts.resumeSession;
-                opts.resumeSession = null; // Only resume once
+                opts.resumeSession = null;
             }
             else if (opts.resume && checkpoint.lastSessionId) {
                 resumeOpts.continue = true;
@@ -380,17 +375,17 @@ async function main() {
                     ...resumeOpts,
                 },
             })) {
+                fmt.handleMessage(message);
                 if (message.type === 'result') {
-                    const result = message;
-                    checkpoint.lastSessionId = result.session_id ?? null;
-                    log(`Result: ${JSON.stringify(result).slice(0, 300)}`);
+                    checkpoint.lastSessionId = fmt.getSessionId(message);
                 }
             }
             checkpoint.stats.iterations++;
+            fmt.iterationEnd();
         }
         catch (err) {
-            log(`Error: ${err.message}`);
-            log(`Waiting ${formatDuration(opts.cooldown)}...`);
+            fmt.error(`${err.message}`);
+            fmt.warn(`Cooling down ${formatDuration(opts.cooldown)}...`);
             await sleep(opts.cooldown, stoppingRef);
             if (stopping)
                 break;
@@ -400,7 +395,7 @@ async function main() {
         checkpoint.iteration = i;
         writeCheckpoint(opts.projectDir, checkpoint);
         if (i < opts.maxIterations && !stopping) {
-            log(`Next iteration in ${formatDuration(opts.delay)}...`);
+            fmt.info(`Next iteration in ${formatDuration(opts.delay)}...`);
             await sleep(opts.delay, stoppingRef);
         }
     }
@@ -408,8 +403,7 @@ async function main() {
     if (!opts.noLock)
         releaseLock(opts.projectDir);
     writeCheckpoint(opts.projectDir, checkpoint);
-    log('---');
-    log('Autonomous loop ended.');
+    fmt.success(`Loop ended after ${checkpoint.stats.iterations} iterations.`);
     notify(opts.notifyCommand, 'completed', 'Loop ended', checkpoint.iteration);
 }
 // ─── Export for CLI integration ───

package/dist/scripts/docker-run.mjs

@@ -329,7 +329,9 @@ async function main() {
     }
     // 2. Build
     step('2/4 Building container image...');
-    const buildResult = compose(opts.rebuild ? ['build', '--no-cache'] : ['build', '-q']);
+    // Always use --pull to pick up base image updates; --no-cache only on explicit --rebuild
+    const buildArgs = opts.rebuild ? ['build', '--no-cache', '--pull'] : ['build', '--pull', '-q'];
+    const buildResult = compose(buildArgs);
     if (buildResult.status !== 0) {
         error('Docker image build failed. Fix the errors above and re-run.');
         process.exit(1);

package/dist/scripts/lib/formatter.mjs

@@ -0,0 +1,309 @@
+// ─── Beautiful terminal output for autonomous loop ───
+import { appendFileSync } from 'node:fs';
+// ─── ANSI colors ───
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    italic: '\x1b[3m',
+    // Foreground
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    // Bright foreground
+    gray: '\x1b[90m',
+    brightRed: '\x1b[91m',
+    brightGreen: '\x1b[92m',
+    brightYellow: '\x1b[93m',
+    brightBlue: '\x1b[94m',
+    brightMagenta: '\x1b[95m',
+    brightCyan: '\x1b[96m',
+    // Background
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    bgGray: '\x1b[100m',
+};
+// ─── Agent colors (rotating) ───
+const AGENT_COLORS = [c.brightCyan, c.brightMagenta, c.brightGreen, c.brightYellow, c.brightBlue, c.brightRed];
+const agentColorMap = new Map();
+let colorIndex = 0;
+function agentColor(name) {
+    if (!agentColorMap.has(name)) {
+        agentColorMap.set(name, AGENT_COLORS[colorIndex % AGENT_COLORS.length]);
+        colorIndex++;
+    }
+    return agentColorMap.get(name);
+}
+// ─── Tool icons ───
+const TOOL_ICONS = {
+    Bash: '⚡',
+    Read: '📖',
+    Write: '✏️',
+    Edit: '🔧',
+    Glob: '🔍',
+    Grep: '🔎',
+    Agent: '🤖',
+    TodoRead: '📋',
+    TodoWrite: '📝',
+    WebSearch: '🌐',
+    WebFetch: '🌐',
+    AskUserQuestion: '❓',
+};
+function toolIcon(name) {
+    return TOOL_ICONS[name] || '⚙️';
+}
+// ─── Time formatting ───
+function ts() {
+    return new Date().toLocaleTimeString('en-GB', { hour12: false });
+}
+function duration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    if (ms < 3600_000)
+        return `${(ms / 60_000).toFixed(1)}m`;
+    return `${(ms / 3600_000).toFixed(1)}h`;
+}
+// ─── Formatting helpers ───
+function truncate(s, max) {
+    const clean = s.replace(/\n/g, ' ').trim();
+    return clean.length > max ? clean.slice(0, max) + '…' : clean;
+}
+function formatPath(path) {
+    // Shorten long paths: /project/libs/shared/ui/src/lib/component.ts → .../ui/src/lib/component.ts
+    const short = path.replace(/^\/project\//, '');
+    return `${c.cyan}${short}${c.reset}`;
+}
+function formatCommand(cmd) {
+    const short = truncate(cmd, 80);
+    return `${c.yellow}${short}${c.reset}`;
+}
+// ─── Main formatter class ───
+export class Formatter {
+    logFile;
+    iterStartTime = 0;
+    totalTokens = { input: 0, output: 0 };
+    toolCalls = 0;
+    agentStack = [];
+    constructor(logFile) {
+        this.logFile = logFile;
+    }
+    // ── Raw log (file only, no formatting) ──
+    fileLog(msg) {
+        if (!this.logFile)
+            return;
+        try {
+            appendFileSync(this.logFile, `[${new Date().toISOString()}] ${msg}\n`);
+        }
+        catch { /* */ }
+    }
+    // ── Print to console + file ──
+    print(formatted, raw) {
+        console.log(formatted);
+        this.fileLog(raw || formatted.replace(/\x1b\[[0-9;]*m/g, ''));
+    }
+    // ─── Public API ───
+    banner() {
+        this.print('');
+        this.print(`${c.bold}${c.cyan}  ╔══════════════════════════════════════════════╗${c.reset}`);
+        this.print(`${c.bold}${c.cyan}  ║   ${c.white}Claude Starter Kit — Autonomous Loop${c.cyan}       ║${c.reset}`);
+        this.print(`${c.bold}${c.cyan}  ╚══════════════════════════════════════════════╝${c.reset}`);
+        this.print('');
+    }
+    info(msg) {
+        this.print(`  ${c.gray}${ts()}${c.reset}  ${c.blue}ℹ${c.reset}  ${msg}`);
+    }
+    warn(msg) {
+        this.print(`  ${c.gray}${ts()}${c.reset}  ${c.yellow}⚠${c.reset}  ${c.yellow}${msg}${c.reset}`);
+    }
+    error(msg) {
+        this.print(`  ${c.gray}${ts()}${c.reset}  ${c.red}✗${c.reset}  ${c.red}${msg}${c.reset}`);
+    }
+    success(msg) {
+        this.print(`  ${c.gray}${ts()}${c.reset}  ${c.green}✓${c.reset}  ${c.green}${msg}${c.reset}`);
+    }
+    iterationStart(i, max) {
+        this.iterStartTime = Date.now();
+        this.toolCalls = 0;
+        const pct = Math.round((i / max) * 100);
+        const bar = progressBar(pct, 20);
+        this.print('');
+        this.print(`  ${c.bold}${c.white}─── Iteration ${i}/${max} ${c.gray}${bar} ${pct}%${c.reset}`);
+        this.print('');
+    }
+    iterationEnd() {
+        const elapsed = Date.now() - this.iterStartTime;
+        const tokens = this.totalTokens.input + this.totalTokens.output;
+        this.print('');
+        this.print(`  ${c.gray}──── ${duration(elapsed)} │ ${this.toolCalls} tools │ ${formatTokens(tokens)} tokens ────${c.reset}`);
+    }
+    // ─── SDK Message handling ───
+    handleMessage(message) {
+        const msg = message;
+        switch (message.type) {
+            case 'assistant':
+                this.handleAssistant(msg);
+                break;
+            case 'user':
+                this.handleToolResult(msg);
+                break;
+            case 'system':
+                this.handleSystem(msg);
+                break;
+            case 'result':
+                this.handleResult(msg);
+                break;
+            default:
+                // Silently skip unknown types (stream_event, etc.)
+                break;
+        }
+    }
+    handleAssistant(msg) {
+        const content = msg.message?.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (block.type === 'text' && block.text?.trim()) {
+                const text = truncate(block.text, 300);
+                const indent = this.indent();
+                this.print(`${indent}${c.white}${text}${c.reset}`, `TEXT: ${text}`);
+            }
+            if (block.type === 'tool_use') {
+                this.handleToolUse(block);
+            }
+        }
+        // Track tokens from usage
+        if (msg.message?.usage) {
+            this.totalTokens.input += msg.message.usage.input_tokens || 0;
+            this.totalTokens.output += msg.message.usage.output_tokens || 0;
+        }
+    }
+    handleToolUse(block) {
+        this.toolCalls++;
+        const name = block.name || 'unknown';
+        const icon = toolIcon(name);
+        const input = block.input || {};
+        const indent = this.indent();
+        if (name === 'Agent') {
+            // Agent delegation — show agent name and description
+            const agentType = input.subagent_type || input.type || 'agent';
+            const desc = truncate(input.description || input.prompt || '', 60);
+            const col = agentColor(agentType);
+            this.agentStack.push(agentType);
+            this.print(`${indent}${icon}  ${col}${c.bold}${agentType}${c.reset} ${c.gray}${desc}${c.reset}`, `AGENT: ${agentType} — ${desc}`);
+            return;
+        }
+        // Format based on tool type
+        let detail = '';
+        if (name === 'Bash') {
+            detail = formatCommand(input.command || '');
+        }
+        else if (name === 'Read') {
+            detail = formatPath(input.file_path || '');
+        }
+        else if (name === 'Write' || name === 'Edit') {
+            detail = formatPath(input.file_path || '');
+        }
+        else if (name === 'Glob') {
+            detail = `${c.cyan}${input.pattern || ''}${c.reset}`;
+        }
+        else if (name === 'Grep') {
+            detail = `${c.cyan}/${input.pattern || ''}/`;
+            if (input.path)
+                detail += ` ${c.gray}in ${input.path}`;
+            detail += c.reset;
+        }
+        else if (name === 'TodoWrite') {
+            detail = `${c.gray}updating task list${c.reset}`;
+        }
+        else if (name === 'TodoRead') {
+            detail = `${c.gray}reading task list${c.reset}`;
+        }
+        else {
+            const summary = truncate(JSON.stringify(input), 80);
+            detail = `${c.gray}${summary}${c.reset}`;
+        }
+        this.print(`${indent}${c.gray}${ts()}${c.reset}  ${icon}  ${c.bold}${name}${c.reset}  ${detail}`, `TOOL: ${name} ${JSON.stringify(input).slice(0, 200)}`);
+    }
+    handleToolResult(msg) {
+        const content = msg.message?.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (block.type !== 'tool_result')
+                continue;
+            const output = String(block.content || '').trim();
+            const isError = block.is_error === true;
+            const indent = this.indent();
+            if (isError) {
+                const short = truncate(output, 120);
+                this.print(`${indent}       ${c.red}✗ ${short}${c.reset}`, `ERROR: ${short}`);
+            }
+            else if (output && output.length > 0) {
+                // Show short results inline, skip very long ones
+                if (output.length < 200) {
+                    const short = truncate(output, 120);
+                    this.print(`${indent}       ${c.green}✓${c.reset} ${c.gray}${short}${c.reset}`, `RESULT: ${short}`);
+                }
+                else {
+                    const lines = output.split('\n').length;
+                    this.print(`${indent}       ${c.green}✓${c.reset} ${c.gray}${lines} lines${c.reset}`, `RESULT: (${lines} lines)`);
+                }
+            }
+        }
+    }
+    handleSystem(msg) {
+        if (msg.subtype === 'task_progress') {
+            const desc = msg.description || '';
+            if (desc) {
+                const indent = this.indent();
+                this.print(`${indent}       ${c.dim}${truncate(desc, 80)}${c.reset}`, `PROGRESS: ${desc}`);
+            }
+            return;
+        }
+        // Other system messages
+        const text = msg.message || JSON.stringify(msg).slice(0, 150);
+        this.info(`${c.dim}${truncate(String(text), 120)}${c.reset}`);
+    }
+    handleResult(msg) {
+        const sessionId = msg.session_id;
+        if (sessionId) {
+            this.fileLog(`SESSION: ${sessionId}`);
+        }
+        this.success('Iteration complete');
+    }
+    // ─── Helpers ───
+    indent() {
+        const depth = this.agentStack.length;
+        if (depth === 0)
+            return '  ';
+        return '  ' + '│ '.repeat(depth);
+    }
+    // Reset agent stack between iterations
+    resetAgentStack() {
+        this.agentStack = [];
+    }
+    getSessionId(msg) {
+        return msg.session_id ?? null;
+    }
+}
+// ─── Utilities ───
+function progressBar(pct, width) {
+    const filled = Math.round((pct / 100) * width);
+    const empty = width - filled;
+    return `${c.green}${'█'.repeat(filled)}${c.gray}${'░'.repeat(empty)}${c.reset}`;
+}
+function formatTokens(n) {
+    if (n < 1000)
+        return String(n);
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return `${(n / 1_000_000).toFixed(2)}M`;
+}

package/dist/scripts/lib/formatter.spec.js

@@ -0,0 +1,262 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, rmSync, readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Formatter } from './formatter.mjs';
+const TEST_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '__fmt_test_tmp__');
+const LOG_FILE = resolve(TEST_DIR, 'test.log');
+beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+    vi.spyOn(console, 'log').mockImplementation(() => { });
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+    rmSync(TEST_DIR, { recursive: true, force: true });
+});
+function readLog() {
+    try {
+        return readFileSync(LOG_FILE, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+describe('Formatter', () => {
+    it('creates instance with log file', () => {
+        const fmt = new Formatter(LOG_FILE);
+        expect(fmt).toBeDefined();
+    });
+    it('banner outputs to console', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.banner();
+        expect(console.log).toHaveBeenCalled();
+    });
+    it('info writes to console and file', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.info('test message');
+        expect(console.log).toHaveBeenCalled();
+        const log = readLog();
+        expect(log).toContain('test message');
+    });
+    it('warn writes with warning indicator', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.warn('warning msg');
+        const log = readLog();
+        expect(log).toContain('warning msg');
+    });
+    it('error writes with error indicator', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.error('error msg');
+        const log = readLog();
+        expect(log).toContain('error msg');
+    });
+    it('success writes with success indicator', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.success('done');
+        const log = readLog();
+        expect(log).toContain('done');
+    });
+    it('iterationStart writes iteration header', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.iterationStart(3, 50);
+        const calls = console.log.mock.calls.map((c) => c[0]);
+        const joined = calls.join('\n');
+        expect(joined).toContain('3');
+        expect(joined).toContain('50');
+    });
+    it('iterationEnd writes summary', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.iterationStart(1, 10);
+        fmt.iterationEnd();
+        const calls = console.log.mock.calls.map((c) => c[0]);
+        const joined = calls.join('\n');
+        expect(joined).toContain('tools');
+        expect(joined).toContain('tokens');
+    });
+});
+describe('Formatter.handleMessage', () => {
+    it('handles assistant text messages', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: { content: [{ type: 'text', text: 'Hello from Claude' }] },
+        });
+        const log = readLog();
+        expect(log).toContain('Hello from Claude');
+    });
+    it('handles tool_use Bash', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Bash', input: { command: 'ls -la' } }] },
+        });
+        const log = readLog();
+        expect(log).toContain('Bash');
+        expect(log).toContain('ls -la');
+    });
+    it('handles tool_use Read', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/project/src/index.ts' } }] },
+        });
+        const log = readLog();
+        expect(log).toContain('Read');
+        expect(log).toContain('index.ts');
+    });
+    it('handles tool_use Write', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Write', input: { file_path: '/project/new-file.ts' } }] },
+        });
+        const log = readLog();
+        expect(log).toContain('Write');
+        expect(log).toContain('new-file.ts');
+    });
+    it('handles tool_use Edit', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Edit', input: { file_path: '/project/file.ts' } }] },
+        });
+        const log = readLog();
+        expect(log).toContain('Edit');
+    });
+    it('handles tool_use Glob', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Glob', input: { pattern: '**/*.ts' } }] },
+        });
+        const log = readLog();
+        expect(log).toContain('Glob');
+        expect(log).toContain('**/*.ts');
+    });
+    it('handles tool_use Grep', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Grep', input: { pattern: 'TODO', path: 'src/' } }] },
+        });
+        const log = readLog();
+        expect(log).toContain('Grep');
+        expect(log).toContain('TODO');
+    });
+    it('handles Agent delegation', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'backend-ts-architect', description: 'Plan API design' } }] },
+        });
+        const log = readLog();
+        expect(log).toContain('backend-ts-architect');
+        expect(log).toContain('Plan API design');
+    });
+    it('handles tool results (short)', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', content: 'file1.ts\nfile2.ts', is_error: false }] },
+        });
+        const log = readLog();
+        expect(log).toContain('file1.ts');
+    });
+    it('handles tool results (long → line count)', () => {
+        const fmt = new Formatter(LOG_FILE);
+        const longOutput = Array.from({ length: 50 }, (_, i) => `line ${i}`).join('\n');
+        fmt.handleMessage({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', content: longOutput, is_error: false }] },
+        });
+        const log = readLog();
+        expect(log).toContain('50 lines');
+    });
+    it('handles tool error results', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', content: 'Permission denied', is_error: true }] },
+        });
+        const log = readLog();
+        expect(log).toContain('Permission denied');
+    });
+    it('handles system task_progress', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'system',
+            subtype: 'task_progress',
+            description: 'Reading package.json',
+        });
+        const log = readLog();
+        expect(log).toContain('Reading package.json');
+    });
+    it('handles result message', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'result',
+            session_id: 'abc-123',
+        });
+        const log = readLog();
+        expect(log).toContain('SESSION: abc-123');
+    });
+    it('getSessionId extracts session_id', () => {
+        const fmt = new Formatter(LOG_FILE);
+        expect(fmt.getSessionId({ session_id: 'test-id' })).toBe('test-id');
+        expect(fmt.getSessionId({})).toBeNull();
+    });
+    it('ignores unknown message types silently', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({ type: 'stream_event', data: 'something' });
+        const log = readLog();
+        expect(log).toBe('');
+    });
+    it('handles multiple content blocks in one message', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: {
+                content: [
+                    { type: 'text', text: 'Planning the implementation' },
+                    { type: 'tool_use', name: 'Read', input: { file_path: '/project/src/main.ts' } },
+                    { type: 'tool_use', name: 'Bash', input: { command: 'npm test' } },
+                ],
+            },
+        });
+        const log = readLog();
+        expect(log).toContain('Planning the implementation');
+        expect(log).toContain('Read');
+        expect(log).toContain('Bash');
+        expect(log).toContain('npm test');
+    });
+    it('tracks tokens from usage', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.iterationStart(1, 10);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: {
+                content: [{ type: 'text', text: 'hi' }],
+                usage: { input_tokens: 1000, output_tokens: 500 },
+            },
+        });
+        fmt.iterationEnd();
+        const calls = console.log.mock.calls.map((c) => c[0]);
+        const summary = calls.join('\n');
+        expect(summary).toContain('1.5K');
+    });
+    it('increments tool call counter', () => {
+        const fmt = new Formatter(LOG_FILE);
+        fmt.iterationStart(1, 10);
+        fmt.handleMessage({
+            type: 'assistant',
+            message: { content: [
+                    { type: 'tool_use', name: 'Read', input: { file_path: 'a.ts' } },
+                    { type: 'tool_use', name: 'Read', input: { file_path: 'b.ts' } },
+                ] },
+        });
+        fmt.iterationEnd();
+        const calls = console.log.mock.calls.map((c) => c[0]);
+        const summary = calls.join('\n');
+        expect(summary).toContain('2 tools');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-workspace",
-  "version": "1.1.120",
+  "version": "1.1.122",
   "author": "",
   "repository": {
     "type": "git",