create-claude-workspace 1.1.136 → 1.1.138

package/dist/scripts/autonomous.mjs

@@ -7,7 +7,7 @@ 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 { TUI } from './lib/tui.mjs';
+import { TUI } from './lib/tui.js';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { config as dotenvConfig } from '@dotenvx/dotenvx';
 // ─── Args ───
@@ -420,16 +420,21 @@ async function main() {
                 claudeMd = readFileSync(claudeMdPath, 'utf-8');
             else if (existsSync(dotClaudeMdPath))
                 claudeMd = readFileSync(dotClaudeMdPath, 'utf-8');
+            // Build system prompt: orchestrator instructions + project CLAUDE.md
+            // Do NOT use preset: 'claude_code' — it adds built-in agents (general-purpose, Explore, Plan)
+            const orchestratorPrompt = agents['orchestrator']?.prompt || '';
+            const systemParts = [orchestratorPrompt, claudeMd].filter(Boolean);
+            const systemPrompt = systemParts.join('\n\n---\n\n');
+            // Only include our agents, not the orchestrator itself (it's the top-level)
+            const subAgents = { ...agents };
+            delete subAgents['orchestrator'];
             const queryOptions = {
-                agents,
-                agent: 'orchestrator',
+                agents: subAgents,
+                systemPrompt: systemPrompt || undefined,
                 model: 'claude-opus-4-6',
                 maxTurns: opts.maxTurns,
                 cwd: opts.projectDir,
             };
-            if (claudeMd) {
-                queryOptions.systemPrompt = { type: 'preset', preset: 'claude_code', append: claudeMd };
-            }
             if (opts.skipPermissions) {
                 queryOptions.permissionMode = 'bypassPermissions';
                 queryOptions.allowDangerouslySkipPermissions = true;

package/dist/scripts/lib/tui.js

@@ -0,0 +1,348 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// ─── Terminal UI for autonomous loop (ink-based) ───
+import { useState, useEffect, useCallback } from 'react';
+import { render, Box, Text, useInput, useApp } from 'ink';
+import { appendFileSync } from 'node:fs';
+// ─── Agent colors ───
+const AGENT_PALETTE = ['cyan', 'magenta', 'green', 'yellow', 'blue', 'red'];
+const agentColorMap = new Map();
+let nextColor = 0;
+function agentColor(name) {
+    if (!agentColorMap.has(name))
+        agentColorMap.set(name, AGENT_PALETTE[nextColor++ % AGENT_PALETTE.length]);
+    return agentColorMap.get(name);
+}
+// ─── Tool icons ───
+const ICONS = {
+    Bash: '⚡', Read: '📖', Write: '✏️ ', Edit: '🔧', Glob: '🔍', Grep: '🔎',
+    Agent: '🤖', TodoRead: '📋', TodoWrite: '📝', WebSearch: '🌐', WebFetch: '🌐', AskUserQuestion: '❓',
+};
+// ─── Helpers ───
+function ts() { return new Date().toLocaleTimeString('en-GB', { hour12: false }); }
+function trunc(s, n) { const c = s.replace(/\n/g, ' ').trim(); return c.length > n ? c.slice(0, n) + '…' : c; }
+function fmtTok(n) { return n < 1e3 ? `${n}` : n < 1e6 ? `${(n / 1e3).toFixed(1)}K` : `${(n / 1e6).toFixed(2)}M`; }
+function fmtDur(ms) { return ms < 1e3 ? `${ms}ms` : ms < 6e4 ? `${(ms / 1e3).toFixed(1)}s` : `${(ms / 6e4).toFixed(1)}m`; }
+// ─── Components ───
+function ProgressBar({ pct, width }) {
+    const filled = Math.round((pct / 100) * width);
+    return (_jsxs(Text, { children: [_jsx(Text, { color: "green", children: '█'.repeat(filled) }), _jsx(Text, { color: "gray", children: '░'.repeat(width - filled) })] }));
+}
+function StatusBar({ state }) {
+    const elapsed = fmtDur(Date.now() - state.loopStart);
+    const iterTime = state.iterStart ? fmtDur(Date.now() - state.iterStart) : '—';
+    const pct = state.maxIter > 0 ? Math.round((state.iteration / state.maxIter) * 100) : 0;
+    const tok = fmtTok(state.tokensIn + state.tokensOut);
+    const curAgent = state.agents.length > 0 ? state.agents[state.agents.length - 1] : '';
+    return (_jsx(Box, { children: _jsxs(Text, { backgroundColor: "gray", children: [' ', _jsx(Text, { color: "white", bold: true, children: elapsed }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsxs(Text, { children: ["Iter ", state.iteration, "/", state.maxIter, " "] }), _jsx(ProgressBar, { pct: pct, width: 8 }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { children: iterTime }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "cyan", children: state.tools }), _jsx(Text, { children: " tools" }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "yellow", children: tok }), _jsx(Text, { children: " tok" }), curAgent && _jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: agentColor(curAgent), bold: true, children: curAgent })] }), state.taskName && _jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "cyan", children: trunc(state.taskName, 20) })] }), state.paused && _jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "yellow", children: "\u23F8 PAUSED" })] }), state.inputBuf && _jsx(_Fragment, { children: _jsxs(Text, { children: ["  \u203A ", state.inputBuf] }) }), ' '] }) }));
+}
+function LogView({ lines }) {
+    return (_jsx(Box, { flexDirection: "column", children: lines.map((line) => (_jsxs(Box, { children: [line.agent && (_jsx(Text, { color: agentColor(line.agent), children: line.agent.slice(0, 14).padEnd(15) })), _jsx(Text, { color: line.color, dimColor: line.dim, bold: line.bold, children: line.text })] }, line.id))) }));
+}
+function App({ stateRef, onInput, onHotkey }) {
+    const [, setTick] = useState(0);
+    const { exit } = useApp();
+    // Rerender every 100ms to update timer
+    useEffect(() => {
+        const timer = setInterval(() => setTick(t => t + 1), 100);
+        return () => clearInterval(timer);
+    }, []);
+    useInput(useCallback((input, key) => {
+        if (key.ctrl && input === 'c') {
+            onHotkey?.('quit');
+            exit();
+            return;
+        }
+        if (key.ctrl && input === 'z') {
+            stateRef.current.paused = !stateRef.current.paused;
+            onHotkey?.(stateRef.current.paused ? 'pause' : 'resume');
+            return;
+        }
+        if (key.ctrl && input === 's') {
+            onHotkey?.('stop');
+            return;
+        }
+        if (key.return) {
+            if (stateRef.current.inputBuf.trim())
+                onInput?.(stateRef.current.inputBuf.trim());
+            stateRef.current.inputBuf = '';
+            return;
+        }
+        if (key.backspace || key.delete) {
+            stateRef.current.inputBuf = stateRef.current.inputBuf.slice(0, -1);
+            return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+            stateRef.current.inputBuf += input;
+        }
+    }, [stateRef, onInput, onHotkey, exit]));
+    const state = stateRef.current;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(LogView, { lines: state.lines }), _jsx(StatusBar, { state: state })] }));
+}
+// ─── TUI class (same public API as before) ───
+export class TUI {
+    logFile;
+    interactive;
+    onInput = null;
+    onHotkey = null;
+    stateRef;
+    inkInstance = null;
+    lineId = 0;
+    constructor(logFile, interactive = false) {
+        this.logFile = logFile;
+        this.interactive = interactive && process.stdin.isTTY === true;
+        this.stateRef = {
+            current: {
+                lines: [],
+                iteration: 0,
+                maxIter: 0,
+                loopStart: Date.now(),
+                iterStart: 0,
+                tools: 0,
+                tokensIn: 0,
+                tokensOut: 0,
+                agents: [],
+                taskName: '',
+                tasksDone: 0,
+                tasksTotal: 0,
+                paused: false,
+                inputBuf: '',
+                tick: 0,
+            },
+        };
+        if (this.interactive) {
+            this.inkInstance = render(_jsx(App, { stateRef: this.stateRef, onInput: (input) => this.onInput?.(input), onHotkey: (action) => this.onHotkey?.(action) }));
+        }
+    }
+    destroy() {
+        this.inkInstance?.unmount();
+    }
+    setInputHandler(handler) { this.onInput = handler; }
+    setHotkeyHandler(handler) { this.onHotkey = handler; }
+    isPaused() { return this.stateRef.current.paused; }
+    // ─── Log output ───
+    push(text, raw, opts) {
+        const agent = this.stateRef.current.agents.length > 0
+            ? this.stateRef.current.agents[this.stateRef.current.agents.length - 1]
+            : undefined;
+        const line = {
+            id: this.lineId++,
+            text,
+            raw: raw || text,
+            agent,
+            ...opts,
+        };
+        if (this.interactive) {
+            this.stateRef.current.lines.push(line);
+            // Keep last 500 lines
+            if (this.stateRef.current.lines.length > 500) {
+                this.stateRef.current.lines = this.stateRef.current.lines.slice(-500);
+            }
+        }
+        else {
+            // Non-interactive: print with ANSI colors
+            const prefix = agent ? `\x1b[${colorCode(agentColor(agent))}m${agent.slice(0, 14).padEnd(15)}\x1b[0m` : '';
+            const colored = opts?.color ? `\x1b[${colorCode(opts.color)}m${text}\x1b[0m` : text;
+            console.log(`${prefix}${colored}`);
+        }
+        if (this.logFile) {
+            try {
+                appendFileSync(this.logFile, `[${new Date().toISOString()}] ${line.raw}\n`);
+            }
+            catch { /* */ }
+        }
+    }
+    fileOnly(msg) {
+        if (this.logFile) {
+            try {
+                appendFileSync(this.logFile, `[${new Date().toISOString()}] ${msg}\n`);
+            }
+            catch { /* */ }
+        }
+    }
+    // ─── Public methods ───
+    banner() {
+        this.push('');
+        this.push('  ╔══════════════════════════════════════════════╗', undefined, { color: 'cyan', bold: true });
+        this.push('  ║   Claude Starter Kit — Autonomous Loop       ║', undefined, { color: 'cyan', bold: true });
+        this.push('  ╚══════════════════════════════════════════════╝', undefined, { color: 'cyan', bold: true });
+        if (this.interactive) {
+            this.push('  Ctrl+Z pause │ Ctrl+S stop │ Ctrl+C quit │ Type to send input', undefined, { color: 'gray' });
+        }
+        this.push('');
+    }
+    info(msg) { this.push(`  ${ts()}  ℹ  ${msg}`, `INFO: ${msg}`); }
+    warn(msg) { this.push(`  ${ts()}  ⚠  ${msg}`, `WARN: ${msg}`, { color: 'yellow' }); }
+    error(msg) { this.push(`  ${ts()}  ✗  ${msg}`, `ERROR: ${msg}`, { color: 'red' }); }
+    success(msg) { this.push(`  ${ts()}  ✓  ${msg}`, `OK: ${msg}`, { color: 'green' }); }
+    setIteration(i, max) {
+        const s = this.stateRef.current;
+        s.iteration = i;
+        s.maxIter = max;
+        s.iterStart = Date.now();
+        s.tools = 0;
+        s.tokensIn = 0;
+        s.tokensOut = 0;
+        s.agents = [];
+        const pct = Math.round((i / max) * 100);
+        const elapsed = fmtDur(Date.now() - s.loopStart);
+        this.push('');
+        this.push(`  ━━━ Iteration ${i}/${max}  ${pct}%  │ ${elapsed} elapsed ━━━`, `--- Iteration ${i}/${max} ---`, { bold: true });
+        if (s.taskName) {
+            const tPct = s.tasksTotal > 0 ? Math.round((s.tasksDone / s.tasksTotal) * 100) : 0;
+            this.push(`  📋 ${s.taskName}  (${s.tasksDone}/${s.tasksTotal} tasks ${tPct}%)`, undefined, { color: 'cyan' });
+        }
+        this.push('');
+    }
+    setTask(name, done, total) {
+        const s = this.stateRef.current;
+        s.taskName = name;
+        s.tasksDone = done;
+        s.tasksTotal = total;
+    }
+    iterationEnd() {
+        const s = this.stateRef.current;
+        const iterElapsed = fmtDur(Date.now() - s.iterStart);
+        const totalElapsed = fmtDur(Date.now() - s.loopStart);
+        const tok = fmtTok(s.tokensIn + s.tokensOut);
+        this.push('');
+        this.push(`  ━━━━ ${iterElapsed} (iter) │ ${totalElapsed} (total) │ ${s.tools} tools │ ${tok} tokens ━━━━`, undefined, { color: 'gray' });
+    }
+    // ─── SDK message handler ───
+    handleMessage(message) {
+        switch (message.type) {
+            case 'assistant':
+                this.onAssistant(message);
+                break;
+            case 'user':
+                this.onToolResult(message);
+                break;
+            case 'system':
+                this.onSystem(message);
+                break;
+            case 'result':
+                this.onResult(message);
+                break;
+        }
+    }
+    onAssistant(msg) {
+        const content = msg.message?.content;
+        if (!Array.isArray(content))
+            return;
+        const s = this.stateRef.current;
+        if (msg.message?.usage) {
+            s.tokensIn += msg.message.usage.input_tokens || 0;
+            s.tokensOut += msg.message.usage.output_tokens || 0;
+        }
+        for (const block of content) {
+            if (block.type === 'text' && block.text?.trim()) {
+                this.push(`  ${trunc(block.text, 300)}`, `TEXT: ${trunc(block.text, 300)}`);
+            }
+            if (block.type === 'tool_use')
+                this.onToolUse(block);
+        }
+    }
+    onToolUse(block) {
+        this.stateRef.current.tools++;
+        const name = block.name || '?';
+        const icon = ICONS[name] || '⚙️';
+        const input = block.input || {};
+        const time = ts();
+        if (name === 'Agent') {
+            const type = input.subagent_type || input.type || 'agent';
+            const model = input.model || '';
+            const desc = trunc(input.description || input.prompt || '', 50);
+            this.stateRef.current.agents.push(type);
+            this.push(`  ${time}  ${icon}  ${type} ${model ? `(${model})` : ''} ${desc}`, `AGENT: ${type} ${model} — ${desc}`, { bold: true });
+            return;
+        }
+        let detail;
+        switch (name) {
+            case 'Bash':
+                detail = trunc(input.command || '', 70);
+                break;
+            case 'Read':
+                detail = (input.file_path || '').replace(/^\/project\//, '');
+                break;
+            case 'Write':
+            case 'Edit':
+                detail = (input.file_path || '').replace(/^\/project\//, '');
+                break;
+            case 'Glob':
+                detail = input.pattern || '';
+                break;
+            case 'Grep':
+                detail = `/${input.pattern || ''}/${input.path ? ` in ${input.path}` : ''}`;
+                break;
+            default: detail = trunc(JSON.stringify(input), 60);
+        }
+        this.push(`  ${time}  ${icon}  ${name}  ${detail}`, `TOOL: ${name} ${JSON.stringify(input).slice(0, 200)}`);
+    }
+    onToolResult(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();
+            if (!output)
+                continue;
+            if (block.is_error) {
+                this.push(`         ✗ ${trunc(output, 100)}`, `ERROR: ${trunc(output, 100)}`, { color: 'red' });
+            }
+            else if (output.length < 150) {
+                this.push(`         ✓ ${trunc(output, 100)}`, `OK: ${trunc(output, 100)}`, { color: 'green', dim: true });
+            }
+            else {
+                const n = output.split('\n').length;
+                this.push(`         ✓ ${n} lines`, `OK: (${n} lines)`, { color: 'green', dim: true });
+            }
+        }
+    }
+    onSystem(msg) {
+        if (msg.subtype === 'init') {
+            this.push(`  ${ts()}  ⚙  Claude Code ${msg.claude_code_version || ''} │ Model: ${msg.model || '?'} │ Agents: ${msg.agents?.join(', ') || 'none'}`, undefined, { color: 'cyan' });
+            if (this.stateRef.current.agents.length === 0 && msg.agents?.length) {
+                this.stateRef.current.agents.push(msg.agents[0]);
+                this.push(`  ${ts()}  🤖  ${msg.agents[0]} (${msg.model || '?'})`, `AGENT_START: ${msg.agents[0]}`, { bold: true });
+            }
+            return;
+        }
+        if (msg.subtype === 'task_started') {
+            const desc = msg.description || '';
+            this.stateRef.current.agents.push(desc);
+            this.push(`  ${ts()}  🤖  ${desc}`, `AGENT_START: ${desc}`, { bold: true });
+            return;
+        }
+        if (msg.subtype === 'task_notification') {
+            const status = msg.status || '';
+            const name = this.stateRef.current.agents.length > 0 ? this.stateRef.current.agents.pop() : 'agent';
+            const summary = msg.summary ? ` ${trunc(msg.summary, 60)}` : '';
+            const color = status === 'completed' ? 'green' : 'red';
+            this.push(`  ${ts()}  ${status === 'completed' ? '✓' : '✗'}  ${name} ${status}${summary}`, `AGENT_END: ${name} ${status}`, { color });
+            return;
+        }
+        if (msg.subtype === 'task_progress' && msg.description) {
+            this.push(`         ${trunc(msg.description, 70)}`, `PROGRESS: ${msg.description}`, { dim: true });
+            return;
+        }
+        if (msg.subtype === 'api_retry') {
+            this.push(`  ${ts()}  ↻  API retry ${msg.attempt}/${msg.max_retries} (${msg.error || ''})`, undefined, { color: 'yellow' });
+            return;
+        }
+    }
+    onResult(msg) {
+        if (msg.session_id)
+            this.fileOnly(`SESSION: ${msg.session_id}`);
+    }
+    resetAgentStack() { this.stateRef.current.agents = []; }
+    getSessionId(msg) { return msg.session_id ?? null; }
+}
+// ─── Color code helper for non-interactive fallback ───
+function colorCode(color) {
+    const map = {
+        red: '31', green: '32', yellow: '33', blue: '34', magenta: '35',
+        cyan: '36', white: '37', gray: '90',
+    };
+    return map[color] || '37';
+}

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

@@ -2,7 +2,7 @@ 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 { TUI } from './tui.mjs';
+import { TUI } from './tui.js';
 // Helper to create partial SDK messages for testing
 function msg(partial) {
     return { parent_tool_use_id: null, uuid: 'test', session_id: 'test', ...partial };
@@ -170,8 +170,9 @@ describe('TUI — message handling', () => {
             message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/project/b.ts' } }] },
         }));
         const out = consoleOutput();
-        // Should have pipe characters for nesting
-        expect(out).toContain('│');
+        // Should show agent names as prefix
+        expect(out).toContain('orchestrator');
+        expect(out).toContain('reviewer');
     });
     it('handles short tool results', () => {
         const tui = new TUI(LOG_FILE, false);

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "create-claude-workspace",
-  "version": "1.1.136",
+  "version": "1.1.138",
   "author": "",
   "repository": {
     "type": "git",
     "url": "git+https://gitlab.com/LadaBr/claude-starter-kit.git"
   },
   "devDependencies": {
+    "@types/react": "^19.2.14",
     "typescript": "^5.8.0",
     "vitest": "^4.0.18"
   },
@@ -42,6 +43,8 @@
   "type": "module",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.81",
-    "@dotenvx/dotenvx": "^1.57.2"
+    "@dotenvx/dotenvx": "^1.57.2",
+    "ink": "^6.8.0",
+    "react": "^19.2.4"
   }
 }