@plainconceptsplatform/loop-task 2.6.0

package/dist/shared/i18n/index.js

@@ -0,0 +1,11 @@
+import en from "./en.json" with { type: "json" };
+const messages = en;
+export function t(key, params) {
+    let result = messages[key] ?? key;
+    if (params) {
+        for (const name of Object.keys(params)) {
+            result = result.split(`{${name}}`).join(String(params[name]));
+        }
+    }
+    return result;
+}

package/dist/shared/providers/InversifyProvider.js

@@ -0,0 +1,6 @@
+import React, { createContext } from "react";
+import { container } from "../container/index.js";
+export const InversifyContext = createContext({ container });
+export function InversifyProvider(props) {
+    return React.createElement(InversifyContext.Provider, { value: { container } }, props.children);
+}

package/dist/shared/services/export-service.js

@@ -0,0 +1,43 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from "inversify";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getDataDir } from "../config/paths.js";
+let IpcExportService = class IpcExportService {
+    constructor(loopService, taskService, projectService) {
+        this.loopService = loopService;
+        this.taskService = taskService;
+        this.projectService = projectService;
+    }
+    async exportConfig() {
+        const [loops, tasks, projects] = await Promise.all([
+            this.loopService.list().catch(() => []),
+            this.taskService.list().catch(() => []),
+            this.projectService.list().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 };
+    }
+};
+IpcExportService = __decorate([
+    injectable()
+], IpcExportService);
+export { IpcExportService };

package/dist/shared/services/log-service.js

@@ -0,0 +1,28 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from "inversify";
+import { sendRequest, streamRequest } from "../../client/ipc.js";
+import { LOG_TAIL_DEFAULT } from "../config/constants.js";
+let IpcLogService = class IpcLogService {
+    async 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 ?? "";
+    }
+    streamRunLog(id, runNumber, onLine, onEnd, onError) {
+        return streamRequest({ type: "run-log-stream", payload: { id, runNumber } }, onLine, onEnd, onError);
+    }
+    streamLogs(id, onLine, onError) {
+        return streamRequest({ type: "logs", payload: { id, follow: true, tail: LOG_TAIL_DEFAULT } }, onLine, () => { }, onError);
+    }
+};
+IpcLogService = __decorate([
+    injectable()
+], IpcLogService);
+export { IpcLogService };

package/dist/shared/services/loop-service.js

@@ -0,0 +1,78 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from "inversify";
+import { sendRequest } from "../../client/ipc.js";
+import { t } from "../i18n/index.js";
+let IpcLoopService = class IpcLoopService {
+    async list() {
+        const response = await sendRequest({ type: "list" });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        return response.data;
+    }
+    async create(options, intervalHuman) {
+        const response = await sendRequest({
+            type: "start",
+            payload: { ...options, intervalHuman },
+        });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        return response.data.id;
+    }
+    async update(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;
+    }
+    async pause(id) {
+        const response = await sendRequest({ type: "pause", payload: { id } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? t("errors.pauseFailed"));
+        }
+    }
+    async resume(id) {
+        const response = await sendRequest({ type: "resume", payload: { id } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? t("errors.resumeFailed"));
+        }
+    }
+    async stop(id) {
+        const response = await sendRequest({ type: "stop-loop", payload: { id } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Stop failed");
+        }
+    }
+    async play(id) {
+        const response = await sendRequest({ type: "play-loop", payload: { id } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Play failed");
+        }
+    }
+    async trigger(id) {
+        const response = await sendRequest({ type: "trigger", payload: { id } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? t("errors.forceRunFailed"));
+        }
+    }
+    async delete(id) {
+        const response = await sendRequest({ type: "delete", payload: { id } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? t("errors.deleteFailed"));
+        }
+    }
+};
+IpcLoopService = __decorate([
+    injectable()
+], IpcLoopService);
+export { IpcLoopService };

package/dist/shared/services/project-service.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from "inversify";
+import { sendRequest } from "../../client/ipc.js";
+import { t } from "../i18n/index.js";
+let IpcProjectService = class IpcProjectService {
+    async list() {
+        const response = await sendRequest({ type: "project-list" });
+        if (response.type !== "ok")
+            throw new Error(response.message);
+        return response.data;
+    }
+    async create(name, color, directory, githubSource) {
+        const response = await sendRequest({ type: "project-create", payload: { name, color, directory, githubSource } });
+        if (response.type !== "ok")
+            throw new Error(response.message);
+        return response.data;
+    }
+    async update(id, name, color, directory, githubSource) {
+        const response = await sendRequest({ type: "project-update", payload: { id, name, color, directory, githubSource } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? t("project.error.updateFailed"));
+        }
+    }
+    async delete(id) {
+        const response = await sendRequest({ type: "project-delete", payload: { id } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? t("project.error.deleteFailed"));
+        }
+    }
+};
+IpcProjectService = __decorate([
+    injectable()
+], IpcProjectService);
+export { IpcProjectService };

package/dist/shared/services/settings-service.js

@@ -0,0 +1,102 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from "inversify";
+import { sendRequest } from "../../client/ipc.js";
+let IpcSettingsService = class IpcSettingsService {
+    async getSettings() {
+        const response = await sendRequest({ type: "settings-get" });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Failed to get settings");
+        }
+        return response.data;
+    }
+    async getHttpApiEnabled() {
+        const response = await sendRequest({ type: "settings-get" });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Failed to get settings");
+        }
+        return response.data.httpApiEnabled;
+    }
+    async setHttpApiEnabled(enabled) {
+        const response = await sendRequest({ type: "settings-set", settings: { httpApiEnabled: enabled } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Failed to set settings");
+        }
+        return response.data;
+    }
+    async getMcpApiEnabled() {
+        const response = await sendRequest({ type: "settings-get" });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Failed to get settings");
+        }
+        return response.data.mcpApiEnabled;
+    }
+    async setMcpApiEnabled(enabled) {
+        const response = await sendRequest({ type: "settings-set", settings: { mcpApiEnabled: enabled } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Failed to set settings");
+        }
+        return response.data;
+    }
+    async getTelemetryEnabled() {
+        const response = await sendRequest({ type: "settings-get" });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Failed to get settings");
+        }
+        return response.data.telemetryEnabled;
+    }
+    async setTelemetryEnabled(enabled) {
+        const response = await sendRequest({ type: "settings-set", settings: { telemetryEnabled: enabled } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Failed to set settings");
+        }
+        return response.data;
+    }
+    async getTelemetrySettings() {
+        const response = await sendRequest({ type: "settings-get" });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Failed to get settings");
+        }
+        const s = response.data;
+        return {
+            enabled: s.telemetryEnabled,
+            endpoint: s.telemetryEndpoint,
+            protocol: s.telemetryProtocol,
+            autoInstrumentAgents: s.telemetryAutoInstrumentAgents,
+            captureContent: s.telemetryCaptureContent,
+            captureCommandOutput: s.telemetryCaptureCommandOutput,
+            serviceName: s.telemetryServiceName,
+        };
+    }
+    async setTelemetrySettings(settings) {
+        const mapping = {
+            enabled: "telemetryEnabled",
+            endpoint: "telemetryEndpoint",
+            protocol: "telemetryProtocol",
+            autoInstrumentAgents: "telemetryAutoInstrumentAgents",
+            captureContent: "telemetryCaptureContent",
+            captureCommandOutput: "telemetryCaptureCommandOutput",
+            serviceName: "telemetryServiceName",
+        };
+        const daemonSettings = {};
+        for (const [key, value] of Object.entries(settings)) {
+            const daemonKey = mapping[key];
+            if (daemonKey) {
+                daemonSettings[daemonKey] = value;
+            }
+        }
+        const response = await sendRequest({ type: "settings-set", settings: daemonSettings });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Failed to set settings");
+        }
+        return response.data;
+    }
+};
+IpcSettingsService = __decorate([
+    injectable()
+], IpcSettingsService);
+export { IpcSettingsService };

package/dist/shared/services/task-service.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from "inversify";
+import { sendRequest } from "../../client/ipc.js";
+let IpcTaskService = class IpcTaskService {
+    async list() {
+        const response = await sendRequest({ type: "task-list" });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        return response.data;
+    }
+    async create(payload) {
+        const response = await sendRequest({ type: "task-create", payload });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        return response.data;
+    }
+    async update(id, payload) {
+        const response = await sendRequest({ type: "task-update", payload: { id, ...payload } });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        return response.data;
+    }
+    async delete(id) {
+        const response = await sendRequest({ type: "task-delete", payload: { id } });
+        if (response.type !== "ok") {
+            throw new Error(response.message ?? "Task delete failed");
+        }
+    }
+};
+IpcTaskService = __decorate([
+    injectable()
+], IpcTaskService);
+export { IpcTaskService };

package/dist/shared/services/types.js

@@ -0,0 +1,8 @@
+export const TYPES = {
+    LoopService: Symbol.for("LoopService"),
+    TaskService: Symbol.for("TaskService"),
+    ProjectService: Symbol.for("ProjectService"),
+    LogService: Symbol.for("LogService"),
+    ExportService: Symbol.for("ExportService"),
+    SettingsService: Symbol.for("SettingsService"),
+};

package/dist/shared/sleep.js

@@ -0,0 +1,17 @@
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/shared/tail.js

@@ -0,0 +1,4 @@
+export function tail(content, count) {
+    const lines = content.split("\n");
+    return count > 0 ? lines.slice(-count) : lines;
+}

package/dist/shared/ui/Button.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { darkTheme as theme } from "./theme.js";
+export function Button(props) {
+    const { label, focused, variant = "default" } = props;
+    const bgColor = focused
+        ? variant === "danger"
+            ? theme.semantic.danger
+            : theme.bg.active
+        : undefined;
+    const fgColor = focused
+        ? theme.text.inverse
+        : variant === "danger"
+            ? theme.semantic.danger
+            : theme.text.primary;
+    const indicator = focused ? "› " : "  ";
+    return (_jsx(Box, { backgroundColor: bgColor, paddingX: 1, marginRight: 1, flexShrink: 0, children: _jsx(Text, { color: fgColor, bold: true, children: indicator + label }) }));
+}

package/dist/shared/ui/DebugPanel.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { darkTheme as theme } from "./theme.js";
+const MAX_ENTRIES = 12;
+export function DebugPanel(props) {
+    const panelWidth = props.breakpoint === "wide" || props.breakpoint === undefined ? "22%" : "100%";
+    return (_jsxs(Box, { flexDirection: "column", width: panelWidth, flexShrink: 0, borderStyle: "single", borderColor: theme.semantic.warning, backgroundColor: theme.bg.surface, children: [_jsx(Box, { paddingLeft: 1, children: _jsx(Text, { color: theme.semantic.warning, bold: true, children: "DEBUG" }) }), _jsx(Box, { paddingLeft: 1, flexDirection: "column", children: props.entries.length === 0 ? (_jsx(Text, { color: theme.text.muted, children: "press keys..." })) : (props.entries.map((e) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: theme.text.primary, children: ["len=", e.len, " codes=[", e.codes, "]"] }), _jsxs(Text, { color: theme.text.muted, children: ["c=", e.ctrl ? 1 : 0, " r=", e.return ? 1 : 0, " t=", e.tab ? 1 : 0, " e=", e.escape ? 1 : 0] })] }, e.id)))) })] }));
+}
+export { MAX_ENTRIES };

package/dist/shared/ui/FocusableButton.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useFocus, useInput } from "ink";
+import { darkTheme as theme } from "./theme.js";
+export function FocusableButton(props) {
+    const { label, color, onPress, variant = "default" } = props;
+    const { isFocused } = useFocus();
+    useInput((_input, key) => {
+        if (_input.includes("[<"))
+            return;
+        if (key.return) {
+            onPress?.();
+        }
+    }, { isActive: isFocused });
+    const accent = variant === "danger" ? theme.semantic.danger : color;
+    const textColor = isFocused ? theme.text.inverse : accent;
+    const indicator = isFocused ? "› " : "  ";
+    return (_jsx(Box, { backgroundColor: isFocused ? theme.bg.active : undefined, paddingX: 1, marginRight: 1, flexShrink: 0, children: _jsx(Text, { color: textColor, bold: true, children: indicator + label }) }));
+}

package/dist/shared/ui/FocusableInput.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text, useFocus, useInput } from "ink";
+import { darkTheme as theme } from "./theme.js";
+import { sanitizePaste } from "../utils/paste.js";
+export function FocusableInput(props) {
+    const { value, onChange, onSubmit } = props;
+    const placeholder = props.placeholder ?? "type here...";
+    const { isFocused } = useFocus();
+    const [cursorOffset, setCursorOffset] = useState(value.length);
+    const insertText = useCallback((text) => {
+        const before = value.slice(0, cursorOffset);
+        const after = value.slice(cursorOffset);
+        const next = before + text + after;
+        onChange(next);
+        setCursorOffset(before.length + text.length);
+    }, [value, cursorOffset, onChange]);
+    useInput((input, key) => {
+        // Bracketed paste: content wrapped in ESC[200~ ... ESC[201~
+        if (input.includes("\x1b[200~")) {
+            insertText(sanitizePaste(input));
+            return;
+        }
+        // Swallow SGR mouse sequences
+        if (input.includes("[<"))
+            return;
+        if (key.ctrl || key.escape)
+            return;
+        // Multi-char containing CR/LF with no bracketed markers  ignore
+        if (input.length > 1 && (input.includes("\r") || input.includes("\n")))
+            return;
+        if (key.return) {
+            onSubmit?.(value);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (cursorOffset > 0) {
+                const next = value.slice(0, cursorOffset - 1) + value.slice(cursorOffset);
+                onChange(next);
+                setCursorOffset((c) => c - 1);
+            }
+            return;
+        }
+        if (key.leftArrow) {
+            if (cursorOffset > 0)
+                setCursorOffset((c) => c - 1);
+            return;
+        }
+        if (key.rightArrow) {
+            if (cursorOffset < value.length)
+                setCursorOffset((c) => c + 1);
+            return;
+        }
+        // Multi-char printable input = unbracketed single-line paste (e.g. right-click)
+        if (input.length > 1 && !key.meta) {
+            insertText(sanitizePaste(input));
+            return;
+        }
+        // Single printable char
+        if (input.length === 1 && input >= " " && input <= "~") {
+            insertText(input);
+        }
+    }, { isActive: isFocused });
+    const borderColor = isFocused ? theme.accent.brand : theme.border.dim;
+    const backgroundColor = isFocused ? theme.bg.input : undefined;
+    const showPlaceholder = value.length === 0;
+    // Render value with cursor
+    const before = value.slice(0, cursorOffset);
+    const cursorChar = cursorOffset < value.length ? value[cursorOffset] : " ";
+    const after = cursorOffset < value.length ? value.slice(cursorOffset + 1) : "";
+    return (_jsxs(Box, { borderStyle: "single", borderColor: borderColor, backgroundColor: backgroundColor, paddingLeft: 1, overflow: "hidden", children: [showPlaceholder ? (_jsx(Text, { color: theme.text.muted, children: placeholder })) : (_jsxs(Text, { color: theme.text.primary, children: [before, _jsx(Text, { inverse: true, children: cursorChar }), after] })), isFocused && showPlaceholder ? _jsx(Text, { inverse: true, children: " " }) : null] }));
+}

package/dist/shared/ui/FocusableList.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Box, Text, useInput } from "ink";
+import { darkTheme as theme } from "./theme.js";
+export function FocusableList(props) {
+    const { items, renderItem, onSelect, onActivate, selectedIndex, isFocused, navActive = true, limit, } = props;
+    const n = items.length;
+    useInput((input, key) => {
+        if (n === 0)
+            return;
+        if (input.includes("[<"))
+            return;
+        if (key.upArrow || input === "k") {
+            const next = selectedIndex <= 0 ? n - 1 : selectedIndex - 1;
+            onSelect(next);
+            return;
+        }
+        if (key.downArrow || input === "j") {
+            const next = selectedIndex >= n - 1 ? 0 : selectedIndex + 1;
+            onSelect(next);
+            return;
+        }
+        if (key.return) {
+            onActivate(selectedIndex);
+            return;
+        }
+    }, { isActive: isFocused && navActive });
+    const { visible, localSelected } = useMemo(() => {
+        if (n === 0)
+            return { visible: [], localSelected: 0 };
+        const eff = Math.min(limit, n);
+        if (n <= eff) {
+            return { visible: items, localSelected: selectedIndex };
+        }
+        const offset = Math.floor(eff / 2);
+        const r = (((selectedIndex - offset) % n) + n) % n;
+        const rotated = [...items.slice(r), ...items.slice(0, r)];
+        return { visible: rotated.slice(0, eff), localSelected: offset };
+    }, [items, selectedIndex, limit, n]);
+    if (n === 0) {
+        throw new Error("FocusableList requires at least one item");
+    }
+    return (_jsx(Box, { flexDirection: "column", children: visible.map((item, i) => {
+            const isSelected = i === localSelected;
+            const indicator = isSelected ? "\u203a " : "  ";
+            return (_jsxs(Box, { backgroundColor: isSelected ? (isFocused && navActive ? theme.bg.active : isFocused ? theme.bg.hover : undefined) : undefined, children: [_jsx(Text, { color: isSelected ? theme.text.inverse : theme.text.primary, children: indicator }), renderItem(item, isSelected)] }, i));
+        }) }));
+}

package/dist/shared/ui/Modal.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { darkTheme as theme } from "./theme.js";
+export function Modal(props) {
+    useInput((_input, key) => {
+        if (_input.includes("[<"))
+            return;
+        if (key.escape) {
+            props.onClose();
+        }
+    });
+    return (_jsx(Box, { position: "absolute", top: 0, left: 0, width: "100%", height: "100%", justifyContent: "center", alignItems: "center", children: _jsxs(Box, { borderStyle: "round", borderColor: theme.accent.brand, backgroundColor: theme.bg.elevated, paddingX: 2, paddingY: 1, flexDirection: "column", width: props.width ?? "60%", height: props.height, children: [_jsx(Text, { color: theme.accent.brand, bold: true, children: props.title }), _jsx(Box, { flexDirection: "column", marginTop: 1, flexGrow: 1, children: props.children })] }) }));
+}

package/dist/shared/ui/SelectModal.js

@@ -0,0 +1,78 @@
+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";
+const MAX_VISIBLE = 10;
+/**
+ * Filterable modal picker: type to narrow, up/down to navigate, enter to
+ * select, esc to cancel. The single interaction pattern for every enumerated
+ * field in the board  a fixed set of two options and a list of dozens both
+ * use this, so users only ever learn one gesture for "change this value".
+ */
+export function SelectModal(props) {
+    const { title, options, initialValue, onSelect, onClose } = props;
+    const accent = props.accentColor ?? theme.accent.brand;
+    const [query, setQuery] = useState("");
+    const [cursor, setCursor] = useState(() => {
+        const idx = options.findIndex((o) => o.value === initialValue);
+        return idx >= 0 ? idx : 0;
+    });
+    const filtered = useMemo(() => {
+        const q = query.trim().toLowerCase();
+        if (!q)
+            return options;
+        return options.filter((o) => o.label.toLowerCase().includes(q));
+    }, [options, query]);
+    const clampedCursor = filtered.length > 0 ? cursor % filtered.length : 0;
+    const selectAt = useCallback((idx) => {
+        const option = filtered[idx];
+        if (option)
+            onSelect(option);
+    }, [filtered, onSelect]);
+    useInput((input, key) => {
+        if (input.includes("[<"))
+            return;
+        if (key.escape) {
+            onClose();
+            return;
+        }
+        if (key.return) {
+            selectAt(clampedCursor);
+            return;
+        }
+        if (key.upArrow) {
+            setCursor((prev) => (prev <= 0 ? Math.max(0, filtered.length - 1) : prev - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setCursor((prev) => (prev >= filtered.length - 1 ? 0 : prev + 1));
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setQuery((prev) => prev.slice(0, -1));
+            setCursor(0);
+            return;
+        }
+        if (key.ctrl)
+            return;
+        if (input.length === 1 && input >= " " && input <= "~") {
+            setQuery((prev) => prev + input);
+            setCursor(0);
+        }
+    });
+    const start = Math.max(0, clampedCursor - Math.floor(MAX_VISIBLE / 2));
+    const end = Math.min(filtered.length, start + MAX_VISIBLE);
+    const visible = filtered.slice(start, end);
+    return (_jsx(Box, { position: "absolute", top: 0, left: 0, width: "100%", height: "100%", justifyContent: "center", alignItems: "center", children: _jsxs(Box, { width: 50, height: Math.min(20, visible.length + 7), flexDirection: "column", backgroundColor: theme.bg.elevated, borderStyle: "round", borderColor: accent, paddingX: 1, paddingY: 0, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: accent, bold: true, children: title }), _jsx(Text, { color: theme.text.muted, children: "esc" })] }), _jsxs(Box, { marginTop: 0, children: [_jsx(Text, { color: theme.text.muted, children: "› " }), _jsx(Text, { color: query ? theme.text.primary : theme.text.muted, children: query || t("selectModal.searchPlaceholder") }), _jsx(Text, { inverse: true, children: " " })] }), _jsx(Box, { flexDirection: "column", marginTop: 0, children: visible.length === 0 ? (_jsx(Text, { color: theme.text.muted, children: t("selectModal.empty") })) : (visible.map((option, visIdx) => {
+                        const realIdx = start + visIdx;
+                        const isSelected = realIdx === clampedCursor;
+                        const isCurrent = option.value === initialValue;
+                        return (_jsxs(Box, { backgroundColor: isSelected ? theme.bg.active : undefined, children: [_jsx(Text, { color: isSelected ? theme.text.inverse : theme.text.muted, children: isSelected ? "❯ " : "  " }), _jsx(Text, { color: isSelected ? theme.text.inverse : isCurrent ? accent : theme.text.primary, children: option.label })] }, option.value));
+                    })) }), _jsxs(Box, { marginTop: 1, justifyContent: "space-between", children: [_jsxs(Text, { color: theme.text.muted, children: [filtered.length, "/", options.length] }), _jsx(Text, { color: theme.text.muted, children: t("selectModal.hint") })] })] }) }));
+}
+/** Bordered field showing the current value, matching TextField's focus styling. */
+export function SelectValueField(props) {
+    const { label, placeholder, isActive } = props;
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(Box, { borderStyle: "single", borderColor: isActive ? theme.accent.brand : theme.border.dim, backgroundColor: isActive ? theme.bg.input : undefined, paddingLeft: 1, overflow: "hidden", width: "100%", children: label ? (_jsx(Text, { color: theme.text.primary, children: label })) : (_jsx(Text, { color: theme.text.muted, children: placeholder })) }), isActive ? (_jsxs(Box, { marginTop: 0, children: [_jsx(Text, { color: theme.accent.brand, children: "› " }), _jsx(Text, { color: theme.text.muted, children: t("selectModal.fieldHint", { action: "enter" }) })] })) : null] }));
+}