loop-task 1.1.0 → 1.4.0

package/dist/board/hooks/useBoardKeybindings.js

@@ -0,0 +1,299 @@
+import { useKeyboard } from "@opentui/react";
+import { cycleSortMode, cycleStatusFilter } from "../state.js";
+import { copyToClipboard } from "../../shared/clipboard.js";
+import { getActionCount, getActionKeys } from "../components/ActionButtons.js";
+const PANEL_ORDER = ["search", "project-filter", "status", "sort", "header-tasks", "header-projects", "header-new", "loops", "runs", "actions"];
+const PANEL_LEFT = {
+    search: "actions",
+    "project-filter": "search",
+    status: "project-filter",
+    sort: "status",
+    "header-tasks": "sort",
+    "header-projects": "header-tasks",
+    "header-new": "header-projects",
+    loops: "header-new",
+    runs: "loops",
+    actions: "runs",
+    projects: "header-new",
+};
+const PANEL_RIGHT = {
+    search: "project-filter",
+    "project-filter": "status",
+    status: "sort",
+    sort: "header-tasks",
+    "header-tasks": "header-projects",
+    "header-projects": "header-new",
+    "header-new": "loops",
+    loops: "runs",
+    runs: "actions",
+    actions: "search",
+    projects: "loops",
+};
+function nextPanel(current, direction) {
+    return direction === "left" ? PANEL_LEFT[current] : PANEL_RIGHT[current];
+}
+const CONFIRM_KEYS = {
+    left: (p) => p.setConfirmChoice((c) => (c === 1 ? 0 : 1)),
+    right: (p) => p.setConfirmChoice((c) => (c === 1 ? 0 : 1)),
+    tab: (p) => p.setConfirmChoice((c) => (c === 1 ? 0 : 1)),
+    y: (p) => { const a = p.confirm.action; p.setConfirm(null); void a(); },
+    n: (p) => p.setConfirm(null),
+    escape: (p) => p.setConfirm(null),
+    return: (p) => {
+        if (p.confirmChoice === 1) {
+            const a = p.confirm.action;
+            p.setConfirm(null);
+            void a();
+        }
+        else
+            p.setConfirm(null);
+    },
+    enter: (p) => {
+        if (p.confirmChoice === 1) {
+            const a = p.confirm.action;
+            p.setConfirm(null);
+            void a();
+        }
+        else
+            p.setConfirm(null);
+    },
+};
+const VIEW_ESCAPE = {
+    create: (p) => { p.setEditTarget(null); p.onBack(); },
+    "task-create": (p) => { p.setEditTask(null); p.onBack(); },
+    "task-edit": (p) => { p.setEditTask(null); p.onBack(); },
+    "task-list": (p) => p.onBack(),
+    projects: (p) => p.onBack(),
+};
+const OVERLAY_DISMISS = {
+    log: (p) => { p.setLogModalRun(null); return true; },
+    help: (p) => { p.setHelpOpen(false); return true; },
+    search: (p, key) => {
+        p.setSearchActive(false);
+        p.setFocusedPanel(key === "return" || key === "enter" ? "loops" : "search");
+        return true;
+    },
+};
+const GLOBAL_KEYS = {
+    escape: (p) => { p.destroyLogSocket(); p.onQuit(); },
+    h: (p) => p.setHelpOpen(true),
+    n: (p) => { p.setEditTarget(null); p.push("create"); },
+    t: (p) => { p.setEditTask(null); p.push("task-create"); },
+    e: (p) => p.onAction("edit"),
+    d: (p) => p.onAction("delete"),
+    delete: (p) => p.onAction("delete"),
+    p: (p) => p.onAction("pause-or-play"),
+    s: (p) => p.onAction("stop"),
+    f: (p) => p.onAction("trigger"),
+};
+const panelHandlers = {
+    search: (key, p) => {
+        if (key === "return" || key === "enter") {
+            p.setSearchActive(true);
+            return true;
+        }
+        return false;
+    },
+    "project-filter": (key, p) => {
+        if (key === "return" || key === "enter") {
+            p.onSelectProject?.();
+            return true;
+        }
+        return false;
+    },
+    status: (key, p) => {
+        if (key === "return" || key === "enter") {
+            p.setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) }));
+            return true;
+        }
+        return false;
+    },
+    sort: (key, p) => {
+        if (key === "return" || key === "enter") {
+            p.setSort((prev) => cycleSortMode(prev));
+            return true;
+        }
+        return false;
+    },
+    "header-tasks": (key, p) => {
+        if (key === "return" || key === "enter") {
+            p.onViewTasks?.();
+            return true;
+        }
+        return false;
+    },
+    "header-projects": (key, p) => {
+        if (key === "return" || key === "enter") {
+            p.onViewProjects?.();
+            return true;
+        }
+        return false;
+    },
+    "header-new": (key, p) => {
+        if (key === "return" || key === "enter") {
+            p.onAddLoop?.();
+            return true;
+        }
+        return false;
+    },
+    loops: (key, p) => {
+        if (key === "up" || key === "k") {
+            p.setSelectedIndex((i) => Math.max(0, i - 1));
+            return true;
+        }
+        if (key === "down" || key === "j") {
+            p.setSelectedIndex((i) => Math.min(p.selected ? p.selected.runHistory.length - 1 : 0, i + 1));
+            return true;
+        }
+        if (key === "return" || key === "enter") {
+            p.setFocusedPanel("actions");
+            return true;
+        }
+        return false;
+    },
+    runs: (key, p) => {
+        if (key === "up" || key === "k") {
+            p.setSelectedRunIndex((i) => Math.max(0, i - 1));
+            return true;
+        }
+        if (key === "down" || key === "j") {
+            p.setSelectedRunIndex((i) => Math.min(p.selectedRunCount - 1, i + 1));
+            return true;
+        }
+        if ((key === "return" || key === "enter") && p.selected && p.selected.runHistory.length > 0) {
+            const runs = p.selected.runHistory;
+            const idx = Math.min(p.selectedRunIndex, runs.length - 1);
+            p.onOpenRunLog(runs[runs.length - 1 - idx]);
+            return true;
+        }
+        return false;
+    },
+    actions: (key, p) => {
+        const count = p.selected ? getActionCount(p.selected.status) : 0;
+        const keys = p.selected ? getActionKeys(p.selected.status) : [];
+        if (key === "up" || key === "k") {
+            p.setSelectedAction((i) => Math.max(0, Math.min(i, count - 1)));
+            return true;
+        }
+        if (key === "down" || key === "j") {
+            p.setSelectedAction((i) => Math.min(count - 1, i + 1));
+            return true;
+        }
+        if (key === "return" || key === "enter") {
+            p.onAction(keys[p.selectedAction] ?? "edit");
+            return true;
+        }
+        return false;
+    },
+    projects: () => false,
+};
+const BOARD_SHORTCUTS = {
+    "/": (p) => p.setSearchActive(true),
+    o: (p) => p.setSort((prev) => cycleSortMode(prev)),
+    x: (p) => p.setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) })),
+    r: (p) => p.onSelectProject?.(),
+    c: (p) => p.onSelectProject?.(),
+};
+export function useBoardKeybindings(params) {
+    const { confirm, confirmChoice, setConfirm, setConfirmChoice, helpOpen, setHelpOpen, searchActive, setSearchActive, view, push, pop, setEditTarget, setEditTask, selected, visibleCount, setSelectedIndex, setFilters, setSort, onQuit, destroyLogSocket, logModalRun, setLogModalRun, logModalLines, selectedRunIndex, setSelectedRunIndex, selectedRunCount, focusedPanel, setFocusedPanel, selectedAction, setSelectedAction, onAction, onOpenRunLog, refreshTasks, onViewTasks, onViewProjects, onAddLoop, onSelectProject, } = params;
+    useKeyboard((key) => {
+        const name = key.name;
+        if (confirm) {
+            CONFIRM_KEYS[name]?.({ confirm, confirmChoice, setConfirm, setConfirmChoice });
+            return;
+        }
+        if (logModalRun) {
+            if (name === "escape" || name === "q") {
+                OVERLAY_DISMISS.log({ setLogModalRun, setHelpOpen, setSearchActive, setFocusedPanel }, name);
+                return;
+            }
+            if (key.ctrl && name === "c") {
+                copyToClipboard(logModalLines.join("\n"));
+                return;
+            }
+            return;
+        }
+        if (helpOpen && (name === "h" || name === "escape")) {
+            OVERLAY_DISMISS.help({ setLogModalRun, setHelpOpen, setSearchActive, setFocusedPanel }, name);
+            return;
+        }
+        if (helpOpen)
+            return;
+        if (searchActive && (name === "escape" || name === "return" || name === "enter")) {
+            OVERLAY_DISMISS.search({ setLogModalRun, setHelpOpen, setSearchActive, setFocusedPanel }, name);
+            return;
+        }
+        if (searchActive) {
+            if (name === "left") {
+                setSearchActive(false);
+                setFocusedPanel("actions");
+                setSelectedAction((selected ? getActionCount(selected.status) : 0) - 1);
+                return;
+            }
+            if (name === "backspace") {
+                setFilters((prev) => ({ ...prev, query: prev.query.slice(0, -1) }));
+                return;
+            }
+            if (key.sequence && key.sequence.length === 1 && key.sequence >= " " && key.sequence <= "~") {
+                setFilters((prev) => ({ ...prev, query: prev.query + key.sequence }));
+                return;
+            }
+            return;
+        }
+        if (name === "left" || name === "right") {
+            if (focusedPanel === "actions") {
+                const actionCount = selected ? getActionCount(selected.status) : 0;
+                if (name === "left" && selectedAction === 0) {
+                    setFocusedPanel((p) => nextPanel(p, "left"));
+                }
+                else if (name === "right" && selectedAction === actionCount - 1) {
+                    setFocusedPanel((p) => nextPanel(p, "right"));
+                }
+                else {
+                    setSelectedAction((i) => name === "right"
+                        ? Math.min(actionCount - 1, i + 1)
+                        : Math.max(0, i - 1));
+                }
+            }
+            else {
+                const next = nextPanel(focusedPanel, name === "right" ? "right" : "left");
+                if (next === "actions") {
+                    setFocusedPanel("actions");
+                    setSelectedAction(0);
+                }
+                else {
+                    setFocusedPanel(next);
+                }
+            }
+            return;
+        }
+        if (view !== "board" && name === "escape") {
+            VIEW_ESCAPE[view]?.({ setEditTarget, setEditTask, onBack: pop });
+            return;
+        }
+        if (view !== "board")
+            return;
+        const globalHandler = GLOBAL_KEYS[name];
+        if (globalHandler) {
+            globalHandler({ destroyLogSocket, onQuit, setHelpOpen, setEditTarget, setEditTask, push, onAction });
+            return;
+        }
+        const panelHandler = panelHandlers[focusedPanel];
+        if (panelHandler?.(name, {
+            setSearchActive, setFilters, setSort, setEditTarget, push,
+            setSelectedIndex, setSelectedRunIndex, setFocusedPanel, selectedRunCount, selected,
+            selectedRunIndex, setSelectedAction, selectedAction, onAction, onOpenRunLog,
+            refreshTasks, onViewTasks, onViewProjects, onAddLoop,
+        }))
+            return;
+        const shortcut = BOARD_SHORTCUTS[name];
+        if (shortcut) {
+            shortcut({
+                setSearchActive, setFilters, setSort, setEditTarget, push,
+                setSelectedIndex, setSelectedRunIndex, setFocusedPanel, selectedRunCount, selected,
+                selectedRunIndex, setSelectedAction, selectedAction, onAction, onOpenRunLog,
+                onSelectProject,
+            });
+        }
+    });
+}

package/dist/board/hooks/useBreakpoint.js

@@ -0,0 +1,6 @@
+import { useTerminalDimensions } from "@opentui/react";
+import { BOARD_BREAKPOINT_WIDTH } from "../../config/constants.js";
+export function useBreakpoint() {
+    const { width } = useTerminalDimensions();
+    return width < BOARD_BREAKPOINT_WIDTH ? "narrow" : "wide";
+}

package/dist/board/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/board/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/board/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/board/hooks/useTaskKeybindings.js

@@ -0,0 +1,114 @@
+import { useKeyboard } from "@opentui/react";
+import { nextTaskPanel } from "../components/TaskBrowser.js";
+export function useTaskKeybindings(params) {
+    const { confirm, view, tasks, taskSelectedIndex, setTaskSelectedIndex, taskSelectedAction, setTaskSelectedAction, taskFocusedPanel, setTaskFocusedPanel, taskSearchActive, setTaskSearchActive, taskQuery, setTaskQuery, onTaskAction, onCancel, onCreateTask, selectable = true, } = params;
+    const taskActions = selectable
+        ? ["select", "edit", "delete"]
+        : ["edit", "delete"];
+    const taskActionCount = taskActions.length;
+    useKeyboard((key) => {
+        if (view !== "task-list")
+            return;
+        const name = key.name;
+        if (confirm)
+            return;
+        if (taskSearchActive) {
+            if (name === "escape") {
+                setTaskSearchActive(false);
+                setTaskFocusedPanel("tasks");
+                return;
+            }
+            if (name === "return" || name === "enter") {
+                setTaskSearchActive(false);
+                setTaskFocusedPanel("tasks");
+                return;
+            }
+            if (name === "left") {
+                setTaskSearchActive(false);
+                setTaskFocusedPanel("actions");
+                setTaskSelectedAction(taskActionCount - 1);
+                return;
+            }
+            if (name === "backspace") {
+                setTaskQuery((q) => q.slice(0, -1));
+                return;
+            }
+            if (key.sequence && key.sequence.length === 1 && key.sequence >= " " && key.sequence <= "~") {
+                setTaskQuery((q) => q + key.sequence);
+                return;
+            }
+            return;
+        }
+        if (name === "escape") {
+            onCancel();
+            return;
+        }
+        if (name === "n") {
+            onCreateTask();
+            return;
+        }
+        if (name === "/" && taskFocusedPanel === "tasks") {
+            setTaskSearchActive(true);
+            return;
+        }
+        if (name === "tab") {
+            setTaskFocusedPanel((p) => nextTaskPanel(p, "right"));
+            return;
+        }
+        if (name === "left" || name === "right") {
+            if (taskFocusedPanel === "actions") {
+                if (name === "left" && taskSelectedAction === 0) {
+                    setTaskFocusedPanel((p) => nextTaskPanel(p, "left"));
+                }
+                else if (name === "right" && taskSelectedAction === taskActionCount - 1) {
+                    setTaskFocusedPanel((p) => nextTaskPanel(p, "right"));
+                }
+                else {
+                    setTaskSelectedAction((i) => name === "right"
+                        ? Math.min(taskActionCount - 1, i + 1)
+                        : Math.max(0, i - 1));
+                }
+            }
+            else {
+                setTaskFocusedPanel((p) => nextTaskPanel(p, name === "right" ? "right" : "left"));
+            }
+            return;
+        }
+        if (taskFocusedPanel === "tasks") {
+            if (name === "up" || name === "k") {
+                setTaskSelectedIndex((i) => Math.max(0, i - 1));
+                return;
+            }
+            if (name === "down" || name === "j") {
+                setTaskSelectedIndex((i) => Math.min(tasks.length - 1, i + 1));
+                return;
+            }
+            if (name === "return" || name === "enter") {
+                setTaskFocusedPanel("actions");
+                return;
+            }
+            if (name === "e" && tasks[taskSelectedIndex]) {
+                onTaskAction("edit");
+                return;
+            }
+            if (name === "delete" && tasks[taskSelectedIndex]) {
+                onTaskAction("delete");
+                return;
+            }
+        }
+        if (taskFocusedPanel === "actions") {
+            if (name === "up" || name === "k") {
+                setTaskSelectedAction((i) => Math.max(0, i - 1));
+                return;
+            }
+            if (name === "down" || name === "j") {
+                setTaskSelectedAction((i) => Math.min(taskActionCount - 1, i + 1));
+                return;
+            }
+            if (name === "return" || name === "enter") {
+                onTaskAction(taskActions[taskSelectedAction] ?? "select");
+                return;
+            }
+        }
+    });
+}

package/dist/board/index.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "@opentui/react/jsx-runtime";
+import { createCliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+import { App } from "./App.js";
+import { boardLog } from "./board-log.js";
+export async function launchBoard() {
+    boardLog("board startup");
+    process.on("uncaughtException", (error) => {
+        boardLog("uncaught exception", error);
+    });
+    process.on("unhandledRejection", (reason) => {
+        boardLog("unhandled rejection", reason);
+    });
+    const renderer = await createCliRenderer({ exitOnCtrlC: false });
+    const quit = () => {
+        try {
+            renderer.destroy();
+        }
+        catch {
+            // ignore teardown errors
+        }
+        process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+        process.exit(0);
+    };
+    try {
+        createRoot(renderer).render(_jsx(App, { onQuit: quit }));
+    }
+    catch (error) {
+        boardLog("render failure", error);
+        throw error;
+    }
+}

package/dist/board/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 };
+}

package/dist/board/state.js

@@ -0,0 +1,99 @@
+export const defaultFilters = {
+    status: "all",
+    intervalBucket: "all",
+    recentActivity: "all",
+    query: "",
+};
+const statusOrder = {
+    running: 0,
+    waiting: 1,
+    paused: 2,
+    idle: 3,
+    stopped: 4,
+};
+function intervalBucketOf(interval) {
+    if (interval <= 60_000)
+        return "short";
+    if (interval <= 3_600_000)
+        return "medium";
+    return "long";
+}
+function activityBucketOf(loop) {
+    const baseline = loop.lastRunAt ?? loop.createdAt;
+    const ageMs = Date.now() - new Date(baseline).getTime();
+    return ageMs <= 15 * 60_000 ? "active" : "stale";
+}
+function matches(loop, filters) {
+    if (filters.status !== "all" && loop.status !== filters.status) {
+        return false;
+    }
+    if (filters.intervalBucket !== "all" &&
+        intervalBucketOf(loop.interval) !== filters.intervalBucket) {
+        return false;
+    }
+    if (filters.recentActivity !== "all" &&
+        activityBucketOf(loop) !== filters.recentActivity) {
+        return false;
+    }
+    const query = filters.query.trim().toLowerCase();
+    if (!query) {
+        return true;
+    }
+    const haystack = [
+        loop.id,
+        loop.command,
+        ...loop.commandArgs,
+        loop.description ?? "",
+        loop.status,
+        loop.intervalHuman,
+    ]
+        .join(" ")
+        .toLowerCase();
+    return haystack.includes(query);
+}
+function describeLoop(loop) {
+    return loop.description?.trim() || [loop.command, ...loop.commandArgs].join(" ").trim();
+}
+function compare(left, right, sort) {
+    if (sort === "description") {
+        return describeLoop(left).localeCompare(describeLoop(right));
+    }
+    if (sort === "created") {
+        return right.createdAt.localeCompare(left.createdAt);
+    }
+    if (sort === "recent") {
+        return (right.lastRunAt ?? right.createdAt).localeCompare(left.lastRunAt ?? left.createdAt);
+    }
+    const byStatus = statusOrder[left.status] - statusOrder[right.status];
+    if (byStatus !== 0) {
+        return byStatus;
+    }
+    const leftNext = left.nextRunAt ?? left.lastRunAt ?? left.createdAt;
+    const rightNext = right.nextRunAt ?? right.lastRunAt ?? right.createdAt;
+    return rightNext.localeCompare(leftNext);
+}
+export function applyLoopFilters(loops, filters, sort) {
+    return loops
+        .filter((loop) => matches(loop, filters))
+        .sort((left, right) => compare(left, right, sort));
+}
+const SORT_CYCLE = {
+    description: "status",
+    status: "recent",
+    recent: "created",
+    created: "description",
+};
+export function cycleSortMode(mode) {
+    return SORT_CYCLE[mode];
+}
+const STATUS_CYCLE = {
+    all: "running",
+    running: "waiting",
+    waiting: "paused",
+    paused: "idle",
+    idle: "stopped",
+    stopped: "all",
+};
+export function cycleStatusFilter(status) {
+    return STATUS_CYCLE[status];
+}