loop-task 1.5.5 → 2.0.1

package/dist/tui/components/WelcomeScreen.js

@@ -0,0 +1,70 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text, useInput } from "ink";
+import { darkTheme as theme } from "../theme.js";
+import { createLoop } from "../daemon.js";
+import { parseDuration } from "../../duration.js";
+const EXAMPLES = [
+    { label: "Run tests every 30m", interval: "30m", command: "npm", args: ["test"] },
+    { label: "Watch for GitHub issues every 5m", interval: "5m", command: "gh", args: ["issue", "list"] },
+    { label: "Sync deps every hour", interval: "1h", command: "npm", args: ["outdated"] },
+];
+export function WelcomeScreen(props) {
+    const [selectedIndex, setSelectedIndex] = React.useState(0);
+    const [creating, setCreating] = React.useState(null);
+    const items = [...EXAMPLES.map((e) => e.label), "Create empty loop"];
+    useInput((_input, key) => {
+        if (creating)
+            return;
+        if (key.upArrow) {
+            setSelectedIndex((i) => i <= 0 ? items.length - 1 : i - 1);
+            return;
+        }
+        if (key.downArrow) {
+            setSelectedIndex((i) => i >= items.length - 1 ? 0 : i + 1);
+            return;
+        }
+        if (key.return) {
+            if (selectedIndex === EXAMPLES.length) {
+                props.onCreateEmpty();
+                return;
+            }
+            const example = EXAMPLES[selectedIndex];
+            if (example) {
+                setCreating(example.label);
+                const options = {
+                    interval: parseDuration(example.interval),
+                    taskId: null,
+                    command: example.command,
+                    commandArgs: example.args,
+                    cwd: "",
+                    immediate: false,
+                    maxRuns: null,
+                    verbose: false,
+                    description: example.label,
+                    projectId: "default",
+                    offset: null,
+                };
+                createLoop(options, example.interval)
+                    .then(() => props.onRefresh())
+                    .then(() => props.onCreateLoop())
+                    .catch(() => setCreating(null));
+            }
+            return;
+        }
+        if (_input === "n") {
+            props.onCreateEmpty();
+            return;
+        }
+        if (_input === "h") {
+            return;
+        }
+    });
+    return (_jsx(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, children: _jsxs(Box, { borderStyle: "round", borderColor: theme.accent.brand, backgroundColor: theme.bg.surface, paddingX: 4, paddingY: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.accent.brand, bold: true, children: ["\n", "Welcome to loop-task!", "\n"] }), _jsx(Text, { color: theme.text.secondary, children: "Loop engineering: define a purpose," }), _jsxs(Text, { color: theme.text.secondary, children: ["give it an interval, let it iterate.", "\n"] }), _jsxs(Text, { color: theme.text.muted, children: ["No loops yet. Here are some examples:", "\n"] }), items.map((label, i) => {
+                    const isSelected = i === selectedIndex;
+                    const bg = isSelected ? theme.bg.active : undefined;
+                    const fg = isSelected ? theme.text.inverse : theme.text.primary;
+                    const prefix = isSelected ? "\u203a " : "  ";
+                    return (_jsx(Box, { backgroundColor: bg, children: _jsxs(Text, { color: fg, children: [prefix, label] }) }, label));
+                }), _jsxs(Text, { color: theme.text.muted, children: ["\n", "or press 'n' to create a custom loop"] }), _jsx(Text, { color: theme.text.muted, children: "press 'h' for keyboard shortcuts (from main view)" }), creating ? (_jsxs(Text, { color: theme.accent.brand, children: ["\n", "Creating: ", creating, "..."] })) : null] }) }));
+}

package/dist/tui/components/WizardForm.js

@@ -0,0 +1,178 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useMemo } from "react";
+import { Box, Text, useInput } from "ink";
+import { darkTheme as theme } from "../theme.js";
+import { t } from "../../i18n/index.js";
+import { useLoopFormValidation } from "../../hooks/useLoopFormValidation.js";
+import { copyToClipboard } from "../../shared/clipboard.js";
+import { sanitizePaste } from "../utils/paste.js";
+function TextField({ value, hint, isActive, }) {
+    const borderColor = isActive ? theme.accent.brand : theme.border.dim;
+    const backgroundColor = isActive ? theme.bg.input : undefined;
+    const showHint = value.length === 0;
+    return (_jsxs(Box, { borderStyle: "single", borderColor: borderColor, backgroundColor: backgroundColor, paddingLeft: 1, overflow: "hidden", width: "100%", children: [_jsx(Text, { color: showHint ? theme.text.muted : theme.text.primary, children: showHint ? hint : value }), isActive ? _jsx(Text, { inverse: true, children: " " }) : null] }));
+}
+export function WizardForm(props) {
+    const { title, steps, onComplete, onCancel, disabled = false } = props;
+    const [values, setValues] = useState({});
+    const [activeField, setActiveField] = useState(0);
+    const [validationErrors, setValidationErrors] = useState({});
+    const { validateField } = useLoopFormValidation();
+    const step = steps[activeField];
+    const valueFor = useCallback((s) => values[s.key] ?? s.defaultValue ?? "", [values]);
+    // Resolved values: raw values with defaults filled in.
+    // skip() functions must receive these so they work before the user touches a field.
+    const resolvedValues = useMemo(() => {
+        const result = {};
+        for (const s of steps)
+            result[s.key] = values[s.key] ?? s.defaultValue ?? "";
+        return result;
+    }, [steps, values]);
+    const setValue = useCallback((key, next) => {
+        setValues((prev) => ({ ...prev, [key]: next }));
+    }, []);
+    const clearError = useCallback((key) => {
+        setValidationErrors((prev) => {
+            if (!(key in prev))
+                return prev;
+            const next = { ...prev };
+            delete next[key];
+            return next;
+        });
+    }, []);
+    const setError = useCallback((key, msg) => {
+        setValidationErrors((prev) => ({ ...prev, [key]: msg }));
+    }, []);
+    const submit = useCallback(() => {
+        const errors = {};
+        for (const s of steps) {
+            if (s.skip && s.skip(resolvedValues))
+                continue;
+            const err = validateField(s.key, resolvedValues);
+            if (err)
+                errors[s.key] = err;
+        }
+        if (Object.keys(errors).length > 0) {
+            setValidationErrors(errors);
+            const firstErrorIdx = steps.findIndex((s) => s.key in errors);
+            if (firstErrorIdx >= 0)
+                setActiveField(firstErrorIdx);
+            return;
+        }
+        const missing = steps.find((s) => !s.skip?.(values) && s.required && !valueFor(s).trim());
+        if (missing) {
+            setActiveField(steps.indexOf(missing));
+            return;
+        }
+        const result = {};
+        for (const s of steps) {
+            if (s.skip && s.skip(resolvedValues))
+                continue;
+            result[s.key] = valueFor(s);
+        }
+        onComplete(result);
+    }, [steps, valueFor, onComplete, resolvedValues]);
+    const findNextField = useCallback((from, delta) => {
+        let next = from + delta;
+        const len = steps.length;
+        while (next >= 0 && next < len) {
+            const candidate = steps[next];
+            if (!candidate.skip || !candidate.skip(resolvedValues))
+                return next;
+            next += delta;
+        }
+        return from;
+    }, [steps, values]);
+    const moveField = useCallback((delta) => {
+        if (step) {
+            const err = validateField(step.key, resolvedValues);
+            if (err) {
+                setError(step.key, err);
+                return;
+            }
+            clearError(step.key);
+        }
+        const next = findNextField(activeField, delta);
+        if (next !== activeField)
+            setActiveField(next);
+    }, [step, valueFor, resolvedValues, activeField, findNextField, setError, clearError]);
+    const visibleSteps = steps.filter((s) => !s.skip || !s.skip(resolvedValues));
+    useInput((input, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.ctrl && input === "s") {
+            submit();
+            return;
+        }
+        if (key.ctrl && input === "y") {
+            if (step) {
+                copyToClipboard(valueFor(step));
+            }
+            return;
+        }
+        if (key.tab) {
+            moveField(key.shift ? -1 : 1);
+            return;
+        }
+        if (!step)
+            return;
+        if (step.renderCustom) {
+            // If onActivate is set, this is a "launch modal" field:
+            // Enter opens the modal, everything else is blocked.
+            if (step.onActivate) {
+                if (key.return)
+                    step.onActivate();
+            }
+            // If no onActivate, the renderCustom component owns its own useInput
+            // for text editing (Enter, arrows, backspace). WizardForm only handles
+            // Esc / Ctrl+S / Tab which are already caught above.
+            return;
+        }
+        // Text field editing
+        if (key.return) {
+            moveField(1);
+            return;
+        }
+        if (key.delete || key.backspace) {
+            setValue(step.key, valueFor(step).slice(0, -1));
+            return;
+        }
+        // Bracketed paste: content wrapped in ESC[200~ ... ESC[201~
+        if (input.includes("\x1b[200~")) {
+            setValue(step.key, valueFor(step) + sanitizePaste(input));
+            return;
+        }
+        // Multi-char containing CR/LF with no bracketed markers — ignore
+        if (input.length > 1 && (input.includes("\r") || input.includes("\n")))
+            return;
+        // Multi-char printable input = unbracketed single-line paste (e.g. right-click)
+        if (input.length > 1 && !key.meta) {
+            setValue(step.key, valueFor(step) + sanitizePaste(input));
+            return;
+        }
+        if (input.length === 1 && input >= " " && input <= "~") {
+            setValue(step.key, valueFor(step) + input);
+        }
+    }, { isActive: !disabled });
+    const mid = Math.ceil(steps.length / 2);
+    const columns = [
+        [steps.slice(0, mid), 0],
+        [steps.slice(mid), mid],
+    ];
+    const filledCount = visibleSteps.filter((s) => valueFor(s).trim().length > 0).length;
+    function renderField(s, fieldIdx) {
+        const isActive = fieldIdx === activeField;
+        const val = valueFor(s);
+        if (s.skip && s.skip(resolvedValues))
+            return null;
+        return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: isActive ? theme.accent.brand : theme.text.muted, bold: true, children: isActive ? "\u203a " : "  " }), _jsx(Text, { color: isActive ? theme.accent.brand : theme.text.secondary, bold: true, children: s.prompt }), s.required ? _jsx(Text, { color: theme.semantic.danger, children: "*" }) : null] }), _jsx(Box, { paddingLeft: 2, width: "100%", children: s.renderCustom ? (s.renderCustom({
+                        value: val,
+                        isActive,
+                        onChange: (next) => setValue(s.key, next),
+                        onAdvance: () => moveField(1),
+                    })) : (_jsx(TextField, { value: val, hint: s.hint, isActive: isActive })) }), validationErrors[s.key] ? (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: theme.semantic.danger, children: validationErrors[s.key] }) })) : null] }, s.key));
+    }
+    return (_jsxs(Box, { flexDirection: "column", backgroundColor: theme.bg.surface, paddingY: 1, paddingX: 2, flexGrow: 1, children: [_jsxs(Box, { justifyContent: "space-between", marginBottom: 1, children: [_jsx(Text, { color: theme.accent.loop, bold: true, children: title }), _jsxs(Text, { color: theme.text.muted, children: [t("wizard.filled", { filled: filledCount, total: visibleSteps.length }), " . ", t("wizard.footerHints")] })] }), _jsx(Box, { flexDirection: "row", gap: 4, children: columns.map(([col, offset]) => (_jsx(Box, { flexDirection: "column", width: "50%", children: col.map((s, i) => renderField(s, i + offset)) }, offset))) })] }));
+}

package/dist/tui/daemon.js

@@ -0,0 +1,142 @@
+import { sendRequest, streamRequest } from "../client/ipc.js";
+import { t } from "../i18n/index.js";
+import { LOG_TAIL_DEFAULT } from "../config/constants.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getDataDir } from "../config/paths.js";
+function expectOk(message, type) {
+    if (type !== "ok") {
+        throw new Error(message);
+    }
+}
+export async function listLoops() {
+    const response = await sendRequest({ type: "list" });
+    if (response.type !== "ok") {
+        throw new Error(response.message);
+    }
+    return response.data;
+}
+export async function pauseLoop(id) {
+    const response = await sendRequest({ type: "pause", payload: { id } });
+    expectOk(response.message ?? t("errors.pauseFailed"), response.type);
+}
+export async function resumeLoop(id) {
+    const response = await sendRequest({ type: "resume", payload: { id } });
+    expectOk(response.message ?? t("errors.resumeFailed"), response.type);
+}
+export async function stopLoop(id) {
+    const response = await sendRequest({ type: "stop-loop", payload: { id } });
+    expectOk(response.message ?? "Stop failed", response.type);
+}
+export async function playLoop(id) {
+    const response = await sendRequest({ type: "play-loop", payload: { id } });
+    expectOk(response.message ?? "Play failed", response.type);
+}
+export async function triggerLoop(id) {
+    const response = await sendRequest({ type: "trigger", payload: { id } });
+    expectOk(response.message ?? t("errors.forceRunFailed"), response.type);
+}
+export async function deleteLoop(id) {
+    const response = await sendRequest({ type: "delete", payload: { id } });
+    expectOk(response.message ?? t("errors.deleteFailed"), response.type);
+}
+export async function createLoop(options, intervalHuman) {
+    const response = await sendRequest({
+        type: "start",
+        payload: { ...options, intervalHuman },
+    });
+    if (response.type !== "ok") {
+        throw new Error(response.message);
+    }
+    return response.data.id;
+}
+export async function updateLoop(id, options, intervalHuman) {
+    const response = await sendRequest({
+        type: "update",
+        payload: { id, ...options, intervalHuman },
+    });
+    if (response.type !== "ok") {
+        throw new Error(response.message);
+    }
+    return response.data.id;
+}
+export function streamLogs(id, onLine, onError) {
+    return streamRequest({ type: "logs", payload: { id, follow: true, tail: LOG_TAIL_DEFAULT } }, onLine, () => { }, onError);
+}
+export async function fetchRunLog(id, runNumber) {
+    const response = await sendRequest({ type: "run-log", payload: { id, runNumber } });
+    if (response.type !== "ok") {
+        throw new Error(response.message ?? "Failed to fetch run log");
+    }
+    return response.data ?? "";
+}
+export function streamRunLog(id, runNumber, onLine, onEnd, onError) {
+    return streamRequest({ type: "run-log-stream", payload: { id, runNumber } }, onLine, onEnd, onError);
+}
+export async function listTasks() {
+    const response = await sendRequest({ type: "task-list" });
+    if (response.type !== "ok") {
+        throw new Error(response.message);
+    }
+    return response.data;
+}
+export async function createTask(payload) {
+    const response = await sendRequest({ type: "task-create", payload });
+    if (response.type !== "ok") {
+        throw new Error(response.message);
+    }
+    return response.data;
+}
+export async function updateTask(id, payload) {
+    const response = await sendRequest({ type: "task-update", payload: { id, ...payload } });
+    if (response.type !== "ok") {
+        throw new Error(response.message);
+    }
+    return response.data;
+}
+export async function deleteTask(id) {
+    const response = await sendRequest({ type: "task-delete", payload: { id } });
+    expectOk(response.message ?? "Task delete failed", response.type);
+}
+export async function listProjects() {
+    const response = await sendRequest({ type: "project-list" });
+    if (response.type !== "ok")
+        throw new Error(response.message);
+    return response.data;
+}
+export async function createProject(name, color) {
+    const response = await sendRequest({ type: "project-create", payload: { name, color } });
+    if (response.type !== "ok")
+        throw new Error(response.message);
+    return response.data;
+}
+export async function updateProject(id, name, color) {
+    const response = await sendRequest({ type: "project-update", payload: { id, name, color } });
+    expectOk(response.message ?? t("project.error.updateFailed"), response.type);
+}
+export async function exportConfig() {
+    const [loops, tasks, projects] = await Promise.all([
+        listLoops().catch(() => []),
+        listTasks().catch(() => []),
+        listProjects().catch(() => []),
+    ]);
+    const exportData = {
+        version: 2,
+        exportedAt: new Date().toISOString(),
+        loops,
+        tasks,
+        projects,
+    };
+    const json = JSON.stringify(exportData, null, 2);
+    const dataDir = getDataDir();
+    const exportsDir = path.join(dataDir, "exports");
+    await fs.mkdir(exportsDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const filePath = path.join(exportsDir, `loop-export-${ts}.json`);
+    await fs.writeFile(filePath, json, "utf-8");
+    return { json, filePath };
+}
+export async function deleteProject(id) {
+    const response = await sendRequest({ type: "project-delete", payload: { id } });
+    expectOk(response.message ?? t("project.error.deleteFailed"), response.type);
+}

package/dist/tui/format.js

@@ -0,0 +1,111 @@
+import { t } from "../i18n/index.js";
+export function unescapeCommand(str) {
+    return str
+        .replace(/\\\\/g, "\x00")
+        .replace(/\\"/g, '"')
+        .replace(/\x00/g, "\\");
+}
+export function quoteArg(arg) {
+    return /[\s"]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
+}
+export function commandLine(command, args) {
+    return [unescapeCommand(command), ...args.map((a) => quoteArg(unescapeCommand(a)))].join(" ").trim();
+}
+export function formatCmd(command, args, max = 24) {
+    const full = commandLine(command, args);
+    return full.length > max ? full.slice(0, max - 3) + "..." : full;
+}
+export function describeLoop(loop) {
+    return loop.description?.trim() || commandLine(loop.command, loop.commandArgs);
+}
+export function truncate(text, max) {
+    return text.length > max ? text.slice(0, max - 3) + "..." : text;
+}
+export function timeAgo(iso) {
+    if (!iso)
+        return t("format.dash");
+    const diff = Date.now() - new Date(iso).getTime();
+    const secs = Math.floor(diff / 1000);
+    if (secs < 5)
+        return t("format.justNow");
+    if (secs < 60)
+        return t("format.secsAgo", { secs });
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return t("format.minsAgo", { mins });
+    const hrs = Math.floor(mins / 60);
+    if (hrs < 24)
+        return t("format.hrsAgo", { hrs });
+    return t("format.daysAgo", { days: Math.floor(hrs / 24) });
+}
+export function timeUntil(iso) {
+    if (!iso)
+        return t("format.dash");
+    const diff = Math.max(0, new Date(iso).getTime() - Date.now());
+    const secs = Math.floor(diff / 1000);
+    if (secs < 5)
+        return t("format.justNow");
+    if (secs < 60)
+        return t("format.secsAhead", { secs });
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return t("format.minsAhead", { mins });
+    const hrs = Math.floor(mins / 60);
+    if (hrs < 24)
+        return t("format.hrsAhead", { hrs });
+    return t("format.daysAhead", { days: Math.floor(hrs / 24) });
+}
+const STATUS_COLORS = {
+    running: "#4ade80",
+    waiting: "#6b7280",
+    paused: "#facc15",
+    idle: "#fb923c",
+    stopped: "#f87171",
+};
+export function statusColor(status) {
+    return STATUS_COLORS[status] ?? "#ffffff";
+}
+export function timingLabel(loop) {
+    if (loop.status === "paused")
+        return t("format.timingPaused");
+    if (loop.status === "idle")
+        return t("format.timingIdle");
+    if (loop.nextRunAt)
+        return t("format.timingNext", { timeAgo: timeUntil(loop.nextRunAt) });
+    if (loop.lastRunAt)
+        return t("format.timingLast", { timeAgo: timeAgo(loop.lastRunAt) });
+    return t("format.timingNew");
+}
+export function statusLabel(status) {
+    return status === "waiting" ? "waiting" : status;
+}
+export function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function formatRunDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
+}
+export function formatRunTime(iso) {
+    const d = new Date(iso);
+    return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false });
+}
+export function formatDate(iso) {
+    const d = new Date(iso);
+    const date = d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    const time = d.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
+    return `${date} ${time}`;
+}
+export function sinceLabel(loop) {
+    const ts = loop.sessionStartedAt ?? loop.createdAt;
+    if (!ts)
+        return t("format.dash");
+    return formatDate(ts);
+}

package/dist/tui/hooks/useBreakpoint.js

@@ -0,0 +1,7 @@
+import { useStdout } from "ink";
+import { BOARD_BREAKPOINT_WIDTH } from "../../config/constants.js";
+export function useBreakpoint() {
+    const { stdout } = useStdout();
+    const width = stdout?.columns ?? 80;
+    return width < BOARD_BREAKPOINT_WIDTH ? "narrow" : "wide";
+}

package/dist/tui/hooks/useHoverState.js

@@ -0,0 +1,11 @@
+import { useState } from "react";
+export function useHoverState() {
+    const [isHovered, setIsHovered] = useState(false);
+    return {
+        isHovered,
+        hoverProps: {
+            onMouseOver: () => setIsHovered(true),
+            onMouseOut: () => setIsHovered(false),
+        },
+    };
+}

package/dist/tui/hooks/useLogStream.js

@@ -0,0 +1,32 @@
+import { useEffect, useRef, useState } from "react";
+import { streamLogs } from "../daemon.js";
+import { t } from "../../i18n/index.js";
+import { LOG_LINES_MAX } from "../../config/constants.js";
+export function useLogStream(selectedId, view, onError) {
+    const [logLines, setLogLines] = useState([]);
+    const logSocket = useRef(null);
+    useEffect(() => {
+        logSocket.current?.destroy();
+        logSocket.current = null;
+        setLogLines([]);
+        if (!selectedId || view !== "board") {
+            return;
+        }
+        setLogLines([t("board.logWaiting")]);
+        const socket = streamLogs(selectedId, (line) => setLogLines((prev) => {
+            const next = prev[0] === t("board.logWaiting") ? [] : prev;
+            return [...next, line].slice(-LOG_LINES_MAX);
+        }), onError);
+        logSocket.current = socket;
+        return () => {
+            socket.destroy();
+            if (logSocket.current === socket) {
+                logSocket.current = null;
+            }
+        };
+    }, [selectedId, view]);
+    return {
+        logLines,
+        destroy: () => logSocket.current?.destroy(),
+    };
+}

package/dist/tui/hooks/useLoopPolling.js

@@ -0,0 +1,28 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { listLoops } from "../daemon.js";
+import { POLL_MS } from "../../config/constants.js";
+export function useLoopPolling() {
+    const [loops, setLoops] = useState([]);
+    const [daemonStatus, setDaemonStatus] = useState("starting");
+    const lastSerialized = useRef("");
+    const refresh = useCallback(async () => {
+        try {
+            const next = await listLoops();
+            const serialized = JSON.stringify(next);
+            if (serialized !== lastSerialized.current) {
+                lastSerialized.current = serialized;
+                setLoops(next);
+            }
+            setDaemonStatus("connected");
+        }
+        catch {
+            setDaemonStatus("error");
+        }
+    }, []);
+    useEffect(() => {
+        void refresh();
+        const timer = setInterval(() => void refresh(), POLL_MS);
+        return () => clearInterval(timer);
+    }, [refresh]);
+    return { loops, daemonStatus, refresh };
+}

package/dist/tui/index.js

@@ -0,0 +1,24 @@
+import { render } from "ink";
+import React from "react";
+import { App } from "./app.js";
+import { BRACKETED_PASTE_ENABLE, BRACKETED_PASTE_DISABLE } from "../config/constants.js";
+export async function launchBoard() {
+    // Enable bracketed paste so a native paste (Ctrl+Shift+V / Cmd+V / right-click)
+    // arrives as one delimited chunk instead of a stream of keypresses.
+    process.stdout.write(BRACKETED_PASTE_ENABLE);
+    const disableBracketedPaste = () => process.stdout.write(BRACKETED_PASTE_DISABLE);
+    const instance = render(React.createElement(App, { onQuit: () => {
+            disableBracketedPaste();
+            instance.unmount();
+        } }));
+    process.on("exit", disableBracketedPaste);
+    process.on("uncaughtException", (error) => {
+        console.error("Uncaught exception:", error);
+        disableBracketedPaste();
+        instance.unmount();
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        console.error("Unhandled rejection:", reason);
+    });
+}

package/dist/tui/router.js

@@ -0,0 +1,16 @@
+import { useState, useCallback } from "react";
+export function useRouter(initial = "board") {
+    const [stack, setStack] = useState([initial]);
+    const view = stack[stack.length - 1] ?? initial;
+    const canGoBack = stack.length > 1;
+    const push = useCallback((next) => {
+        setStack((s) => [...s, next]);
+    }, []);
+    const replace = useCallback((next) => {
+        setStack((s) => [...s.slice(0, -1), next]);
+    }, []);
+    const pop = useCallback(() => {
+        setStack((s) => (s.length > 1 ? s.slice(0, -1) : s));
+    }, []);
+    return { view, stack, push, replace, pop, canGoBack };
+}