create-claude-workspace 1.1.117 → 1.1.118

package/package.json

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

package/dist/scripts/lib/agent-tag.integration.spec.js

@@ -1,197 +0,0 @@
-// ─── Integration tests: agent tag + color in real Claude CLI stream ───
-// Spawns actual `claude` process and verifies agent tags appear in formatted output.
-import { describe, it, expect, beforeEach } from 'vitest';
-import { execSync, spawn } from 'node:child_process';
-import { resetStreamState, setAgentTag, simplifyModelName, colorizeAgent, formatStreamEvent, formatStreamEventTracked, } from './claude-runner.mjs';
-// ─── ANSI helpers ───
-function stripAnsi(s) {
-    return s.replace(/\x1b\[\d+m/g, '');
-}
-// ─── Check if claude CLI is available ───
-function claudeAvailable() {
-    try {
-        execSync('claude --version', { stdio: 'pipe', timeout: 5000 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-const hasClaude = claudeAvailable();
-function spawnClaude(prompt, maxTurns, extraFlags = []) {
-    const isWin = process.platform === 'win32';
-    const flags = [
-        '-p',
-        '--output-format', 'stream-json',
-        '--verbose',
-        '--include-partial-messages',
-        '--max-turns', String(maxTurns),
-        ...extraFlags,
-    ];
-    const child = isWin
-        ? spawn(process.env.ComSpec ?? 'cmd.exe', ['/c', 'claude', ...flags], {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            windowsHide: true,
-        })
-        : spawn('claude', [...flags, prompt], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-    if (isWin && child.stdin) {
-        child.stdin.write(prompt);
-        child.stdin.end();
-    }
-    setAgentTag('orchestrator');
-    const rawEvents = [];
-    const formattedLines = [];
-    let detectedModel = '';
-    return new Promise((resolve) => {
-        let buffer = '';
-        child.stdout.on('data', (chunk) => {
-            buffer += chunk.toString();
-            const lines = buffer.split('\n');
-            buffer = lines.pop();
-            for (const rawLine of lines) {
-                const line = rawLine.replace(/\r/g, '');
-                if (!line.trim())
-                    continue;
-                let event;
-                try {
-                    event = JSON.parse(line);
-                }
-                catch {
-                    continue;
-                }
-                rawEvents.push(event);
-                if (event.type === 'system' && typeof event.model === 'string') {
-                    detectedModel = simplifyModelName(event.model);
-                    setAgentTag('orchestrator', detectedModel);
-                }
-                const formatted = formatStreamEventTracked(event);
-                if (formatted) {
-                    formattedLines.push(formatted);
-                    process.stdout.write(formatted);
-                }
-            }
-        });
-        child.stderr.on('data', () => { });
-        child.on('close', () => resolve({ rawEvents, formattedLines, detectedModel }));
-    });
-}
-// ─── Tests ───
-describe('agent tag integration: real Claude CLI', () => {
-    beforeEach(() => {
-        resetStreamState();
-    });
-    it.skipIf(!hasClaude)('spawns claude and verifies agent tag in stream output', async () => {
-        const result = await spawnClaude('Respond with exactly: ok', 1);
-        // System event with model
-        const systemEvent = result.rawEvents.find(e => e.type === 'system');
-        expect(systemEvent, 'system event should be present').toBeDefined();
-        expect(systemEvent.model, 'system event should contain model').toBeDefined();
-        console.log(`\nDetected model: ${systemEvent.model} → simplified: ${result.detectedModel}`);
-        // Model simplified correctly
-        expect(result.detectedModel).toMatch(/^\w+-\d+(\.\d+)?$/);
-        // Formatted output contains agent tag with model
-        const allPlain = result.formattedLines.map(stripAnsi).join('');
-        expect(allPlain).toContain('orchestrator');
-        expect(allPlain).toContain(result.detectedModel);
-        // At least one line has full tag format
-        const hasFullTag = result.formattedLines.some(line => stripAnsi(line).includes(`orchestrator/${result.detectedModel}`));
-        expect(hasFullTag, `expected "orchestrator/${result.detectedModel}" in output`).toBe(true);
-        console.log(`\n═══ ${result.rawEvents.length} events, ${result.formattedLines.length} formatted lines ═══`);
-        console.log(`Event types: ${[...new Set(result.rawEvents.map(e => e.type))].join(', ')}`);
-    }, 60_000);
-    it.skipIf(!hasClaude)('shows sub-agent name when Agent tool is used', async () => {
-        // Use a custom agent defined in .claude/agents/test-dummy.md (model: haiku)
-        // This mirrors how orchestrator delegates: subagent_type="test-dummy", model="haiku"
-        const prompt = [
-            'You MUST use the Agent tool exactly once.',
-            'Call it with: subagent_type "test-dummy", model "haiku", description "find ts files",',
-            'prompt "Use Glob with pattern **/*.mts to find TypeScript files. Return the list."',
-            'After the Agent tool returns, respond with: done',
-        ].join(' ');
-        const result = await spawnClaude(prompt, 5, ['--dangerously-skip-permissions']);
-        // Find assistant events with Agent tool_use
-        const agentToolEvents = result.rawEvents.filter(e => {
-            if (e.type !== 'assistant')
-                return false;
-            const msg = e.message;
-            if (!msg || typeof msg === 'string')
-                return false;
-            const content = msg.content;
-            return content?.some(b => b.type === 'tool_use' && b.name === 'Agent');
-        });
-        console.log(`\n═══ Sub-agent test: ${result.rawEvents.length} events, ${agentToolEvents.length} Agent tool calls ═══`);
-        // Verify Agent tool was called
-        expect(agentToolEvents.length, 'expected at least one Agent tool_use event').toBeGreaterThanOrEqual(1);
-        // Verify formatted output contains the robot icon and sub-agent identifier
-        const allPlain = result.formattedLines.map(stripAnsi).join('');
-        expect(allPlain, 'expected 🤖 icon for Agent tool call').toContain('🤖');
-        expect(allPlain, 'expected → arrow for sub-agent delegation').toContain('→');
-        // Verify the delegation line shows orchestrator (parent) + agent name
-        const agentLine = result.formattedLines.find(l => stripAnsi(l).includes('🤖'));
-        expect(agentLine, 'expected a formatted line with 🤖').toBeDefined();
-        const agentLinePlain = stripAnsi(agentLine);
-        console.log(`Delegation line: ${agentLinePlain.trim()}`);
-        // Delegation line should show orchestrator as the caller
-        expect(agentLinePlain).toContain(`orchestrator/${result.detectedModel}`);
-        // Should contain agent name "test-dummy" with model "haiku"
-        expect(agentLinePlain, 'expected "test-dummy" in delegation line')
-            .toContain('test-dummy');
-        expect(agentLinePlain, 'expected "haiku" model in delegation line')
-            .toContain('haiku');
-        // Verify sub-agent's internal tool calls show sub-agent name + model (not orchestrator)
-        const plainLines = result.formattedLines.map(stripAnsi);
-        const delegationIdx = plainLines.findIndex(l => l.includes('🤖'));
-        const subAgentLines = plainLines.slice(delegationIdx + 1).filter(l => l.includes('▶') || l.includes('💭'));
-        if (subAgentLines.length > 0) {
-            console.log(`Sub-agent internal tool calls (${subAgentLines.length}):`);
-            for (const line of subAgentLines) {
-                console.log(`  ${line.trim()}`);
-                // Internal tool calls should show "test-dummy/haiku", NOT "orchestrator"
-                expect(line, 'sub-agent tool call should show test-dummy')
-                    .toContain('test-dummy');
-                expect(line, 'sub-agent tool call should show haiku model')
-                    .toContain('haiku');
-                expect(line, 'sub-agent tool call should NOT show orchestrator')
-                    .not.toContain(`orchestrator/${result.detectedModel}`);
-            }
-        }
-        // After Agent returns, verify orchestrator tag is restored
-        const postAgentLines = plainLines.slice(delegationIdx + 1).filter(l => !l.includes('▶') && !l.includes('💭') && !l.includes('✓') && !l.includes('⏳') && l.trim());
-        if (postAgentLines.length > 0) {
-            const lastLine = postAgentLines[postAgentLines.length - 1];
-            console.log(`Post-agent line: ${lastLine.trim()}`);
-            expect(lastLine, 'after Agent returns, orchestrator tag should be restored')
-                .toContain(`orchestrator/${result.detectedModel}`);
-        }
-        console.log(`Event types: ${[...new Set(result.rawEvents.map(e => e.type))].join(', ')}`);
-        console.log('═══ End ═══\n');
-    }, 120_000);
-    it.skipIf(!hasClaude)('agent colors are visible in real formatted output', () => {
-        const agents = [
-            'orchestrator', 'ui-engineer', 'backend-ts-architect',
-            'senior-code-reviewer', 'test-engineer', 'product-owner',
-            'technical-planner', 'devops-integrator', 'deployment-engineer',
-            'project-initializer',
-        ];
-        console.log('\n═══ Agent colors (visual check) ═══');
-        for (const agent of agents) {
-            setAgentTag(agent, 'opus-4.6');
-            const line = formatStreamEvent({
-                type: 'assistant',
-                message: { content: [{ type: 'text', text: `Working on task #42...` }] },
-            });
-            process.stdout.write(line);
-            resetStreamState();
-        }
-        console.log('═══ End of agent colors ═══\n');
-        const orchColor = colorizeAgent('orchestrator').match(/\x1b\[\d+m/)?.[0];
-        for (const agent of agents.slice(1)) {
-            const color = colorizeAgent(agent).match(/\x1b\[\d+m/)?.[0];
-            if (agent !== 'devops-integrator') {
-                expect(color, `${agent} should differ from orchestrator`).not.toBe(orchColor);
-            }
-        }
-    });
-});