loop-task 1.3.0 → 1.4.1

package/dist/board/hooks/useBoardKeybindings.js

@@ -1,191 +1,299 @@
 import { useKeyboard } from "@opentui/react";
 import { cycleSortMode, cycleStatusFilter } from "../state.js";
-const PANEL_ORDER = ["search", "status", "sort", "new", "loops", "runs", "actions"];
-const ACTION_COUNT = 4;
+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) {
-    const idx = PANEL_ORDER.indexOf(current);
-    return PANEL_ORDER[(idx + (direction === "right" ? 1 : PANEL_ORDER.length - 1)) % PANEL_ORDER.length];
+    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, setView, setEditTarget, selected, visibleCount, setSelectedIndex, setFilters, setSort, onQuit, destroyLogSocket, logModalRun, setLogModalRun, selectedRunIndex, setSelectedRunIndex, selectedRunCount, focusedPanel, setFocusedPanel, selectedAction, setSelectedAction, onAction, onOpenRunLog, } = 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) {
-            if (name === "left" || name === "right" || name === "tab") {
-                setConfirmChoice((c) => (c === 1 ? 0 : 1));
-                return;
-            }
-            if (name === "y") {
-                const action = confirm.action;
-                setConfirm(null);
-                void action();
-            }
-            else if (name === "n" || name === "escape") {
-                setConfirm(null);
-            }
-            else if (name === "return" || name === "enter") {
-                if (confirmChoice === 1) {
-                    const action = confirm.action;
-                    setConfirm(null);
-                    void action();
-                }
-                else {
-                    setConfirm(null);
-                }
-            }
+            CONFIRM_KEYS[name]?.({ confirm, confirmChoice, setConfirm, setConfirmChoice });
             return;
         }
         if (logModalRun) {
             if (name === "escape" || name === "q") {
-                setLogModalRun(null);
-            }
-            return;
-        }
-        if (helpOpen) {
-            if (name === "h" || name === "escape") {
-                setHelpOpen(false);
-            }
-            return;
-        }
-        if (searchActive) {
-            if (name === "escape") {
-                setSearchActive(false);
-                setFocusedPanel("search");
-            }
-            else if (name === "return" || name === "enter") {
-                setSearchActive(false);
-                setFocusedPanel("loops");
+                OVERLAY_DISMISS.log({ setLogModalRun, setHelpOpen, setSearchActive, setFocusedPanel }, name);
+                return;
             }
-            return;
-        }
-        if (view === "create") {
-            if (name === "escape") {
-                setEditTarget(null);
-                setView("board");
+            if (key.ctrl && name === "c") {
+                copyToClipboard(logModalLines.join("\n"));
+                return;
             }
             return;
         }
-        if (name === "escape") {
-            destroyLogSocket();
-            onQuit();
+        if (helpOpen && (name === "h" || name === "escape")) {
+            OVERLAY_DISMISS.help({ setLogModalRun, setHelpOpen, setSearchActive, setFocusedPanel }, name);
             return;
         }
-        if (name === "h") {
-            setHelpOpen(true);
+        if (helpOpen)
             return;
-        }
-        if (name === "n") {
-            setEditTarget(null);
-            setView("create");
+        if (searchActive && (name === "escape" || name === "return" || name === "enter")) {
+            OVERLAY_DISMISS.search({ setLogModalRun, setHelpOpen, setSearchActive, setFocusedPanel }, name);
             return;
         }
-        if (name === "r") {
-            onAction("run");
-            return;
-        }
-        if (name === "p") {
-            onAction("pause-resume");
-            return;
-        }
-        if (name === "delete") {
-            onAction("delete");
-            return;
-        }
-        if (view === "board") {
-            if (name === "left" || name === "right") {
-                if (focusedPanel === "actions") {
-                    setSelectedAction((i) => name === "right"
-                        ? Math.min(ACTION_COUNT - 1, i + 1)
-                        : Math.max(0, i - 1));
-                }
-                else {
-                    setFocusedPanel((p) => nextPanel(p, name === "right" ? "right" : "left"));
-                }
+        if (searchActive) {
+            if (name === "left") {
+                setSearchActive(false);
+                setFocusedPanel("actions");
+                setSelectedAction((selected ? getActionCount(selected.status) : 0) - 1);
                 return;
             }
-            if (focusedPanel === "search") {
-                if (name === "return" || name === "enter") {
-                    setSearchActive(true);
-                    return;
-                }
-            }
-            else if (focusedPanel === "status") {
-                if (name === "return" || name === "enter") {
-                    setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) }));
-                    return;
-                }
-            }
-            else if (focusedPanel === "sort") {
-                if (name === "return" || name === "enter") {
-                    setSort((prev) => cycleSortMode(prev));
-                    return;
-                }
-            }
-            else if (focusedPanel === "new") {
-                if (name === "return" || name === "enter") {
-                    setEditTarget(null);
-                    setView("create");
-                    return;
-                }
+            if (name === "backspace") {
+                setFilters((prev) => ({ ...prev, query: prev.query.slice(0, -1) }));
+                return;
             }
-            else if (focusedPanel === "loops") {
-                if (name === "up" || name === "k") {
-                    setSelectedIndex((i) => Math.max(0, i - 1));
-                    return;
-                }
-                if (name === "down" || name === "j") {
-                    setSelectedIndex((i) => Math.min(visibleCount - 1, i + 1));
-                    return;
-                }
-                if ((name === "return" || name === "enter") && selected) {
-                    setEditTarget(selected);
-                    setView("create");
-                    return;
-                }
+            if (key.sequence && key.sequence.length === 1 && key.sequence >= " " && key.sequence <= "~") {
+                setFilters((prev) => ({ ...prev, query: prev.query + key.sequence }));
+                return;
             }
-            else if (focusedPanel === "runs") {
-                if (name === "up" || name === "k") {
-                    setSelectedRunIndex((i) => Math.max(0, i - 1));
-                    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"));
                 }
-                if (name === "down" || name === "j") {
-                    setSelectedRunIndex((i) => Math.min(selectedRunCount - 1, i + 1));
-                    return;
+                else if (name === "right" && selectedAction === actionCount - 1) {
+                    setFocusedPanel((p) => nextPanel(p, "right"));
                 }
-                if ((name === "return" || name === "enter") && selected && selected.runHistory.length > 0) {
-                    const runs = selected.runHistory;
-                    const idx = Math.min(selectedRunIndex, runs.length - 1);
-                    onOpenRunLog(runs[runs.length - 1 - idx]);
-                    return;
+                else {
+                    setSelectedAction((i) => name === "right"
+                        ? Math.min(actionCount - 1, i + 1)
+                        : Math.max(0, i - 1));
                 }
             }
-            else if (focusedPanel === "actions") {
-                if (name === "up" || name === "k") {
-                    setSelectedAction((i) => Math.max(0, i - 1));
-                    return;
-                }
-                if (name === "down" || name === "j") {
-                    setSelectedAction((i) => Math.min(ACTION_COUNT - 1, i + 1));
-                    return;
+            else {
+                const next = nextPanel(focusedPanel, name === "right" ? "right" : "left");
+                if (next === "actions") {
+                    setFocusedPanel("actions");
+                    setSelectedAction(0);
                 }
-                if (name === "return" || name === "enter") {
-                    const actionKeys = ["pause-resume", "run", "edit", "delete"];
-                    onAction(actionKeys[selectedAction] ?? "edit");
-                    return;
+                else {
+                    setFocusedPanel(next);
                 }
             }
-            if (name === "/") {
-                setSearchActive(true);
-                return;
-            }
-            if (name === "f") {
-                setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) }));
-                return;
-            }
-            if (name === "s") {
-                setSort((prev) => cycleSortMode(prev));
-                return;
-            }
+            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/useTaskKeybindings.js

@@ -0,0 +1,130 @@
+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 === "d" && tasks[taskSelectedIndex]) {
+                onTaskAction("delete");
+                return;
+            }
+            if (name === "delete" && tasks[taskSelectedIndex]) {
+                onTaskAction("delete");
+                return;
+            }
+            if (selectable && name === "s" && tasks[taskSelectedIndex]) {
+                onTaskAction("select");
+                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;
+            }
+            if (name === "d") {
+                onTaskAction("delete");
+                return;
+            }
+            if (selectable && name === "s") {
+                onTaskAction("select");
+                return;
+            }
+        }
+    });
+}

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

@@ -8,7 +8,8 @@ const statusOrder = {
     running: 0,
     waiting: 1,
     paused: 2,
-    stopped: 3,
+    idle: 3,
+    stopped: 4,
 };
 function intervalBucketOf(interval) {
     if (interval <= 60_000)
@@ -76,20 +77,23 @@ export function applyLoopFilters(loops, filters, sort) {
         .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 mode === "description" ? "status" : mode === "status" ? "recent" : mode === "recent" ? "created" : "description";
+    return SORT_CYCLE[mode];
 }
+const STATUS_CYCLE = {
+    all: "running",
+    running: "waiting",
+    waiting: "paused",
+    paused: "idle",
+    idle: "stopped",
+    stopped: "all",
+};
 export function cycleStatusFilter(status) {
-    switch (status) {
-        case "all":
-            return "running";
-        case "running":
-            return "waiting";
-        case "waiting":
-            return "paused";
-        case "paused":
-            return "stopped";
-        default:
-            return "all";
-    }
+    return STATUS_CYCLE[status];
 }