vgxness 1.2.1 → 1.3.1

package/dist/cli/tui/opentui/code/index.js

@@ -0,0 +1,210 @@
+import { createCliRenderer } from '@opentui/core';
+import { spawn } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ApprovalDecisionWriter, getApprovalActionsState } from '../../../../code/tui/approval-actions.js';
+import { buildSafetyReadModel, parseVgxcodeJsonl, parseVgxcodeJsonlLine } from '../../../../code/tui/runtime-events.js';
+import { parsePromptSubmission, toggleReadOnlyMode } from '../../../../code/tui/prompt-mode.js';
+import { createVgxcodeScreen } from './screen.js';
+async function main() {
+    const project = process.argv[2] ?? 'vgxness';
+    const parsedStdin = await readPipedRuntimeEvents();
+    const state = {
+        project,
+        prompt: '',
+        submittedPrompt: '',
+        events: [...parsedStdin.events],
+        errors: [...parsedStdin.errors],
+        status: parsedStdin.errors.length > 0 ? 'error' : parsedStdin.events.length > 0 ? 'completed' : 'idle',
+        source: parsedStdin.events.length > 0 || parsedStdin.errors.length > 0 ? 'stdin' : 'interactive',
+        mode: 'inspect',
+        childStdinOpen: false,
+        decisionWriter: undefined,
+    };
+    const renderer = await createCliRenderer({
+        exitOnCtrlC: true,
+        clearOnShutdown: true,
+        screenMode: 'alternate-screen',
+        consoleMode: 'disabled',
+    });
+    const render = () => {
+        const current = renderer.root.getRenderable('vgxcode-screen');
+        if (current)
+            renderer.root.remove('vgxcode-screen');
+        const safety = buildSafetyReadModel(state.events);
+        renderer.root.add(createVgxcodeScreen({
+            ...state,
+            approvalActionsEnabled: getApprovalActionsState({
+                source: state.source,
+                status: state.status,
+                mode: state.mode,
+                childStdinOpen: state.childStdinOpen,
+                pendingApprovalCount: safety.pendingApprovalCount,
+                ...(safety.latestPendingApproval === undefined ? {} : { latestPendingApproval: safety.latestPendingApproval }),
+            }).enabled,
+        }));
+        renderer.requestRender();
+    };
+    render();
+    if (state.source === 'interactive') {
+        renderer.keyInput.on('keypress', (key) => {
+            if (key.ctrl && key.name === 'c')
+                return;
+            if (state.status === 'running') {
+                if (key.name === 'a' || key.sequence === 'a')
+                    writePendingApprovalDecision(state, 'approved', render);
+                if (key.name === 'd' || key.sequence === 'd')
+                    writePendingApprovalDecision(state, 'denied', render);
+                return;
+            }
+            if (key.name === 'tab') {
+                state.mode = toggleReadOnlyMode(state.mode);
+                render();
+                return;
+            }
+            if (key.name === 'return' || key.name === 'enter') {
+                void runReadOnlyBridge(state, render);
+                return;
+            }
+            if (key.name === 'backspace' || key.name === 'delete') {
+                state.prompt = state.prompt.slice(0, -1);
+                render();
+                return;
+            }
+            const text = printableKeyText(key.sequence);
+            if (text !== '') {
+                state.prompt += text;
+                render();
+            }
+        });
+    }
+}
+async function readPipedRuntimeEvents() {
+    if (process.stdin.isTTY)
+        return { events: [], errors: [] };
+    let input = '';
+    for await (const chunk of process.stdin)
+        input += String(chunk);
+    return parseVgxcodeJsonl(input);
+}
+async function runReadOnlyBridge(state, render) {
+    const submission = parsePromptSubmission(state.prompt, state.mode);
+    const prompt = submission.prompt;
+    if (prompt === '') {
+        state.status = 'error';
+        state.errors = ['Enter a prompt before running inspect, plan, craft-preview, or craft. Prefix with /inspect, /plan, /craft-preview, or /craft; press Tab to switch inspect/plan.'];
+        render();
+        return;
+    }
+    state.mode = submission.mode;
+    state.submittedPrompt = prompt;
+    state.prompt = '';
+    state.status = 'running';
+    state.errors = [];
+    state.events = [];
+    state.childStdinOpen = false;
+    state.decisionWriter = undefined;
+    render();
+    const root = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../..');
+    const approvalCapableCraft = state.mode === 'craft';
+    const child = spawn('bun', commandArgsForMode(state.mode, prompt), {
+        cwd: root,
+        stdio: approvalCapableCraft ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
+        env: process.env,
+    });
+    state.childStdinOpen = approvalCapableCraft && child.stdin !== null;
+    state.decisionWriter = approvalCapableCraft && child.stdin !== null ? new ApprovalDecisionWriter(child.stdin) : undefined;
+    if (child.stdout === null || child.stderr === null) {
+        state.status = 'error';
+        state.childStdinOpen = false;
+        state.decisionWriter = undefined;
+        state.errors.push('Failed to start root CLI with JSONL output streams.');
+        render();
+        return;
+    }
+    child.stdin?.on('close', () => {
+        state.childStdinOpen = false;
+        render();
+    });
+    child.stdin?.on('error', () => {
+        state.childStdinOpen = false;
+        render();
+    });
+    let lineNumber = 0;
+    let stdoutBuffer = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        stdoutBuffer += chunk;
+        const lines = stdoutBuffer.split(/\r?\n/);
+        stdoutBuffer = lines.pop() ?? '';
+        for (const line of lines) {
+            lineNumber += 1;
+            const parsed = parseVgxcodeJsonlLine(line, lineNumber);
+            if (parsed.event)
+                state.events.push(parsed.event);
+            if (parsed.error)
+                state.errors.push(parsed.error);
+        }
+        render();
+    });
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+        stderr += chunk;
+    });
+    child.on('error', (error) => {
+        state.status = 'error';
+        state.childStdinOpen = false;
+        state.errors.push(`Failed to start root CLI: ${error.message}`);
+        render();
+    });
+    child.on('close', (code, signal) => {
+        state.childStdinOpen = false;
+        state.decisionWriter = undefined;
+        if (stdoutBuffer.trim() !== '') {
+            lineNumber += 1;
+            const parsed = parseVgxcodeJsonlLine(stdoutBuffer, lineNumber);
+            if (parsed.event)
+                state.events.push(parsed.event);
+            if (parsed.error)
+                state.errors.push(parsed.error);
+        }
+        state.status = state.errors.length > 0 ? 'error' : 'completed';
+        if (code !== 0 && !(state.mode === 'craft-preview' && code === 3)) {
+            const detail = stderr.trim() === '' ? `signal ${signal ?? 'none'}` : stderr.trim();
+            state.status = 'error';
+            state.errors.push(`Root Bun CLI ${state.mode} failed (exit ${code ?? 'signal'}): ${detail}`);
+        }
+        render();
+    });
+}
+function commandArgsForMode(mode, prompt) {
+    const args = ['run', '--silent', 'cli:bun', '--', 'code', mode, prompt, '--events-jsonl'];
+    if (mode === 'craft')
+        args.push('--approval-channel', 'stdio');
+    return args;
+}
+function writePendingApprovalDecision(state, status, render) {
+    const model = buildSafetyReadModel(state.events);
+    const actions = getApprovalActionsState({
+        source: state.source,
+        status: state.status,
+        mode: state.mode,
+        childStdinOpen: state.childStdinOpen,
+        pendingApprovalCount: model.pendingApprovalCount,
+        ...(model.latestPendingApproval === undefined ? {} : { latestPendingApproval: model.latestPendingApproval }),
+    });
+    if (!actions.enabled)
+        return;
+    const wrote = state.decisionWriter?.write(actions.approval, status, status === 'approved' ? 'Approved from vgxcode.' : 'Denied from vgxcode.') ?? false;
+    if (!wrote)
+        return;
+    render();
+}
+function printableKeyText(sequence) {
+    if (sequence.length !== 1)
+        return '';
+    const code = sequence.charCodeAt(0);
+    return code >= 32 && code !== 127 ? sequence : '';
+}
+await main();

package/dist/cli/tui/opentui/code/screen.js

@@ -0,0 +1,107 @@
+import { Box, Text } from '@opentui/core';
+import { buildSafetyReadModel, summarizeEvent } from '../../../../code/tui/runtime-events.js';
+export function createVgxcodeScreen(input) {
+    const latest = input.events.at(-1);
+    const transcript = input.events.filter((event) => event.type === 'provider.message').map(summarizeEvent);
+    const activity = input.events.filter((event) => event.type !== 'provider.message').map(summarizeEvent);
+    const safety = buildSafetyReadModel(input.events);
+    const status = input.errors.length > 0 ? 'error' : input.status;
+    const latestText = latest ? `   Last event: ${latest.type}` : '';
+    const modeDescription = describeMode(input.mode);
+    const promptLabel = input.source === 'stdin' ? 'piped JSONL replay (safe)' : `${input.mode} prompt (${modeDescription})`;
+    const submittedText = input.submittedPrompt === '' ? 'Last submitted: none' : `Last submitted (${input.mode}): ${input.submittedPrompt}`;
+    const promptText = input.source === 'stdin'
+        ? 'stdin JSONL detected; not spawning root CLI.'
+        : `Mode: ${input.mode} (${modeDescription})   State: ${status}\n${submittedText}\n> ${input.prompt}${input.status === 'running' ? '  [running]' : ''}`;
+    const errorText = input.errors.length === 0 ? '' : `\n\nErrors (${input.errors.length}):\n${input.errors.map((error) => `! ${error}`).join('\n')}`;
+    const safetyText = formatSafetyDetails(safety);
+    return Box({
+        id: 'vgxcode-screen',
+        flexDirection: 'column',
+        width: '100%',
+        height: '100%',
+        padding: 1,
+        gap: 1,
+        backgroundColor: '#080B12',
+    }, Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#7DD3FC',
+        paddingX: 1,
+        title: ' vgxcode ',
+    }, Text({ content: `Project: ${input.project}   UI: OpenTUI/Bun experimental   Source: ${input.source}   State: ${status}${latestText}`, fg: '#E0F2FE', wrapMode: 'word' })), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#A78BFA',
+        paddingX: 1,
+        title: ` Prompt — ${promptLabel} `,
+    }, Text({ content: promptText, fg: '#F8FAFC', wrapMode: 'word' })), Box({
+        flexDirection: 'row',
+        flexGrow: 1,
+        gap: 1,
+    }, Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#22C55E',
+        flexGrow: 2,
+        padding: 1,
+        title: ' Transcript ',
+    }, Text({ content: transcript.length === 0 ? 'No assistant output yet.' : transcript.join('\n'), fg: '#DCFCE7', wrapMode: 'word' })), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#F59E0B',
+        flexGrow: 1,
+        padding: 1,
+        title: ' Activity ',
+    }, Text({ content: `${activity.length === 0 ? 'No runtime activity yet.' : activity.join('\n')}${errorText}`, fg: input.errors.length > 0 ? '#FECACA' : '#FEF3C7', wrapMode: 'word' }))), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#38BDF8',
+        paddingX: 1,
+        title: ` Safety details — ${input.mode === 'craft' ? 'approval-capable craft' : 'preview/read-only'} `,
+    }, Text({ content: safetyText, fg: '#E0F2FE', wrapMode: 'word' })), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#475569',
+        paddingX: 1,
+        title: ' Shortcuts ',
+    }, Text({ content: formatFooter(input.approvalActionsEnabled === true), fg: '#CBD5E1', wrapMode: 'word' })));
+}
+function formatSafetyDetails(safety) {
+    const approvalText = safety.latestPendingApproval
+        ? `! Pending approvals: ${safety.pendingApprovalCount} (latest: ${safety.latestPendingApproval.toolName})`
+        : `✓ Pending approvals: ${safety.pendingApprovalCount}`;
+    const decisionText = safety.latestApprovalDecision
+        ? `${approvalDecisionCue(safety.latestApprovalDecision.final)} Latest approval decision: ${safety.latestApprovalDecision.final} — ${safety.latestApprovalDecision.toolName}: ${safety.latestApprovalDecision.reason}`
+        : '· Latest approval decision: none';
+    const previewText = safety.latestApprovalPreview
+        ? `! Approval preview: ${safety.latestApprovalPreview.toolName} (${safety.latestApprovalPreview.capability}) — Approve disabled, Deny disabled. No mutation executed.${safety.latestApprovalPreview.targetPath ? ` Target: ${safety.latestApprovalPreview.targetPath}.` : ''}`
+        : '· Approval preview: none';
+    const changedFilesText = safety.changedFiles.length > 0
+        ? `! Changed files (${safety.changedFiles.length}): ${safety.changedFiles.join(', ')}`
+        : '✓ Changed files: none reported';
+    const diffText = safety.diffAvailability === 'filenames-only'
+        ? '· Diff preview: unavailable in current event stream; only changed filenames were reported.'
+        : safety.diffAvailability === 'preview' && safety.latestDiffPreview
+            ? formatDiffPreview(safety.latestDiffPreview)
+            : '· Diff preview: no changed files reported.';
+    return `${approvalText}\n${decisionText}\n${previewText}\n${changedFilesText}\n${diffText}\n· Craft is approval-capable and may mutate after you approve. Craft-preview is preview-only and never sends approval decisions.`;
+}
+function describeMode(mode) {
+    if (mode === 'craft')
+        return 'approval-capable, mutating after approval';
+    if (mode === 'craft-preview')
+        return 'preview-only, no mutation executed';
+    return 'read-only';
+}
+function formatFooter(approvalActionsEnabled) {
+    const approvalText = approvalActionsEnabled ? '[a] Approve pending  [d] Deny pending' : 'Approve/Deny hidden until a live craft run has a pending approval';
+    return `[Enter] Run mode  [Tab] Toggle inspect/plan  Prefix: /inspect, /plan, /craft, or /craft-preview  [Backspace] Edit  ${approvalText}  [Ctrl+C] Quit.`;
+}
+function formatDiffPreview(preview) {
+    const metadata = `· Diff preview: ${preview.files.length} files, ${preview.bodyBytes}/${preview.originalBytes} bytes, sha256:${preview.hash.slice(0, 12)}${preview.truncated ? ', truncated' : ''}${preview.redacted ? ', redacted' : ''}`;
+    return `${metadata}\n${preview.body}`;
+}
+function approvalDecisionCue(final) {
+    return final === 'allow' ? '✓' : '✕';
+}

package/dist/cli/tui/opentui/code/smoke.js

@@ -0,0 +1,32 @@
+import { createTestRenderer } from '@opentui/core/testing';
+import { parseVgxcodeJsonl, sampleEvents } from '../../../../code/tui/runtime-events.js';
+import { createVgxcodeScreen } from './screen.js';
+const input = await readPipedInput();
+const parsed = input === '' ? { events: [], errors: [] } : parseVgxcodeJsonl(input);
+if (parsed.errors.length > 0) {
+    throw new Error(`Smoke input contained invalid events: ${parsed.errors.join('; ')}`);
+}
+const events = parsed.events.length > 0 ? parsed.events : sampleEvents();
+const setup = await createTestRenderer({ width: 140, height: 36 });
+try {
+    setup.renderer.root.add(createVgxcodeScreen({ project: 'vgxness-smoke', events, prompt: 'smoke test prompt', submittedPrompt: 'previous smoke prompt', status: 'completed', errors: [], source: 'interactive', mode: 'inspect' }));
+    await setup.renderOnce();
+    const frame = setup.captureCharFrame();
+    const requiredText = ['vgxcode', 'vgxness-smoke', 'State: completed', 'Mode: inspect', 'Last submitted', 'Prompt', 'Transcript', 'Activity', 'Safety details', 'hidden until a live craft run', '/craft-preview'];
+    const missing = requiredText.filter((text) => !frame.includes(text));
+    if (missing.length > 0) {
+        throw new Error(`Smoke frame is missing expected text: ${missing.join(', ')}`);
+    }
+    console.log('vgxcode OpenTUI smoke passed');
+}
+finally {
+    setup.renderer.destroy();
+}
+async function readPipedInput() {
+    if (process.stdin.isTTY)
+        return '';
+    let input = '';
+    for await (const chunk of process.stdin)
+        input += String(chunk);
+    return input;
+}

package/dist/cli/tui/opentui/main-menu/index.js

@@ -0,0 +1,3 @@
+export * from './renderer.js';
+export * from './screen.js';
+export * from './view.js';

package/dist/cli/tui/opentui/main-menu/renderer.js

@@ -0,0 +1,68 @@
+import { createCliRenderer } from '@opentui/core';
+import { mainMenuActionFromInput, reduceMainMenuState } from '../../main-menu/main-menu-actions.js';
+import { createMainMenuState } from '../../main-menu/main-menu-state.js';
+import { createTuiViewport } from '../../visual/viewport.js';
+import { createOpenTuiMainMenuScreen } from './screen.js';
+export async function renderOpenTuiMainMenu(options = {}) {
+    const width = terminalWidth(options.stdout);
+    let state = options.initialState ?? createMainMenuState(width === undefined ? {} : { width });
+    const renderer = await createCliRenderer({
+        ...(options.stdin === undefined ? {} : { stdin: options.stdin }),
+        ...(options.stdout === undefined ? {} : { stdout: options.stdout }),
+        exitOnCtrlC: true,
+        clearOnShutdown: true,
+        screenMode: 'alternate-screen',
+        consoleMode: 'disabled',
+    });
+    await new Promise((resolve) => {
+        let finished = false;
+        const finish = (result) => {
+            if (finished)
+                return;
+            finished = true;
+            options.onResult?.(result);
+            renderer.destroy();
+            resolve();
+        };
+        const render = () => {
+            const current = renderer.root.getRenderable('main-menu-screen');
+            if (current)
+                renderer.root.remove('main-menu-screen');
+            renderer.root.add(createOpenTuiMainMenuScreen(state));
+            renderer.requestRender();
+        };
+        renderer.on('destroy', () => {
+            if (!finished)
+                resolve();
+        });
+        renderer.on('resize', () => {
+            state = { ...state, viewport: createTuiViewport(renderer.terminalWidth, state.viewport.width) };
+            render();
+        });
+        renderer.keyInput.on('keypress', (key) => {
+            if (key.ctrl && key.name === 'c')
+                return;
+            const action = mainMenuActionFromInput(key.sequence, keyToMainMenuInputKey(key));
+            if (action === undefined)
+                return;
+            const reduced = reduceMainMenuState(state, action);
+            state = reduced.state;
+            if (reduced.result !== undefined)
+                finish(reduced.result);
+            else
+                render();
+        });
+        render();
+    });
+}
+function terminalWidth(stdout) {
+    return stdout?.columns;
+}
+function keyToMainMenuInputKey(key) {
+    return {
+        upArrow: key.name === 'up',
+        downArrow: key.name === 'down',
+        return: key.name === 'return' || key.name === 'enter',
+        escape: key.name === 'escape',
+    };
+}

package/dist/cli/tui/opentui/main-menu/screen.js

@@ -0,0 +1,68 @@
+import { Box, Text } from '@opentui/core';
+import { tuiBadges } from '../../visual/badges.js';
+import { buildMainMenuViewModel } from '../../main-menu/main-menu-read-model.js';
+import { formatMainMenuOptions } from './view.js';
+export function createOpenTuiMainMenuScreen(state) {
+    const vm = buildMainMenuViewModel(state);
+    return Box({
+        id: 'main-menu-screen',
+        flexDirection: 'column',
+        width: '100%',
+        height: '100%',
+        padding: 1,
+        gap: 1,
+        backgroundColor: '#080B12',
+    }, Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#7DD3FC',
+        paddingX: 1,
+        title: ' VGXNESS ',
+    }, Text({ content: `${vm.title}\n${vm.subtitle} ${tuiBadges.readOnly}\n${vm.contextLines.join('\n')}`, fg: '#E0F2FE', wrapMode: 'word' })), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#14B8A6',
+        paddingX: 1,
+        title: ` ${vm.statusSnapshot.title} ${vm.statusSnapshot.badges.join(' ')} `,
+    }, Text({ content: vm.statusSnapshot.lines.join('\n'), fg: '#CCFBF1', wrapMode: 'word' })), Box({
+        flexDirection: state.viewport.mode === 'narrow' ? 'column' : 'row',
+        flexGrow: 1,
+        gap: 1,
+    }, Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#A78BFA',
+        flexGrow: 1,
+        padding: 1,
+        title: ' Menu ',
+    }, Text({ content: formatMainMenuOptions(vm.options), fg: '#F8FAFC', wrapMode: 'word' })), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#22C55E',
+        flexGrow: 1,
+        padding: 1,
+        title: ` ${vm.detail.title}${vm.detail.badges.length === 0 ? '' : ` ${vm.detail.badges.join(' ')}`} `,
+    }, Text({ content: vm.detail.lines.join('\n'), fg: '#DCFCE7', wrapMode: 'word' }))), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#F59E0B',
+        paddingX: 1,
+        title: ` Safety ${tuiBadges.noProviderWrites} `,
+    }, Text({ content: vm.safetyLines.join('\n'), fg: '#FEF3C7', wrapMode: 'word' })), ...(vm.helpLines.length === 0
+        ? []
+        : [
+            Box({
+                border: true,
+                borderStyle: 'rounded',
+                borderColor: '#38BDF8',
+                paddingX: 1,
+                title: ` Help ${tuiBadges.readOnly} `,
+            }, Text({ content: vm.helpLines.join('\n'), fg: '#E0F2FE', wrapMode: 'word' })),
+        ]), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#475569',
+        paddingX: 1,
+        title: ' Shortcuts ',
+    }, Text({ content: vm.footer, fg: '#CBD5E1', wrapMode: 'word' })));
+}

package/dist/cli/tui/opentui/main-menu/smoke.js

@@ -0,0 +1,17 @@
+import { createTestRenderer } from '@opentui/core/testing';
+import { createMainMenuState } from '../../main-menu/main-menu-state.js';
+import { createOpenTuiMainMenuScreen } from './screen.js';
+const setup = await createTestRenderer({ width: 120, height: 32 });
+try {
+    setup.renderer.root.add(createOpenTuiMainMenuScreen(createMainMenuState({ focusedOptionId: 'setup', helpVisible: true, width: 120 })));
+    await setup.renderOnce();
+    const frame = setup.captureCharFrame();
+    const requiredText = ['VGXNESS Main Menu', 'Installation', 'Requires confirmation', 'No provider writes', 'final confirmation', 'q/Esc'];
+    const missing = requiredText.filter((text) => !frame.includes(text));
+    if (missing.length > 0)
+        throw new Error(`Main menu smoke frame is missing expected text: ${missing.join(', ')}`);
+    console.log('main-menu OpenTUI smoke passed');
+}
+finally {
+    setup.renderer.destroy();
+}

package/dist/cli/tui/opentui/main-menu/view.js

@@ -0,0 +1,8 @@
+import { formatBadges, tuiBadges } from '../../visual/badges.js';
+export function formatMainMenuOptions(options) {
+    return options.map(formatMainMenuOption).join('\n');
+}
+function formatMainMenuOption(option) {
+    const badges = formatBadges([...(option.focused ? [tuiBadges.focused] : []), ...option.badges]);
+    return `${option.focused ? '›' : ' '} ${option.label}${badges.length === 0 ? '' : ` ${badges}`} — ${option.description}`;
+}

package/dist/cli/tui/opentui/setup/index.js

@@ -0,0 +1,3 @@
+export { renderOpenTuiSetup } from './renderer.js';
+export { createOpenTuiSetupScreen } from './screen.js';
+export { formatOpenTuiSetupScreen } from './view.js';

package/dist/cli/tui/opentui/setup/renderer.js

@@ -0,0 +1,87 @@
+import { createCliRenderer } from '@opentui/core';
+import { createSetupTuiController } from '../../setup/setup-tui-controller.js';
+import { setupTuiActionFromInput } from '../../setup/setup-tui-input.js';
+import { createSetupTuiState } from '../../setup/setup-tui-state.js';
+import { createOpenTuiSetupScreen } from './screen.js';
+export async function renderOpenTuiSetup(options) {
+    let state = options.initialState ?? createSetupTuiState({ selections: options.runtime.selections });
+    const renderer = await createCliRenderer({
+        ...(options.stdin === undefined ? {} : { stdin: options.stdin }),
+        ...(options.stdout === undefined ? {} : { stdout: options.stdout }),
+        exitOnCtrlC: true,
+        clearOnShutdown: true,
+        screenMode: 'alternate-screen',
+        consoleMode: 'disabled',
+    });
+    await new Promise((resolve) => {
+        let finished = false;
+        let dispatching = false;
+        const finish = () => {
+            if (finished)
+                return;
+            finished = true;
+            renderer.destroy();
+            resolve();
+        };
+        const render = () => {
+            const current = renderer.root.getRenderable('setup-screen');
+            if (current)
+                renderer.root.remove('setup-screen');
+            renderer.root.add(createOpenTuiSetupScreen(state, renderer.terminalWidth));
+            renderer.requestRender();
+            options.onState?.(state);
+        };
+        const dispatch = async (action) => {
+            dispatching = true;
+            try {
+                const controller = await createSetupTuiController({ state, services: options.services, runtime: options.runtime }).dispatch(action);
+                state = controller.state;
+                render();
+                if (state.screen === 'cancelled' && action.type === 'cancel')
+                    finish();
+            }
+            finally {
+                dispatching = false;
+            }
+        };
+        renderer.on('destroy', () => {
+            if (!finished)
+                resolve();
+        });
+        renderer.on('resize', render);
+        renderer.keyInput.on('keypress', (key) => {
+            if (key.ctrl && key.name === 'c')
+                return;
+            if (dispatching)
+                return;
+            if (isCloseKey(key) && (state.screen === 'cancelled' || state.screen === 'result' || state.screen === 'error-recovery')) {
+                finish();
+                return;
+            }
+            const action = setupTuiActionFromInput(key.sequence, keyToSetupTuiInputKey(key), state);
+            if (action !== undefined)
+                void dispatch(action);
+        });
+        void createSetupTuiController({ state, services: options.services, runtime: options.runtime })
+            .load()
+            .then((controller) => {
+            if (finished)
+                return;
+            state = controller.state;
+            render();
+        });
+    });
+}
+function isCloseKey(key) {
+    return key.name === 'escape' || key.sequence === 'q';
+}
+function keyToSetupTuiInputKey(key) {
+    return {
+        upArrow: key.name === 'up',
+        downArrow: key.name === 'down',
+        return: key.name === 'return' || key.name === 'enter',
+        escape: key.name === 'escape',
+        tab: key.name === 'tab',
+        shift: key.shift === true,
+    };
+}