loop-task 2.1.4 → 2.1.5

package/dist/features/code-editor/useModalDimensions.js

@@ -0,0 +1,9 @@
+import { CODE_EDITOR_MODAL_HEIGHT, CODE_EDITOR_MODAL_WIDTH, } from "../../shared/config/constants.js";
+export function useModalDimensions() {
+    const termRows = process.stdout.rows || 24;
+    const termCols = process.stdout.columns || 80;
+    const modalHeight = Math.min(CODE_EDITOR_MODAL_HEIGHT, termRows - 2);
+    const modalWidth = Math.min(CODE_EDITOR_MODAL_WIDTH, termCols - 2);
+    const editorVisibleLines = Math.max(3, modalHeight - 6);
+    return { modalWidth, modalHeight, editorVisibleLines };
+}

package/dist/{tui → features/commands}/commands.js

@@ -1,5 +1,5 @@
-import { COMMAND_TIER_ACTION, COMMAND_TIER_CONFIRM, COMMAND_TIER_GLOBAL, COMMAND_CATEGORY_GLOBAL, COMMAND_CATEGORY_FILTERS, COMMAND_CATEGORY_LOOP, COMMAND_CATEGORY_TASK, COMMAND_CATEGORY_PROJECT, } from '../config/constants.js';
-import { t } from '../i18n/index.js';
+import { COMMAND_TIER_ACTION, COMMAND_TIER_CONFIRM, COMMAND_TIER_GLOBAL, COMMAND_CATEGORY_GLOBAL, COMMAND_CATEGORY_FILTERS, COMMAND_CATEGORY_LOOP, COMMAND_CATEGORY_TASK, COMMAND_CATEGORY_PROJECT, } from '../../shared/config/constants.js';
+import { t } from '../../shared/i18n/index.js';
 function globalCommands() {
     return [
         { label: t('cmd.help'), value: 'help', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+p' },

package/dist/features/commands/useCommandHandlers.js

@@ -0,0 +1,147 @@
+import { t } from "../../shared/i18n/index.js";
+import { cycleSortMode, cycleStatusFilter } from "../../entities/loops/filters.js";
+import { cycleProjectSortMode, cycleProjectHasLoopsFilter, cycleProjectIsSystemFilter } from "../../entities/projects/filters.js";
+export function useCommandHandlers(context) {
+    const { activeTab, selected, selectedTask, selectedProjectEntity, tasks, projects, currentProjectId, setCloneMode, setEditTarget, setPendingTaskSelection, setEditTask, setEditProject, setActiveTab, setConfirmState, setCommandsBrowserOpen, setSearchValue, setSearchState, setFilters, setSort, setCurrentProjectId, setProjectFilters, setProjectSelectedIndex, setDebugMode, setExportModal, push, pop, refresh, refreshTasks, refreshProjects, pushToast, loopService, taskService, projectService, exportService, runAction, handleOpenRunLog, } = context;
+    const commandHandlers = {
+        edit: () => {
+            if (activeTab === "loops" && selected) {
+                setCloneMode(false);
+                setEditTarget(selected);
+                if (selected.taskId) {
+                    const task = tasks.find((t) => t.id === selected.taskId);
+                    setPendingTaskSelection(task ? { id: task.id, name: task.name } : null);
+                }
+                else {
+                    setPendingTaskSelection(null);
+                }
+                push("create");
+            }
+            else if (activeTab === "tasks" && selectedTask) {
+                setEditTask(selectedTask);
+                push("task-edit");
+            }
+            else if (activeTab === "projects" && selectedProjectEntity && !selectedProjectEntity.isSystem) {
+                setEditProject(selectedProjectEntity);
+                push("project-edit");
+            }
+        },
+        clone: () => {
+            if (activeTab === "loops" && selected) {
+                setCloneMode(true);
+                setEditTarget(selected);
+                push("create");
+            }
+        },
+        delete: () => {
+            if (activeTab === "loops" && selected) {
+                setConfirmState({
+                    prompt: t("confirm.deleteLoop", { name: selected.description || selected.id }),
+                    onConfirm: () => { void loopService.delete(selected.id).then(() => { void refresh(); }); },
+                });
+            }
+            else if (activeTab === "tasks" && selectedTask) {
+                setConfirmState({
+                    prompt: t("confirm.deleteTask", { id: selectedTask.id }),
+                    onConfirm: () => { void taskService.delete(selectedTask.id).then(() => { void refreshTasks(); }); },
+                });
+            }
+            else if (activeTab === "projects" && selectedProjectEntity && !selectedProjectEntity.isSystem) {
+                setConfirmState({
+                    prompt: t("confirm.deleteProject", { name: selectedProjectEntity.name }),
+                    onConfirm: async () => {
+                        try {
+                            await projectService.delete(selectedProjectEntity.id);
+                            pushToast("success", t("project.toastDeleted", { name: selectedProjectEntity.name }));
+                            setProjectSelectedIndex(0);
+                            void refreshProjects();
+                        }
+                        catch (e) {
+                            pushToast("error", e.message);
+                        }
+                    },
+                });
+            }
+        },
+        pause: () => {
+            if (activeTab === "loops" && selected) {
+                void runAction(t("board.toastPaused", { desc: selected.description }), () => loopService.pause(selected.id))();
+            }
+        },
+        play: () => {
+            if (activeTab === "loops" && selected) {
+                const isPaused = selected.status === "paused";
+                const toastKey = isPaused ? "board.toastResumed" : "board.toastPlayed";
+                const fn = isPaused ? () => loopService.resume(selected.id) : () => loopService.play(selected.id);
+                void runAction(t(toastKey, { desc: selected.description }), fn)();
+            }
+        },
+        stop: () => {
+            if (activeTab === "loops" && selected) {
+                setConfirmState({
+                    prompt: t("confirm.stopLoop", { name: selected.description || selected.id }),
+                    onConfirm: () => { void loopService.stop(selected.id).then(() => { void refresh(); }); },
+                });
+            }
+        },
+        trigger: () => {
+            if (activeTab === "loops" && selected) {
+                void runAction(t("board.toastTriggered", { desc: selected.description }), () => loopService.trigger(selected.id))();
+            }
+        },
+        "new-loop": () => { setEditTarget(null); push("create"); },
+        "new-task": () => { setEditTask(null); push("task-create"); },
+        "new-project": () => { setEditProject(null); setActiveTab("projects"); push("project-create"); },
+        "project-filter-loops": () => { setProjectFilters((prev) => ({ ...prev, hasLoops: cycleProjectHasLoopsFilter(prev.hasLoops) })); },
+        "project-filter-type": () => { setProjectFilters((prev) => ({ ...prev, isSystem: cycleProjectIsSystemFilter(prev.isSystem) })); },
+        "project-sort": () => { setProjectFilters((prev) => ({ ...prev, sort: cycleProjectSortMode(prev.sort) })); },
+        "all-commands": () => { setCommandsBrowserOpen(true); },
+        help: () => { setCommandsBrowserOpen(true); },
+        search: () => { setSearchValue(""); setSearchState({ active: true }); },
+        "filter-status": () => { setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) })); },
+        sort: () => { setSort((prev) => cycleSortMode(prev)); },
+        "filter-project": () => {
+            const ids = ["all", ...projects.map((p) => p.id)];
+            const idx = ids.indexOf(currentProjectId);
+            const nextId = ids[(idx + 1) % ids.length] ?? "all";
+            setCurrentProjectId(nextId);
+        },
+        debug: () => { setDebugMode((prev) => !prev); },
+        logs: () => {
+            if (activeTab === "loops" && selected) {
+                const runs = selected.runHistory;
+                if (runs && runs.length > 0) {
+                    handleOpenRunLog(runs[runs.length - 1]);
+                }
+            }
+        },
+        select: () => {
+            if (selectedTask) {
+                setPendingTaskSelection({ id: selectedTask.id, name: selectedTask.name });
+                pop();
+            }
+        },
+        api: () => {
+            const port = process.env.LOOP_CLI_HTTP_PORT ?? "8845";
+            const baseUrl = `http://127.0.0.1:${port}`;
+            pushToast("info", `API: ${baseUrl} | Swagger: ${baseUrl}/api/docs | OpenAPI: ${baseUrl}/api/openapi.json`);
+        },
+        status: () => { pushToast("info", `Command "status" coming soon`); },
+        export: () => {
+            exportService.exportConfig()
+                .then(({ json, filePath }) => setExportModal({ json, filePath, error: null }))
+                .catch((e) => setExportModal({ json: "", filePath: null, error: e instanceof Error ? e.message : String(e) }));
+        },
+        import: () => { pushToast("info", `Command "import" coming soon`); },
+    };
+    function handleCommand(value) {
+        const handler = commandHandlers[value];
+        if (handler) {
+            handler();
+        }
+        else {
+            pushToast("error", `Unknown command: ${value}`);
+        }
+    }
+    return { handlers: commandHandlers, handleCommand };
+}

package/dist/features/commands/useContextualActions.js

@@ -0,0 +1,75 @@
+import { useCallback } from "react";
+import { copyToClipboard } from "../../shared/clipboard.js";
+import { commandLine } from "../../shared/ui/format.js";
+import { t } from "../../shared/i18n/index.js";
+export function useContextualActions(context) {
+    const { activeTab, focusedPanel, selected, selectedTask, selectedProjectEntity, tasks, push, setCloneMode, setEditTarget, setPendingTaskSelection, handleCommand, handleOpenRunLog, pushToast, isBoardView, view, logModalRun, commandsBrowserOpen, confirmState, searchState, setChordState, chordState, } = context;
+    const handleContextualCopy = useCallback(() => {
+        const copyHandlers = {
+            loops: () => {
+                if (!selected)
+                    return;
+                const text = selected.commandRaw
+                    ? selected.commandRaw.split("\n").map((l) => l.trim()).filter(Boolean).join(" ")
+                    : commandLine(selected.command, selected.commandArgs);
+                copyToClipboard(text);
+                pushToast("info", t("board.toastTextCopied"));
+            },
+            tasks: () => {
+                if (!selectedTask)
+                    return;
+                const text = selectedTask.commandRaw
+                    ? selectedTask.commandRaw.split("\n").map((l) => l.trim()).filter(Boolean).join(" ")
+                    : commandLine(selectedTask.command, selectedTask.commandArgs);
+                copyToClipboard(text);
+                pushToast("info", t("board.toastTextCopied"));
+            },
+            projects: () => {
+                if (!selectedProjectEntity)
+                    return;
+                copyToClipboard(selectedProjectEntity.name);
+                pushToast("info", t("board.toastTextCopied"));
+            },
+        };
+        const handler = copyHandlers[activeTab];
+        if (handler)
+            handler();
+    }, [activeTab, selected, selectedTask, selectedProjectEntity, pushToast]);
+    const triggerContextualAction = useCallback(() => {
+        if (!isBoardView(view) || logModalRun || commandsBrowserOpen || confirmState || searchState?.active)
+            return;
+        if (chordState)
+            setChordState(null);
+        const editSelectedLoop = () => {
+            if (!selected)
+                return;
+            setCloneMode(false);
+            setEditTarget(selected);
+            const task = selected.taskId ? tasks.find((t) => t.id === selected.taskId) : null;
+            setPendingTaskSelection(task ? { id: task.id, name: task.name } : null);
+            push("create");
+        };
+        const handlers = {
+            "tasks:": () => { if (selectedTask)
+                handleCommand("edit"); },
+            "projects:": () => { if (selectedProjectEntity)
+                handleCommand("edit"); },
+            "loops:right": () => {
+                if (!selected)
+                    return;
+                const runs = selected.runHistory;
+                if (runs && runs.length > 0)
+                    handleOpenRunLog(runs[runs.length - 1]);
+                else
+                    editSelectedLoop();
+            },
+            "loops:left": editSelectedLoop,
+        };
+        const handlerKey = activeTab !== "loops" ? `${activeTab}:` : `loops:${focusedPanel}`;
+        handlers[handlerKey]?.();
+    }, [activeTab, focusedPanel, view, logModalRun, commandsBrowserOpen, confirmState, searchState,
+        chordState, setChordState, selected, selectedTask, selectedProjectEntity, tasks, push,
+        setCloneMode, setEditTarget, setPendingTaskSelection, handleCommand, handleOpenRunLog,
+        isBoardView]);
+    return { handleContextualCopy, triggerContextualAction };
+}

package/dist/features/commands/useGlobalShortcuts.js

@@ -0,0 +1,152 @@
+import { useInput } from "ink";
+import { MAX_ENTRIES } from "../../shared/ui/DebugPanel.js";
+const FORM_VIEWS = ["create", "task-create", "task-edit", "project-create", "project-edit"];
+function isBoardView(view) {
+    return view === "board";
+}
+export function useGlobalShortcuts(context) {
+    const { activeTab, focusedPanel, setFocusedPanel, setActiveTab, view, handleCommand, triggerContextualAction, popLayer, anyModalOpen, debugMode, setDebugEntries, inputOwner, confirmState, searchState, logModalRun, commandsBrowserOpen, exportModal, contextHelpOpen, setContextHelpOpen, onQuit, exit, setConfirmState, setLogModalRun, setLogModalLoopId, setCommandsBrowserOpen, chordState, setChordState, } = context;
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            if (!logModalRun && !confirmState && !commandsBrowserOpen && !exportModal) {
+                setConfirmState({
+                    prompt: "",
+                    onConfirm: () => { onQuit(); exit(); },
+                });
+                return;
+            }
+        }
+        if (debugMode) {
+            const entry = {
+                id: Date.now(),
+                input,
+                len: input.length,
+                ctrl: key.ctrl,
+                return: key.return,
+                shift: key.shift,
+                meta: key.meta,
+                tab: key.tab,
+                upArrow: key.upArrow,
+                downArrow: key.downArrow,
+                leftArrow: key.leftArrow,
+                rightArrow: key.rightArrow,
+                escape: key.escape,
+                codes: Array.from(input).map((c) => c.charCodeAt(0)).join(","),
+            };
+            setDebugEntries((prev) => [entry, ...prev].slice(0, MAX_ENTRIES));
+        }
+        const isMultiCharEnter = input.length > 1 && (input.includes("\r") || input.includes("\n"));
+        const isCtrlEnter = (key.ctrl && key.return) || input === "\x0e" || isMultiCharEnter;
+        if (isCtrlEnter && isBoardView(view) && !logModalRun && !commandsBrowserOpen && !confirmState && !searchState?.active) {
+            triggerContextualAction();
+            return;
+        }
+        const canShortcut = key.ctrl && isBoardView(view) && !logModalRun && !commandsBrowserOpen && !confirmState && !searchState?.active && !exportModal;
+        if (canShortcut) {
+            const globalShortcuts = {
+                p: () => { setCommandsBrowserOpen(true); },
+                b: () => handleCommand("debug"),
+                g: () => handleCommand("api"),
+                x: () => handleCommand("export"),
+                i: () => handleCommand("import"),
+                y: () => handleCommand("status"),
+            };
+            const filterShortcuts = {
+                s: () => handleCommand("search"),
+                t: () => handleCommand("filter-status"),
+                o: () => handleCommand("sort"),
+                p: () => handleCommand("filter-project"),
+            };
+            const actionShortcuts = {
+                n: () => handleCommand(activeTab === "loops" ? "new-loop" : activeTab === "tasks" ? "new-task" : "new-project"),
+                e: () => handleCommand("edit"),
+                d: () => handleCommand("delete"),
+                ...(activeTab === "loops" ? {
+                    p: () => handleCommand("pause"),
+                    r: () => handleCommand("play"),
+                    s: () => handleCommand("stop"),
+                    t: () => handleCommand("trigger"),
+                    c: () => handleCommand("clone"),
+                    o: () => handleCommand("logs"),
+                } : {}),
+            };
+            if (chordState === "ctrl+f" && filterShortcuts[input]) {
+                filterShortcuts[input]();
+                setChordState(null);
+                return;
+            }
+            if (chordState === "ctrl+a" && actionShortcuts[input]) {
+                actionShortcuts[input]();
+                setChordState(null);
+                return;
+            }
+            if (chordState) {
+                setChordState(null);
+            }
+            if (input === "f") {
+                setChordState("ctrl+f");
+                return;
+            }
+            if (input === "a") {
+                setChordState("ctrl+a");
+                return;
+            }
+            const globalHandler = globalShortcuts[input];
+            if (globalHandler) {
+                globalHandler();
+                return;
+            }
+        }
+        if (confirmState && !key.escape)
+            return;
+        if (searchState?.active && !key.escape)
+            return;
+        if (key.escape) {
+            popLayer();
+            return;
+        }
+        if (logModalRun) {
+            if (input === "q") {
+                setLogModalRun(null);
+                setLogModalLoopId(null);
+            }
+            return;
+        }
+        if (commandsBrowserOpen)
+            return;
+        if (contextHelpOpen) {
+            setContextHelpOpen(false);
+            return;
+        }
+        if (logModalRun)
+            return;
+        if (FORM_VIEWS.includes(view))
+            return;
+        if (isBoardView(view)) {
+            if (key.ctrl && key.rightArrow) {
+                setActiveTab((prev) => prev === "loops" ? "tasks" : prev === "tasks" ? "projects" : "loops");
+                return;
+            }
+            if (key.ctrl && key.leftArrow) {
+                setActiveTab((prev) => prev === "loops" ? "projects" : prev === "tasks" ? "loops" : "tasks");
+                return;
+            }
+            if (key.tab) {
+                setFocusedPanel((prev) => prev === "left" ? "right" : "left");
+                return;
+            }
+            if (input === "1") {
+                setActiveTab("loops");
+                return;
+            }
+            if (input === "2") {
+                setActiveTab("tasks");
+                return;
+            }
+            if (input === "3") {
+                setActiveTab("projects");
+                return;
+            }
+        }
+    });
+}

package/dist/features/forms/FormRouter.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CreateView } from "../../widgets/loop-form/CreateForm.js";
+import { TaskForm } from "../../widgets/task-form/TaskForm.js";
+import { ProjectFormView } from "../../widgets/project-form/ProjectForm.js";
+const TASK_FORM_VIEWS = new Set(["task-create", "task-edit"]);
+function createInitialValues(editTarget, currentProjectId) {
+    if (!editTarget) {
+        return {
+            interval: "30m",
+            taskMode: "inline",
+            command: "",
+            cwd: process.cwd(),
+            taskId: "",
+            description: "",
+            runNow: "y",
+            maxRuns: "",
+            project: currentProjectId,
+        };
+    }
+    return {
+        interval: editTarget.intervalHuman ?? "30m",
+        taskMode: editTarget.taskId ? "existing" : "inline",
+        command: editTarget.commandRaw ?? [editTarget.command, ...editTarget.commandArgs].join(" "),
+        cwd: editTarget.cwd ?? "",
+        taskId: editTarget.taskId ?? "",
+        description: editTarget.description,
+        runNow: "y",
+        maxRuns: editTarget.maxRuns?.toString() ?? "",
+        project: editTarget.projectId ?? "default",
+    };
+}
+export function FormRouter(props) {
+    const { view, editTarget, cloneMode, editTask, editProject, pendingTaskSelection, tasks, projects, currentProjectId, cancelCreate, onCreateDone, handleChooseTask, cancelTask, onTaskDone, cancelProject, onProjectDone } = props;
+    if (view === "create") {
+        return (_jsx(CreateView, { mode: editTarget && !cloneMode ? "edit" : "create", editId: editTarget && !cloneMode ? editTarget.id : null, initial: createInitialValues(editTarget, currentProjectId), selectedTaskId: pendingTaskSelection?.id ?? null, selectedTaskName: pendingTaskSelection?.name ?? null, tasks: tasks, projects: projects, currentProjectId: currentProjectId, onCancel: cancelCreate, onDone: onCreateDone, onChooseTask: handleChooseTask }));
+    }
+    if (TASK_FORM_VIEWS.has(view)) {
+        return (_jsx(TaskForm, { mode: view === "task-edit" ? "edit" : "create", editTask: editTask, onCancel: cancelTask, onDone: onTaskDone }));
+    }
+    if (view === "project-create" || view === "project-edit") {
+        return (_jsx(ProjectFormView, { mode: view === "project-edit" ? "edit" : "create", editProject: view === "project-edit" ? editProject : null, onCancel: cancelProject, onDone: onProjectDone }));
+    }
+    return null;
+}

package/dist/{tui/components → features/overlays}/ContextHelpModal.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { darkTheme as theme } from "../theme.js";
-import { Modal } from "./Modal.js";
-import { t } from "../../i18n/index.js";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { Modal } from "../../shared/ui/Modal.js";
+import { t } from "../../shared/i18n/index.js";
 export function ContextHelpModal(props) {
     return (_jsxs(Modal, { title: t("context.helpTitle"), onClose: props.onClose, width: 64, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.text.primary, children: t("context.helpRules") }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.accent.brand, children: t("context.helpTemplates") }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.semantic.warning, children: t("context.helpCaveat") }) }), _jsx(Box, { children: _jsx(Text, { color: theme.text.secondary, children: t("context.helpJqTip") }) })] }));
 }

package/dist/{tui/components → features/overlays}/ExportModal.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useState } from "react";
 import { Box, Text, useInput } from "ink";
-import { darkTheme as theme } from "../theme.js";
-import { t } from "../../i18n/index.js";
-import { EXPORT_MAX_PREVIEW_LINES } from "../../config/constants.js";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { t } from "../../shared/i18n/index.js";
+import { EXPORT_MAX_PREVIEW_LINES } from "../../shared/config/constants.js";
 import { copyToClipboard } from "../../shared/clipboard.js";
 const VISIBLE_LINES = 20;
 export function ExportModal(props) {

package/dist/{tui/components → features/overlays}/HelpGuideModal.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useInput } from "ink";
-import { darkTheme as theme } from "../theme.js";
-import { Modal } from "./Modal.js";
-import { t } from "../../i18n/index.js";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { Modal } from "../../shared/ui/Modal.js";
+import { t } from "../../shared/i18n/index.js";
 export function HelpGuideModal(props) {
     useInput((_input, key) => {
         if (key.escape || _input === "q") {

package/dist/{tui/components → features/overlays}/HelpModal.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { darkTheme as theme } from "../theme.js";
-import { Modal } from "./Modal.js";
-import { t } from "../../i18n/index.js";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { Modal } from "../../shared/ui/Modal.js";
+import { t } from "../../shared/i18n/index.js";
 function helpEntries(view) {
     switch (view) {
         case "board":

package/dist/features/overlays/OverlayStack.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { LogModal } from "../../widgets/log-modal/LogModal.js";
+import { CommandsBrowserModal } from "../../widgets/commands-browser/CommandsBrowserModal.js";
+import { ContextHelpModal } from "./ContextHelpModal.js";
+import { ExportModal } from "./ExportModal.js";
+import { ToastStack } from "../../shared/ui/Toast.js";
+export function OverlayStack(props) {
+    return (_jsxs(_Fragment, { children: [props.commandsBrowserOpen ? (_jsx(CommandsBrowserModal, { context: props.commandContext, onClose: props.onCommandsBrowserClose, onExecute: props.onCommandsBrowserExecute })) : null, props.contextHelpOpen ? _jsx(ContextHelpModal, { onClose: props.onContextHelpClose }) : null, props.exportModal ? (_jsx(ExportModal, { json: props.exportModal.json, filePath: props.exportModal.filePath, error: props.exportModal.error, onClose: props.onExportModalClose, onCopy: props.onExportCopy })) : null, props.logModalRun ? (_jsx(LogModal, { loopId: props.logModalLoopId, run: props.logModalRun, logLines: props.logModalLines, loading: props.logModalLoading, onClose: props.onLogModalClose, onCopy: props.onLogCopy })) : null, _jsx(ToastStack, { toasts: props.toasts })] }));
+}

package/dist/{tui/components → features/overlays}/ProjectsModal.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from "react";
 import { Box, Text, useInput } from "ink";
-import { darkTheme as theme } from "../theme.js";
-import { t } from "../../i18n/index.js";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { t } from "../../shared/i18n/index.js";
 export function ProjectsModal(props) {
     const { projects, loops, currentProjectId, onSelect, onClose } = props;
     const [selectedIndex, setSelectedIndex] = React.useState(() => {

package/dist/{tui/components → features/overlays}/TaskPickerModal.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useMemo, useCallback } from "react";
 import { Box, Text, useInput } from "ink";
-import { darkTheme as theme } from "../theme.js";
-import { t } from "../../i18n/index.js";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { t } from "../../shared/i18n/index.js";
 const MAX_VISIBLE = 10;
 export function TaskPickerModal(props) {
     const [query, setQuery] = useState("");

package/dist/{tui/components → features/overlays}/WelcomeScreen.js

@@ -1,8 +1,9 @@
 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 { darkTheme as theme } from "../../shared/ui/theme.js";
+import { useInject } from "../../shared/hooks/useInject.js";
+import { TYPES } from "../../shared/services/types.js";
 import { parseDuration } from "../../duration.js";
 const EXAMPLES = [
     { label: "Run tests every 30m", interval: "30m", command: "npm", args: ["test"] },
@@ -10,6 +11,7 @@ const EXAMPLES = [
     { label: "Sync deps every hour", interval: "1h", command: "npm", args: ["outdated"] },
 ];
 export function WelcomeScreen(props) {
+    const loopService = useInject(TYPES.LoopService);
     const [selectedIndex, setSelectedIndex] = React.useState(0);
     const [creating, setCreating] = React.useState(null);
     const items = [...EXAMPLES.map((e) => e.label), "Create empty loop"];
@@ -45,7 +47,7 @@ export function WelcomeScreen(props) {
                     projectId: "default",
                     offset: null,
                 };
-                createLoop(options, example.interval)
+                loopService.create(options, example.interval)
                     .then(() => props.onRefresh())
                     .then(() => props.onCreateLoop())
                     .catch(() => setCreating(null));

package/dist/features/overlays/useOverlayStack.js

@@ -0,0 +1,51 @@
+import { useMemo } from "react";
+import { t } from "../../shared/i18n/index.js";
+import { resolveInputOwner } from "../../shared/ui/state.js";
+export function useOverlayStack(context) {
+    const { confirmState, setConfirmState, searchState, setSearchState, setSearchValue, logModalRun, setLogModalRun, logModalLoopId, setLogModalLoopId, commandsBrowserOpen, setCommandsBrowserOpen, exportModal, setExportModal, contextHelpOpen, setContextHelpOpen, view, pop, onQuit, exit, commandBarHasText, commandBarDropdownOpen, } = context;
+    const popLayer = () => {
+        if (confirmState) {
+            setConfirmState(null);
+            return true;
+        }
+        if (searchState?.active) {
+            setSearchState(null);
+            setSearchValue("");
+            return true;
+        }
+        if (logModalRun) {
+            setLogModalRun(null);
+            setLogModalLoopId(null);
+            return true;
+        }
+        if (commandsBrowserOpen) {
+            setCommandsBrowserOpen(false);
+            return true;
+        }
+        if (exportModal) {
+            setExportModal(null);
+            return true;
+        }
+        if (contextHelpOpen) {
+            setContextHelpOpen(false);
+            return true;
+        }
+        if (view !== "board") {
+            pop();
+            return true;
+        }
+        setConfirmState({
+            prompt: t("confirm.quit"),
+            onConfirm: () => { onQuit(); exit(); },
+        });
+        return true;
+    };
+    const anyModalOpen = !!(logModalRun || commandsBrowserOpen || exportModal);
+    const commandInputDisabled = anyModalOpen;
+    const inputOwner = useMemo(() => resolveInputOwner({
+        modalOpen: !!(logModalRun || commandsBrowserOpen || exportModal || contextHelpOpen || confirmState || searchState?.active),
+        commandBarHasText,
+        commandBarDropdownOpen,
+    }), [logModalRun, commandsBrowserOpen, exportModal, contextHelpOpen, confirmState, searchState?.active, commandBarHasText, commandBarDropdownOpen]);
+    return { popLayer, anyModalOpen, commandInputDisabled, inputOwner };
+}