@thegitai/cli 1.0.0-beta.1

package/dist/src/ui/tui/bridge.js

@@ -0,0 +1,175 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const requireFromHere = createRequire(import.meta.url);
+function normalizeChildMessage(raw) {
+    if (raw.op === 'ready') {
+        return {
+            op: 'ready',
+            cols: Number(raw.cols ?? 80),
+            rows: Number(raw.rows ?? 24),
+        };
+    }
+    if (raw.op === 'closed') {
+        return { op: 'closed' };
+    }
+    if (raw.op !== 'event') {
+        return null;
+    }
+    if (raw.kind === 'paste') {
+        return { op: 'event', kind: 'paste', text: String(raw.text ?? '') };
+    }
+    if (raw.kind === 'resize') {
+        return {
+            op: 'event',
+            kind: 'resize',
+            cols: Number(raw.cols ?? 80),
+            rows: Number(raw.rows ?? 24),
+        };
+    }
+    if (raw.kind === 'selectionCopy') {
+        return {
+            op: 'event',
+            kind: 'selectionCopy',
+            text: String(raw.text ?? ''),
+        };
+    }
+    if (raw.kind === 'linkCopy') {
+        return {
+            op: 'event',
+            kind: 'linkCopy',
+            url: String(raw.url ?? ''),
+        };
+    }
+    if (raw.kind === 'linkOpen') {
+        return {
+            op: 'event',
+            kind: 'linkOpen',
+            url: String(raw.url ?? ''),
+        };
+    }
+    if (raw.kind === 'contextMenu') {
+        return { op: 'event', kind: 'contextMenu' };
+    }
+    if (raw.kind === 'transcriptScroll') {
+        return {
+            op: 'event',
+            kind: 'transcriptScroll',
+            deltaLines: Number(raw.deltaLines ?? raw.delta_lines ?? 0),
+        };
+    }
+    if (raw.kind !== 'key') {
+        return null;
+    }
+    const bool = (value) => value === true;
+    return {
+        op: 'event',
+        kind: 'key',
+        input: String(raw.input ?? ''),
+        ctrl: bool(raw.ctrl),
+        meta: bool(raw.meta),
+        shift: bool(raw.shift),
+        escape: bool(raw.escape),
+        returnKey: bool(raw.returnKey ?? raw.return_key),
+        tab: bool(raw.tab),
+        backspace: bool(raw.backspace),
+        delete: bool(raw.delete),
+        upArrow: bool(raw.upArrow ?? raw.up_arrow),
+        downArrow: bool(raw.downArrow ?? raw.down_arrow),
+        leftArrow: bool(raw.leftArrow ?? raw.left_arrow),
+        rightArrow: bool(raw.rightArrow ?? raw.right_arrow),
+        home: bool(raw.home),
+        end: bool(raw.end),
+        paste: bool(raw.paste),
+        pageUp: bool(raw.pageUp ?? raw.page_up),
+        pageDown: bool(raw.pageDown ?? raw.page_down),
+    };
+}
+export function resolveTuiBinaryPath() {
+    const binaryName = process.platform === 'win32' ? 'thegitai-tui.exe' : 'thegitai-tui';
+    const platformPackage = `@thegitai/tui-${process.platform}-${process.arch}`;
+    // 1) Published per-platform optional dependency (the installed-from-npm path).
+    try {
+        return requireFromHere.resolve(`${platformPackage}/${binaryName}`);
+    }
+    catch {
+        // Not installed (unsupported platform yet, or local dev) — fall through.
+    }
+    // 2) Local dev build: `npm run build:tui` populates the workspace bin/.
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const devCandidates = [
+        path.join(moduleDir, '../../../bin', binaryName),
+        path.join(moduleDir, '../../../../bin', binaryName),
+    ];
+    const devBinary = devCandidates.find((candidate) => existsSync(candidate));
+    if (devBinary) {
+        return devBinary;
+    }
+    throw new Error(`Missing thegitai-tui binary. Expected the optional dependency "${platformPackage}" (your platform may not be supported yet), ` +
+        `or a local build at one of: ${devCandidates.join(', ')} (run "npm run build:tui").`);
+}
+export function spawnTuiProcess(options = {}) {
+    const binaryPath = resolveTuiBinaryPath();
+    return spawn(binaryPath, [], {
+        stdio: ['pipe', 'pipe', 'inherit'],
+        env: { ...process.env, ...options.env },
+    });
+}
+export function createRatatuiBridge() {
+    const child = spawnTuiProcess();
+    const rl = createInterface({ input: child.stdout });
+    let eventHandler = null;
+    let closed = false;
+    rl.on('line', (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        try {
+            const message = normalizeChildMessage(JSON.parse(trimmed));
+            if (!message)
+                return;
+            eventHandler?.(message);
+            if (message.op === 'closed') {
+                closed = true;
+            }
+        }
+        catch {
+            // ignore malformed protocol lines
+        }
+    });
+    child.on('exit', () => {
+        closed = true;
+        eventHandler?.({ op: 'closed' });
+    });
+    const writeParent = (payload) => {
+        if (closed)
+            return;
+        child.stdin.write(`${JSON.stringify(payload)}\n`);
+    };
+    return {
+        onEvent(handler) {
+            eventHandler = handler;
+        },
+        render(frame) {
+            writeParent({ op: 'frame', ...frame });
+        },
+        clear() {
+            writeParent({ op: 'clear' });
+        },
+        async close() {
+            if (closed)
+                return;
+            writeParent({ op: 'quit' });
+            closed = true;
+            child.stdin.end();
+            await new Promise((resolve) => {
+                child.once('exit', () => resolve());
+                setTimeout(resolve, 500);
+            });
+            rl.close();
+        },
+    };
+}