@amsterdamdatalabs/enact-factory 0.1.1

package/dist/support/chatTui.js

@@ -0,0 +1,1082 @@
+#!/usr/bin/env tsx
+// EnactFactory - Rich TUI Chat Interface
+// Claude Code style tabbed interface with real-time updates
+import blessed from 'blessed';
+import { resolve } from 'node:path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { getDefaultAdapterName } from '../adapters/index.js';
+import { getDefaultChatModel, resolveChatModel, runChatCompletion, shortenChatModel } from '../support/chatBackend.js';
+import { sessionsPath } from '../factory/paths.js';
+import { requireWorkspaceUiPort } from '../core/workspaceConfig.js';
+// Constants
+const CHAT_DIR = sessionsPath('chat');
+const FACTORY_DASHBOARD_PORT = String(requireWorkspaceUiPort());
+const FACTORY_DASHBOARD_BASE_URL = `http://127.0.0.1:${FACTORY_DASHBOARD_PORT}`;
+// Render guard: blessed는 동시 render() 호출 시 화면이 검은색으로 깨질 수 있음
+let renderScheduled = false;
+let screenRef = null;
+function safeRender() {
+    if (renderScheduled || !screenRef)
+        return;
+    renderScheduled = true;
+    process.nextTick(() => {
+        renderScheduled = false;
+        try {
+            screenRef.render();
+        }
+        catch {
+            // render 실패 시 복구 시도
+            try {
+                screenRef.alloc();
+                screenRef.render();
+            }
+            catch {
+                // 무시 — 다음 사이클에서 복구
+            }
+        }
+    });
+}
+// Session Management
+async function ensureChatDir() {
+    await mkdir(CHAT_DIR, { recursive: true });
+}
+async function saveSession(session) {
+    await ensureChatDir();
+    session.updatedAt = new Date().toISOString();
+    const path = resolve(CHAT_DIR, `${session.id}.json`);
+    await writeFile(path, JSON.stringify(session, null, 2));
+}
+async function loadSession(id) {
+    const path = resolve(CHAT_DIR, `${id}.json`);
+    if (!existsSync(path))
+        return null;
+    const data = JSON.parse(await readFile(path, 'utf-8'));
+    const provider = data.provider ?? inferProvider(undefined, data.model);
+    return {
+        ...data,
+        provider,
+        model: data.model ?? getDefaultChatModel(provider),
+        totalCost: data.totalCost ?? 0,
+        totalTokens: data.totalTokens ?? 0,
+    };
+}
+function generateSessionId() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}`;
+}
+function inferProvider(provider, model) {
+    if (provider)
+        return provider;
+    if (model?.includes('codex'))
+        return 'codex';
+    if (model?.startsWith('gpt-') || model?.startsWith('o3') || model?.startsWith('o4'))
+        return 'responses';
+    return loadDefaultProvider();
+}
+function loadDefaultProvider() {
+    return getDefaultAdapterName();
+}
+// Shared chat backend
+async function callChatModel(prompt, provider, model, sessionId, onStream) {
+    const result = await runChatCompletion({
+        prompt,
+        provider,
+        model,
+        sessionId: provider === 'claude' ? sessionId : undefined,
+        timeoutMs: 180000,
+        onText: onStream,
+    });
+    return {
+        response: result.response,
+        sessionId: result.sessionId ?? '',
+        cost: result.cost ?? 0,
+        tokens: result.tokens ?? 0,
+    };
+}
+// Warhammer 40k Loading Messages
+const LOADING_MESSAGES = [
+    'Initializing cogitator arrays',
+    'Querying data-vault archives',
+    'Accessing servitor protocols',
+    'Compiling neural responses',
+    'Interfacing with the Noosphere',
+    'Scanning data-streams',
+    'Calibrating logic engines',
+    'Decoding transmission packets',
+    'Loading archive databases',
+    'Synchronizing machine protocols',
+    'Analyzing pattern matrices',
+    'Establishing neural link',
+    'Processing data-core output',
+    'Running diagnostics sequence',
+    'Activating response circuits',
+];
+const SPINNER_FRAMES = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+// UI Components - Claude Code Style
+function createUI() {
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: 'Enact Factory Chat',
+        fullUnicode: true,
+        terminal: 'xterm-256color',
+        forceUnicode: true,
+        warnings: false, // Suppress warnings that can corrupt display
+        dockBorders: true, // Better border handling in tmux
+        fastCSR: true, // Faster rendering for streaming
+    });
+    const colors = {
+        bg: '#1a1a1a',
+        statusBg: '#2d3748',
+        statusFg: '#e2e8f0',
+        tabActiveBg: '#4a5568',
+        tabActiveFg: '#f7fafc',
+        tabInactiveBg: '#2d3748',
+        tabInactiveFg: '#a0aec0',
+        border: '#4a5568',
+        borderActive: '#667eea',
+        inputBorder: '#48bb78',
+        scrollbar: '#4a5568',
+        userMessage: '#60a5fa',
+        assistantMessage: '#34d399',
+        dimText: '#718096',
+    };
+    const statusBar = blessed.box({
+        top: 0,
+        left: 0,
+        width: '100%',
+        height: 1,
+        tags: true,
+        style: {
+            fg: colors.statusFg,
+            bg: colors.statusBg,
+        },
+    });
+    const tabBar = blessed.box({
+        top: 1,
+        left: 0,
+        width: '100%',
+        height: 1,
+        tags: true,
+        style: {
+            fg: colors.tabInactiveFg,
+            bg: colors.tabInactiveBg,
+        },
+    });
+    // Chat tab content - clean borders (adjusted for taller input box)
+    const chatLog = blessed.log({
+        top: 2,
+        left: 0,
+        width: '100%',
+        height: '100%-9', // Increased from -7 to -9 for 5-line input box
+        scrollable: true,
+        alwaysScroll: true,
+        mouse: true,
+        scrollbar: {
+            ch: '│',
+            track: {
+                bg: '#1a1a1a',
+            },
+            style: {
+                fg: colors.scrollbar,
+            },
+        },
+        tags: true,
+        border: { type: 'line' },
+        style: {
+            fg: '#e2e8f0',
+            bg: '#1a1a1a',
+            border: {
+                fg: colors.border,
+            },
+        },
+    });
+    const projectsBox = blessed.box({
+        top: 2,
+        left: 0,
+        width: '100%',
+        height: '100%-9', // Adjusted for taller input box
+        content: '{center}{#718096-fg}Loading projects...{/}{/center}',
+        tags: true,
+        scrollable: true,
+        mouse: true,
+        scrollbar: {
+            ch: '│',
+            style: { fg: colors.scrollbar },
+        },
+        border: { type: 'line' },
+        style: {
+            fg: '#e2e8f0',
+            bg: '#1a1a1a',
+            border: { fg: colors.border },
+        },
+        hidden: true,
+    });
+    const pipelineBox = blessed.box({
+        top: 2,
+        left: 0,
+        width: '100%',
+        height: '100%-9', // Adjusted for taller input box
+        content: '{center}{#718096-fg}Loading workItems...{/}{/center}',
+        tags: true,
+        scrollable: true,
+        mouse: true,
+        scrollbar: {
+            ch: '│',
+            style: { fg: colors.scrollbar },
+        },
+        border: { type: 'line' },
+        style: {
+            fg: '#e2e8f0',
+            bg: '#1a1a1a',
+            border: { fg: colors.border },
+        },
+        hidden: true,
+    });
+    const stuckBox = blessed.box({
+        top: 2,
+        left: 0,
+        width: '100%',
+        height: '100%-9',
+        content: '{center}{#718096-fg}Loading stuck work items...{/}{/center}',
+        tags: true,
+        scrollable: true,
+        alwaysScroll: true,
+        mouse: true,
+        keys: true,
+        vi: true,
+        scrollbar: {
+            ch: '█',
+            style: { fg: colors.scrollbar },
+        },
+        style: {
+            border: { fg: colors.border },
+        },
+        hidden: true,
+    });
+    const logsBox = blessed.log({
+        top: 2,
+        left: 0,
+        width: '100%',
+        height: '100%-9', // Adjusted for taller input box
+        scrollable: true,
+        alwaysScroll: true,
+        mouse: true,
+        scrollbar: {
+            ch: '│',
+            style: { fg: colors.scrollbar },
+        },
+        tags: true,
+        border: { type: 'line' },
+        style: {
+            fg: '#e2e8f0',
+            bg: '#1a1a1a',
+            border: { fg: colors.border },
+        },
+        hidden: true,
+    });
+    const workItemsBox = blessed.box({
+        top: 2,
+        left: 0,
+        width: '100%',
+        height: '100%-9',
+        scrollable: true,
+        alwaysScroll: true,
+        mouse: true,
+        scrollbar: {
+            ch: '│',
+            style: { fg: colors.scrollbar },
+        },
+        tags: true,
+        border: { type: 'line' },
+        label: ' {#00ccdd-fg}WorkItems{/} ',
+        style: {
+            border: { fg: colors.border },
+        },
+        hidden: true,
+    });
+    // Input box - textarea for multiline + Korean support
+    const inputBox = blessed.textarea({
+        bottom: 1,
+        left: 0,
+        width: '100%',
+        height: 5, // Increased height for multiline
+        inputOnFocus: true,
+        border: { type: 'line' },
+        label: ' {#718096-fg}Message (Shift+Enter: newline, Enter: send){/} ',
+        tags: true,
+        keys: true, // Enable key handling
+        mouse: true,
+        scrollable: true,
+        alwaysScroll: false,
+        style: {
+            fg: '#f7fafc',
+            bg: '#1a1a1a',
+            border: { fg: colors.border },
+            focus: {
+                border: { fg: colors.borderActive },
+                bg: '#0d1117',
+            },
+        },
+    });
+    const helpBar = blessed.box({
+        bottom: 0,
+        left: 0,
+        width: '100%',
+        height: 1,
+        content: ' {#718096-fg}Tab{/} Switch  {#718096-fg}Enter{/} Send  {#718096-fg}Shift+Enter{/} Newline  {#718096-fg}Esc{/} Exit Input  {#718096-fg}i{/} Focus Input  {#718096-fg}Ctrl+C{/} Exit  {#718096-fg}/help{/} Cmds',
+        tags: true,
+        style: {
+            fg: '#a0aec0',
+            bg: colors.statusBg,
+        },
+    });
+    screen.append(statusBar);
+    screen.append(tabBar);
+    screen.append(chatLog);
+    screen.append(projectsBox);
+    screen.append(pipelineBox);
+    screen.append(stuckBox);
+    screen.append(logsBox);
+    screen.append(workItemsBox);
+    screen.append(inputBox);
+    screen.append(helpBar);
+    return {
+        screen,
+        statusBar,
+        tabBar,
+        chatLog,
+        projectsBox,
+        pipelineBox,
+        workItemsBox,
+        stuckBox,
+        logsBox,
+        inputBox,
+        helpBar,
+    };
+}
+// Tab Management
+function updateTabBar(ui, currentTab) {
+    const tabs = [
+        { key: '1', name: 'Chat', icon: '💬' },
+        { key: '2', name: 'Projects', icon: '📁' },
+        { key: '3', name: 'Pipeline', icon: '✓' },
+        { key: '4', name: 'Stuck', icon: '⚠' },
+        { key: '5', name: 'WorkItems', icon: '🎫' },
+        { key: '6', name: 'Logs', icon: '📝' },
+    ];
+    const content = tabs.map((tab, idx) => {
+        if (idx === currentTab) {
+            // Active tab - highlighted
+            return `{#4a5568-bg}{#f7fafc-fg}{bold} ${tab.icon} ${tab.name} {/bold}{/}{/}`;
+        }
+        // Inactive tab - dimmed
+        return `{#2d3748-bg}{#a0aec0-fg} ${tab.icon} ${tab.name} {/}{/}`;
+    }).join(' ');
+    ui.tabBar.setContent(' ' + content);
+}
+function switchTab(state, ui, tabIndex) {
+    state.currentTab = tabIndex;
+    ui.chatLog.hide();
+    ui.projectsBox.hide();
+    ui.pipelineBox.hide();
+    ui.workItemsBox.hide();
+    ui.stuckBox.hide();
+    ui.logsBox.hide();
+    switch (tabIndex) {
+        case 0:
+            ui.chatLog.show();
+            break;
+        case 1:
+            ui.projectsBox.show();
+            loadProjectsData(ui.projectsBox);
+            break;
+        case 2:
+            ui.pipelineBox.show();
+            loadPipelineData(ui.pipelineBox);
+            break;
+        case 3:
+            ui.stuckBox.show();
+            loadStuckData(ui.stuckBox);
+            break;
+        case 4:
+            ui.workItemsBox.show();
+            loadWorkItemsData(ui.workItemsBox);
+            break;
+        case 5:
+            ui.logsBox.show();
+            break;
+    }
+    updateTabBar(ui, tabIndex);
+    safeRender();
+}
+// Data Loaders
+async function loadProjectsData(box) {
+    try {
+        const response = await fetch(`${FACTORY_DASHBOARD_BASE_URL}/api/projects`);
+        const projects = await response.json();
+        if (projects.length === 0) {
+            box.setContent('\n{center}{#718096-fg}No projects tracked{/}{/center}');
+            return;
+        }
+        const lines = [
+            '',
+            `  {#a0aec0-fg}${projects.length} project${projects.length > 1 ? 's' : ''} tracked{/}`,
+            '',
+        ];
+        for (const p of projects) {
+            const status = p.enabled ? '{#34d399-fg}●{/}' : '{#718096-fg}○{/}';
+            const running = p.running.length > 0 ? `{#60a5fa-fg}${p.running.length} running{/}` : '';
+            const queued = p.queued.length > 0 ? `{#f59e0b-fg}${p.queued.length} queued{/}` : '';
+            const workItems = [running, queued].filter(Boolean).join(' · ');
+            lines.push(`  ${status} {bold}${p.name}{/bold}`);
+            if (workItems) {
+                lines.push(`    ${workItems}`);
+            }
+            lines.push(`    {#718096-fg}${p.path}{/}`);
+            lines.push('');
+        }
+        box.setContent(lines.join('\n'));
+    }
+    catch (err) {
+        box.setContent(`\n{center}{#ef4444-fg}Failed to load projects{/}\n{#718096-fg}${err}{/}{/center}`);
+    }
+}
+async function loadPipelineData(box) {
+    try {
+        const response = await fetch(`${FACTORY_DASHBOARD_BASE_URL}/api/pipeline`);
+        const { stages } = await response.json();
+        if (stages.length === 0) {
+            box.setContent('\n{center}{#718096-fg}No pipeline events{/}{/center}');
+            return;
+        }
+        // Build workItem info map and extract stage events
+        const workItemInfo = new Map();
+        const allStageEvents = [];
+        for (const event of stages) {
+            if (event.type === 'workItem:started' && event.data.workItemId) {
+                workItemInfo.set(event.data.workItemId, { title: event.data.title, workItemIdentifier: event.data.workItemIdentifier });
+            }
+            else if (event.type === 'pipeline:stage' && event.data.workItemId && event.data.stage) {
+                allStageEvents.push({
+                    workItemId: event.data.workItemId,
+                    stage: event.data.stage,
+                    status: event.data.status || '',
+                    model: event.data.model,
+                    inputTokens: event.data.inputTokens,
+                    outputTokens: event.data.outputTokens,
+                    costUsd: event.data.costUsd,
+                });
+            }
+        }
+        if (allStageEvents.length === 0) {
+            box.setContent('\n{center}{#718096-fg}No active pipeline stages{/}{/center}');
+            return;
+        }
+        // Render pipeline table
+        const recentStages = allStageEvents.slice(-15).reverse();
+        const lines = [
+            '',
+            `  {#34d399-fg}{bold}Pipeline Events{/bold} {#718096-fg}(${recentStages.length} recent){/}{/}`,
+            '',
+            `  {#718096-fg}${'WORKITEM'.padEnd(12)} ${'STAGE'.padEnd(10)} ${'MODEL'.padEnd(12)} ${'TOKENS'.padEnd(15)} STATUS{/}`,
+            `  {#444444-fg}${'─'.repeat(70)}{/}`,
+        ];
+        for (const ev of recentStages) {
+            const info = workItemInfo.get(ev.workItemId);
+            const workItem = (info?.workItemIdentifier || ev.workItemId.slice(0, 8)).padEnd(12).slice(0, 12);
+            const stage = ev.stage.padEnd(10).slice(0, 10);
+            const statusMap = {
+                start: ['◐', '#f59e0b'],
+                complete: ['●', '#34d399'],
+                fail: ['✗', '#ef4444'],
+            };
+            const [icon, color] = statusMap[ev.status] || ['○', '#718096'];
+            let model = '';
+            if (ev.model?.includes('sonnet-4-5'))
+                model = 'sonnet-4.5';
+            else if (ev.model?.includes('haiku-4-5'))
+                model = 'haiku-4.5';
+            else if (ev.model?.includes('opus-4'))
+                model = 'opus-4';
+            else if (ev.model)
+                model = ev.model.split('-').pop() || '';
+            model = model.padEnd(12).slice(0, 12);
+            let tokens = '';
+            if (ev.inputTokens || ev.outputTokens) {
+                const inK = ev.inputTokens ? Math.round(ev.inputTokens / 1000) : 0;
+                const outK = ev.outputTokens ? Math.round(ev.outputTokens / 1000) : 0;
+                tokens = `${inK}k/${outK}k`;
+                if (ev.costUsd != null)
+                    tokens += ` $${ev.costUsd.toFixed(2)}`;
+            }
+            tokens = tokens.padEnd(15).slice(0, 15);
+            lines.push(`  {#34d399-fg}${workItem}{/} {#718096-fg}${stage}{/} {#34d399-fg}${model}{/} {#718096-fg}${tokens}{/} {${color}-fg}${icon} ${ev.status}{/}`);
+        }
+        box.setContent(lines.join('\n'));
+    }
+    catch (err) {
+        box.setContent(`\n{center}{#ef4444-fg}Failed to load pipeline{/}\n{#718096-fg}${err}{/}{/center}`);
+    }
+}
+async function loadStuckData(box) {
+    try {
+        const response = await fetch(`${FACTORY_DASHBOARD_BASE_URL}/api/workitems/stuck`);
+        const { stuckWorkItems, failedWorkItems } = await response.json();
+        const totalStuck = stuckWorkItems.length;
+        const totalFailed = failedWorkItems.length;
+        const total = totalStuck + totalFailed;
+        if (total === 0) {
+            box.setContent('\n{center}{#34d399-fg}✓ All work items healthy{/}{/center}');
+            return;
+        }
+        const lines = [
+            '',
+            `  {#ef4444-fg}⚠ ${total} work item${total > 1 ? 's' : ''} need attention{/}`,
+            '',
+        ];
+        // Stuck work items
+        if (totalStuck > 0) {
+            lines.push(`  {#f59e0b-fg}{bold}⏱ STUCK (${totalStuck}){/bold}{/}`);
+            lines.push('');
+            for (const workItem of stuckWorkItems) {
+                const priorityIcon = workItem.priority === 1 ? '{#ef4444-fg}🔴{/}' : workItem.priority === 2 ? '{#f59e0b-fg}🟡{/}' : '{#718096-fg}⚪{/}';
+                lines.push(`  ${priorityIcon} {bold}${workItem.identifier}{/bold}`);
+                lines.push(`    ${workItem.title.substring(0, 60)}${workItem.title.length > 60 ? '...' : ''}`);
+                lines.push(`    {#f59e0b-fg}${workItem.reason}{/}`);
+                if (workItem.project?.name) {
+                    lines.push(`    {#718096-fg}📁 ${workItem.project.name}{/}`);
+                }
+                lines.push('');
+            }
+        }
+        // Failed work items
+        if (totalFailed > 0) {
+            lines.push(`  {#ef4444-fg}{bold}✖ FAILED (${totalFailed}){/bold}{/}`);
+            lines.push('');
+            for (const workItem of failedWorkItems) {
+                const priorityIcon = workItem.priority === 1 ? '{#ef4444-fg}🔴{/}' : workItem.priority === 2 ? '{#f59e0b-fg}🟡{/}' : '{#718096-fg}⚪{/}';
+                lines.push(`  ${priorityIcon} {bold}${workItem.identifier}{/bold}`);
+                lines.push(`    ${workItem.title.substring(0, 60)}${workItem.title.length > 60 ? '...' : ''}`);
+                lines.push(`    {#ef4444-fg}${workItem.reason}{/}`);
+                if (workItem.project?.name) {
+                    lines.push(`    {#718096-fg}📁 ${workItem.project.name}{/}`);
+                }
+                lines.push('');
+            }
+        }
+        box.setContent(lines.join('\n'));
+    }
+    catch (err) {
+        box.setContent(`\n{center}{#ef4444-fg}Failed to load stuck work items{/}\n{#718096-fg}${err}{/}{/center}`);
+    }
+}
+// WorkItems Data Loader (로컬 이슈 트래커)
+async function loadWorkItemsData(box) {
+    try {
+        const response = await fetch(`${FACTORY_DASHBOARD_BASE_URL}/api/factory/workitems`);
+        const json = await response.json();
+        if (!json.ok)
+            throw new Error('Work-items endpoint returned ok:false');
+        const items = json.data;
+        const total = json.total;
+        if (total === 0) {
+            box.setContent(`\n{center}{#718096-fg}No work items tracked{/}\n\n{#445544-fg}Create work items via web dashboard (:${FACTORY_DASHBOARD_PORT}/workitems){/}{/center}`);
+            return;
+        }
+        const lines = [
+            '',
+            `  {#00ccdd-fg}{bold}🎫 WORK ITEMS{/bold}{/} — total: {bold}${total}{/bold}`,
+            '',
+        ];
+        lines.push('  ' + '─'.repeat(70));
+        lines.push('');
+        const priorityIcons = {
+            urgent: '{#ef4444-fg}●{/}', high: '{#ffaa00-fg}●{/}',
+            medium: '{#00ccdd-fg}●{/}', low: '{#718096-fg}●{/}', none: '{#445544-fg}○{/}',
+        };
+        const statusColors = {
+            backlog: '#718096', todo: '#e2e8f0', in_progress: '#ffaa00',
+            in_review: '#00ccdd', done: '#00ff41', cancelled: '#ef4444',
+        };
+        for (const iss of items.slice(0, 50)) {
+            const priority = iss.layeredState?.business?.priority ?? 'none';
+            const status = iss.layeredState?.business?.state ?? iss.status ?? 'backlog';
+            const icon = priorityIcons[priority] || '{#718096-fg}●{/}';
+            const stColor = statusColors[status] || '#718096';
+            const title = iss.title.length > 50 ? iss.title.substring(0, 50) + '...' : iss.title;
+            const labels = (iss.labels || []).slice(0, 2).map((l) => `{#445544-fg}[${l}]{/}`).join('');
+            lines.push(`  ${icon} {${stColor}-fg}${String(status).padEnd(12)}{/} {bold}${title}{/bold}`);
+            lines.push(`    {#718096-fg}${iss.id.slice(0, 6)} | ${iss.area ?? iss.projectId ?? ''}${iss.assignee ? ' | ' + iss.assignee : ''}{/} ${labels}`);
+            lines.push('');
+        }
+        if (total > 50) {
+            lines.push(`  {#718096-fg}... and ${total - 50} more work items{/}`);
+        }
+        lines.push('');
+        lines.push(`  {#445544-fg}Open web dashboard for full management: http://localhost:${FACTORY_DASHBOARD_PORT}/workitems{/}`);
+        box.setContent(lines.join('\n'));
+    }
+    catch (err) {
+        box.setContent(`\n{center}{#ef4444-fg}Failed to load work items{/}\n{#718096-fg}${err}{/}\n\n{#445544-fg}Make sure the service is running{/}{/center}`);
+    }
+}
+// Loading Spinner (inline in chat)
+function startSpinner(ui) {
+    let frameIndex = 0;
+    const loadingMessage = LOADING_MESSAGES[Math.floor(Math.random() * LOADING_MESSAGES.length)];
+    const lines = ui.chatLog.getLines();
+    const lineIndex = lines.length;
+    const interval = setInterval(() => {
+        const spinner = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length];
+        const content = `  {#667eea-fg}${spinner}{/} {#718096-fg}${loadingMessage}...{/}`;
+        ui.chatLog.setLine(lineIndex, content);
+        ui.chatLog.setScrollPerc(100);
+        safeRender();
+        frameIndex++;
+    }, 80);
+    return { interval, lineIndex };
+}
+function stopSpinner(ui, spinnerData) {
+    clearInterval(spinnerData.interval);
+    ui.chatLog.deleteLine(spinnerData.lineIndex);
+    safeRender();
+}
+// Chat Logic
+async function sendMessage(state, ui, message) {
+    if (!message.trim())
+        return;
+    ui.chatLog.log('');
+    ui.chatLog.log(`{#60a5fa-fg}{bold}▸ You{/bold}{/}`);
+    ui.chatLog.log(`  ${message}`);
+    ui.chatLog.log('');
+    ui.chatLog.setScrollPerc(100);
+    safeRender();
+    state.session.messages.push({ role: 'user', content: message });
+    ui.chatLog.log(`{#34d399-fg}{bold}▸ Assistant{/bold}{/}`);
+    const assistantHeaderLine = ui.chatLog.getLines().length - 1;
+    let assistantContent = '';
+    let lastRenderTime = 0;
+    let spinnerStopped = false;
+    let contentStartLine = assistantHeaderLine + 1;
+    const spinnerData = startSpinner(ui);
+    try {
+        const result = await callChatModel(message, state.session.provider, state.session.model, state.session.claudeSessionId, (chunk, isThinking) => {
+            // Handle thinking notification (show/resume spinner)
+            if (isThinking) {
+                if (spinnerStopped) {
+                    // Resume spinner for thinking phase
+                    spinnerStopped = false;
+                    const newSpinner = startSpinner(ui);
+                    Object.assign(spinnerData, newSpinner);
+                }
+                return;
+            }
+            // Stop spinner on first text chunk
+            if (!spinnerStopped && chunk) {
+                stopSpinner(ui, spinnerData);
+                spinnerStopped = true;
+            }
+            if (!chunk)
+                return;
+            assistantContent += chunk;
+            // Throttle rendering for smoother streaming (30fps)
+            const now = Date.now();
+            if (now - lastRenderTime < 33)
+                return;
+            lastRenderTime = now;
+            // Clear previous content lines (안전한 역순 삭제)
+            const currentLines = ui.chatLog.getLines().length;
+            const deleteCount = Math.max(0, Math.min(currentLines - contentStartLine, currentLines));
+            for (let i = 0; i < deleteCount; i++) {
+                ui.chatLog.deleteLine(contentStartLine);
+            }
+            // Add updated content line by line with proper empty line handling
+            const contentLines = assistantContent.split('\n');
+            for (const line of contentLines) {
+                // Always add line, even if empty (preserves paragraph breaks)
+                ui.chatLog.log(line ? `  ${line}` : '  ');
+            }
+            ui.chatLog.setScrollPerc(100);
+            safeRender();
+        });
+        // Ensure spinner is stopped
+        if (!spinnerStopped) {
+            stopSpinner(ui, spinnerData);
+            spinnerStopped = true;
+        }
+        if (state.session.provider === 'claude' && result.sessionId) {
+            state.session.claudeSessionId = result.sessionId;
+        }
+        // Update session stats
+        state.session.totalCost += result.cost;
+        state.session.totalTokens += result.tokens;
+        // Finalize assistant message with cost
+        // Clear streaming content first (안전한 삭제)
+        const finalLines = ui.chatLog.getLines().length;
+        const finalDeleteCount = Math.max(0, Math.min(finalLines - contentStartLine, finalLines));
+        for (let i = 0; i < finalDeleteCount; i++) {
+            ui.chatLog.deleteLine(contentStartLine);
+        }
+        // Add final content line by line with proper empty line handling
+        const contentLines = result.response.split('\n');
+        for (const line of contentLines) {
+            // Always add line, even if empty (preserves paragraph breaks)
+            ui.chatLog.log(line ? `  ${line}` : '  ');
+        }
+        // Add cost info if available
+        if (result.cost > 0) {
+            ui.chatLog.log(`  {#718096-fg}${result.tokens} tokens · $${result.cost.toFixed(4)}{/}`);
+        }
+        ui.chatLog.log('');
+        state.session.messages.push({
+            role: 'assistant',
+            content: result.response,
+            cost: result.cost,
+        });
+        await saveSession(state.session);
+        updateStatusBar(state, ui);
+        safeRender();
+    }
+    catch (err) {
+        if (!spinnerStopped) {
+            stopSpinner(ui, spinnerData);
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        ui.chatLog.log(`{#ef4444-fg}{bold}✗ Error{/bold}{/}`);
+        ui.chatLog.log(`  ${msg}`);
+        ui.chatLog.log('');
+        state.session.messages.pop(); // Remove user message on failure
+        safeRender();
+    }
+}
+// Status Bar Update
+function updateStatusBar(state, ui) {
+    const modelShort = shortenChatModel(state.session.model);
+    const cost = state.session.totalCost > 0 ? `$${state.session.totalCost.toFixed(4)}` : '$0.00';
+    const msgs = state.session.messages.length;
+    const status = [
+        '{bold}Enact Factory{/bold}',
+        `{#718096-fg}│{/}`,
+        `{#a0aec0-fg}${state.session.id}{/}`,
+        `{#718096-fg}│{/}`,
+        `{#c084fc-fg}${state.session.provider}{/}`,
+        `{#718096-fg}│{/}`,
+        `{#60a5fa-fg}${modelShort}{/}`,
+        `{#718096-fg}│{/}`,
+        `{#a0aec0-fg}${msgs} messages{/}`,
+        `{#718096-fg}│{/}`,
+        `{#34d399-fg}${cost}{/}`,
+    ].join(' ');
+    ui.statusBar.setContent(' ' + status);
+}
+// Command Handler
+async function handleCommand(cmd, state, ui) {
+    const [command, ...args] = cmd.slice(1).split(' ');
+    switch (command) {
+        case 'clear':
+        case 'c':
+            state.session.messages = [];
+            state.session.claudeSessionId = undefined;
+            state.session.totalCost = 0;
+            state.session.totalTokens = 0;
+            ui.chatLog.setContent('');
+            ui.chatLog.log('');
+            ui.chatLog.log('{#34d399-fg}✓ Conversation cleared{/}');
+            ui.chatLog.log('');
+            updateStatusBar(state, ui);
+            safeRender();
+            break;
+        case 'provider':
+        case 'p': {
+            const next = args[0];
+            ui.chatLog.log('');
+            if (!next) {
+                ui.chatLog.log(`  {bold}Current provider:{/bold} {#c084fc-fg}${state.session.provider}{/}`);
+                ui.chatLog.log('  {#718096-fg}Available providers:{/}');
+                ui.chatLog.log('    {#a0aec0-fg}claude{/}');
+                ui.chatLog.log('    {#a0aec0-fg}codex{/}');
+            }
+            else if (next !== 'claude' && next !== 'codex') {
+                ui.chatLog.log(`  {#ef4444-fg}Unknown provider: ${next}{/}`);
+            }
+            else {
+                state.session.provider = next;
+                state.session.model = getDefaultChatModel(next);
+                state.session.claudeSessionId = undefined;
+                ui.chatLog.log(`  {#34d399-fg}✓ Provider changed to {bold}${next}{/bold}{/}`);
+                ui.chatLog.log(`  {#34d399-fg}✓ Model changed to {bold}${state.session.model}{/bold}{/}`);
+                updateStatusBar(state, ui);
+            }
+            ui.chatLog.log('');
+            safeRender();
+            break;
+        }
+        case 'model':
+        case 'm': {
+            const newModel = args[0];
+            ui.chatLog.log('');
+            if (!newModel) {
+                ui.chatLog.log(`  {bold}Current provider:{/bold} {#c084fc-fg}${state.session.provider}{/}`);
+                ui.chatLog.log(`  {bold}Current model:{/bold} {#60a5fa-fg}${shortenChatModel(state.session.model)}{/}`);
+                ui.chatLog.log('');
+                ui.chatLog.log('  {#718096-fg}Available models:{/}');
+                if (state.session.provider === 'claude') {
+                    ui.chatLog.log('    {#a0aec0-fg}sonnet{/}  {#718096-fg}→{/} claude-sonnet-4-5');
+                    ui.chatLog.log('    {#a0aec0-fg}haiku{/}   {#718096-fg}→{/} claude-haiku-4-5');
+                    ui.chatLog.log('    {#a0aec0-fg}opus{/}    {#718096-fg}→{/} claude-opus-4-6');
+                }
+                else if (state.session.provider === 'responses') {
+                    ui.chatLog.log('    {#a0aec0-fg}auto{/}    {#718096-fg}→{/} auto');
+                    ui.chatLog.log('    {#a0aec0-fg}gpt-5{/}   {#718096-fg}→{/} gpt-5');
+                    ui.chatLog.log('    {#a0aec0-fg}gpt-4o{/}  {#718096-fg}→{/} gpt-4o');
+                }
+                else {
+                    ui.chatLog.log('    {#a0aec0-fg}codex{/}   {#718096-fg}→{/} gpt-5-codex');
+                }
+            }
+            else {
+                state.session.model = resolveChatModel(newModel, state.session.provider);
+                state.session.claudeSessionId = undefined;
+                const shortName = shortenChatModel(state.session.model);
+                ui.chatLog.log(`  {#34d399-fg}✓ Model changed to {bold}${shortName}{/bold}{/}`);
+                updateStatusBar(state, ui);
+            }
+            ui.chatLog.log('');
+            safeRender();
+            break;
+        }
+        case 'save': {
+            const name = args[0] || state.session.id;
+            state.session.id = name;
+            await saveSession(state.session);
+            ui.chatLog.log('');
+            ui.chatLog.log(`  {#34d399-fg}✓ Session saved: {bold}${name}{/bold}{/}`);
+            ui.chatLog.log('');
+            updateStatusBar(state, ui);
+            safeRender();
+            break;
+        }
+        case 'help':
+        case 'h':
+        case '?':
+            ui.chatLog.log('');
+            ui.chatLog.log('  {bold}Available Commands{/bold}');
+            ui.chatLog.log('');
+            ui.chatLog.log('    {#60a5fa-fg}/clear{/}         Clear conversation');
+            ui.chatLog.log('    {#60a5fa-fg}/provider{/} [id] Change provider {#718096-fg}(claude/codex){/}');
+            ui.chatLog.log('    {#60a5fa-fg}/model{/} [name]  Change model {#718096-fg}(sonnet/haiku/opus){/}');
+            ui.chatLog.log('    {#60a5fa-fg}/save{/} [name]   Save session');
+            ui.chatLog.log('    {#60a5fa-fg}/help{/}          Show this help');
+            ui.chatLog.log('');
+            ui.chatLog.log('  {bold}Navigation{/bold}');
+            ui.chatLog.log('');
+            ui.chatLog.log('    {#718096-fg}1-4{/}            Switch tabs directly');
+            ui.chatLog.log('    {#718096-fg}Tab/Shift+Tab{/}  Cycle through tabs');
+            ui.chatLog.log('    {#718096-fg}Esc{/}            Exit input mode (blur)');
+            ui.chatLog.log('    {#718096-fg}i / Enter{/}      Focus input (from chat)');
+            ui.chatLog.log('    {#718096-fg}Ctrl+C{/}         Exit (double press to confirm)');
+            ui.chatLog.log('');
+            safeRender();
+            break;
+        default:
+            ui.chatLog.log('');
+            ui.chatLog.log(`  {#ef4444-fg}Unknown command: /{bold}${command}{/bold}{/}`);
+            ui.chatLog.log(`  {#718096-fg}Type {/}{#60a5fa-fg}/help{/}{#718096-fg} for available commands{/}`);
+            ui.chatLog.log('');
+            safeRender();
+    }
+    return false;
+}
+// Main
+export async function main() {
+    const defaultProvider = loadDefaultProvider();
+    const loadArg = process.argv[2];
+    let session;
+    if (loadArg && loadArg !== '--' && !loadArg.startsWith('-')) {
+        const loaded = await loadSession(loadArg);
+        if (loaded) {
+            session = loaded;
+        }
+        else {
+            session = {
+                id: loadArg,
+                provider: defaultProvider,
+                model: getDefaultChatModel(defaultProvider),
+                messages: [],
+                totalCost: 0,
+                totalTokens: 0,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            };
+        }
+    }
+    else {
+        session = {
+            id: generateSessionId(),
+            provider: defaultProvider,
+            model: getDefaultChatModel(defaultProvider),
+            messages: [],
+            totalCost: 0,
+            totalTokens: 0,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    const state = {
+        session,
+        currentTab: 0,
+        inputMode: 'normal',
+        multilineBuffer: [],
+        showBinary: false,
+        diagnostics: {
+            lastResponseTime: 0,
+            avgTokensPerSec: 0,
+            totalRequests: 0,
+        },
+    };
+    const ui = createUI();
+    screenRef = ui.screen; // safeRender용 참조 설정
+    updateStatusBar(state, ui);
+    updateTabBar(ui, state.currentTab);
+    // Restore chat history - Claude Code style with proper line breaks
+    for (const msg of session.messages) {
+        ui.chatLog.log('');
+        if (msg.role === 'user') {
+            ui.chatLog.log(`{#60a5fa-fg}{bold}▸ You{/bold}{/}`);
+            // Split multiline user messages
+            const userLines = msg.content.split('\n');
+            for (const line of userLines) {
+                ui.chatLog.log(line ? `  ${line}` : '  ');
+            }
+        }
+        else {
+            ui.chatLog.log(`{#34d399-fg}{bold}▸ Assistant{/bold}{/}`);
+            // Split multiline assistant messages properly
+            const assistantLines = msg.content.split('\n');
+            for (const line of assistantLines) {
+                ui.chatLog.log(line ? `  ${line}` : '  ');
+            }
+            if (msg.cost) {
+                ui.chatLog.log(`  {#718096-fg}$${msg.cost.toFixed(4)}{/}`);
+            }
+        }
+    }
+    if (session.messages.length > 0) {
+        ui.chatLog.log('');
+    }
+    // Key bindings
+    ui.screen.key(['1'], () => switchTab(state, ui, 0));
+    ui.screen.key(['2'], () => switchTab(state, ui, 1));
+    ui.screen.key(['3'], () => switchTab(state, ui, 2));
+    ui.screen.key(['4'], () => switchTab(state, ui, 3));
+    ui.screen.key(['5'], () => switchTab(state, ui, 4));
+    ui.screen.key(['tab'], () => {
+        const next = (state.currentTab + 1) % 6;
+        switchTab(state, ui, next);
+    });
+    ui.screen.key(['S-tab'], () => {
+        const prev = (state.currentTab - 1 + 6) % 6;
+        switchTab(state, ui, prev);
+    });
+    // Ctrl+C: Clear input or exit (Claude Code style)
+    let ctrlCPressed = false;
+    ui.screen.key(['C-c'], async () => {
+        const currentValue = ui.inputBox.getValue();
+        if (currentValue && currentValue.trim()) {
+            // If input has text, just clear it
+            ui.inputBox.clearValue();
+            ui.inputBox.focus();
+            safeRender();
+            ctrlCPressed = false;
+        }
+        else {
+            // If input is empty, exit with double Ctrl+C
+            if (ctrlCPressed) {
+                await saveSession(state.session);
+                process.exit(0);
+            }
+            else {
+                ctrlCPressed = true;
+                ui.statusBar.setContent(' {#f59e0b-fg}Press Ctrl+C again to exit{/}');
+                safeRender();
+                setTimeout(() => {
+                    ctrlCPressed = false;
+                    updateStatusBar(state, ui);
+                    safeRender();
+                }, 2000);
+            }
+        }
+    });
+    // Escape: Clear input and blur (exit input mode)
+    ui.screen.key(['escape'], () => {
+        const currentValue = ui.inputBox.getValue();
+        if (currentValue && currentValue.trim()) {
+            // Clear input if has content
+            ui.inputBox.clearValue();
+        }
+        // Blur input box to exit input mode
+        ui.chatLog.focus();
+        safeRender();
+    });
+    // Enter in chatLog: focus input
+    ui.chatLog.key(['enter', 'i'], () => {
+        ui.inputBox.focus();
+        safeRender();
+    });
+    // Shift+Enter: Insert newline (handled by textarea by default)
+    // Enter: Submit message
+    ui.inputBox.key(['enter'], async () => {
+        const value = ui.inputBox.getValue();
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        ui.inputBox.clearValue();
+        ui.inputBox.focus();
+        safeRender();
+        if (trimmed.startsWith('/')) {
+            await handleCommand(trimmed, state, ui);
+        }
+        else {
+            await sendMessage(state, ui, trimmed);
+        }
+    });
+    // Focus input by default
+    ui.inputBox.focus();
+    // Handle terminal resize (important for tmux) — debounce로 연속 resize 시 깜빡임 방지
+    let resizeTimer = null;
+    process.stdout.on('resize', () => {
+        if (resizeTimer)
+            clearTimeout(resizeTimer);
+        resizeTimer = setTimeout(() => {
+            ui.screen.alloc();
+            ui.screen.realloc();
+            safeRender();
+        }, 50);
+    });
+    // Render
+    safeRender();
+    // Auto-refresh Projects/WorkItems/Stuck tabs every 5s
+    setInterval(() => {
+        if (state.currentTab === 1)
+            loadProjectsData(ui.projectsBox);
+        if (state.currentTab === 2)
+            loadWorkItemsData(ui.workItemsBox);
+        if (state.currentTab === 3)
+            loadStuckData(ui.stuckBox);
+        if (state.currentTab === 4)
+            loadWorkItemsData(ui.workItemsBox);
+        safeRender();
+    }, 5000);
+    // System logs (example - hook into eventHub in real implementation)
+    ui.logsBox.log('{gray-fg}System initialized{/gray-fg}');
+}
+// Auto-run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((err) => {
+        console.error('Fatal:', err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=chatTui.js.map