@elaraai/e3-ui-cli 1.0.72 → 1.0.74

package/dist/tui/controller.js

@@ -0,0 +1,644 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { describeError } from './api.js';
+import { cancelRun, startRun } from './data/dataflow.js';
+import { viewWorkspace } from './data/feeds.js';
+import { complete } from './input/completion.js';
+import { describe, parseCommand } from './input/commands.js';
+import { resolve as resolveKey } from './input/keymap.js';
+import { isMouseInput, parseSgr } from './input/mouse.js';
+import { hitAt, lastFrame, paneTopFromRow } from './ui/frame.js';
+import { buildCatalogue } from './model/catalogue.js';
+import { HELP_TABS, helpTabFor } from './model/help.js';
+import { listModel } from './model/index.js';
+import { inputView, isLogTab, taskTabsOf, taskView } from './state/actions.js';
+import { dirtyCount } from './state/reducer.js';
+import { repoEntry } from './state/persist.js';
+import { restoreTree } from './ui/widgets/tree.js';
+const hooks = new Map();
+/**
+ * Registers a view's hooks (called by each view module on load).
+ *
+ * @param kind - The view kind
+ * @param viewHooks - The hooks
+ */
+export function registerViewHooks(kind, viewHooks) {
+    hooks.set(kind, { ...hooks.get(kind), ...viewHooks });
+}
+let toastSeq = 0;
+/** Rows one wheel report scrolls (design §13). */
+const WHEEL_ROWS = 3;
+/**
+ * Creates the controller.
+ *
+ * @param deps - The dependencies
+ * @returns The controller
+ */
+export function createController(deps) {
+    const { store } = deps;
+    let stdout = null;
+    const state = () => store.getState();
+    const dispatch = (action) => store.dispatch(action);
+    const workspace = () => {
+        const v = state().view;
+        if (v.kind === 'dashboard' || v.kind === 'task' || v.kind === 'input')
+            return v.ws;
+        const persisted = deps.persist?.state;
+        const session = state().session;
+        if (persisted !== undefined && session !== null)
+            return persisted.repos[session.stateKey]?.workspace ?? null;
+        return null;
+    };
+    const remember = (view) => {
+        const session = state().session;
+        if (deps.persist === null || session === null)
+            return;
+        deps.persist.update(s => {
+            const entry = repoEntry(s, session.stateKey);
+            if (view.kind === 'dashboard' || view.kind === 'task' || view.kind === 'input')
+                entry.workspace = view.ws;
+            entry.view = view.kind === 'task' ? `task:${view.task}` : view.kind === 'input' ? `input:${view.name}` : view.kind;
+        });
+    };
+    const controller = {
+        deps,
+        dispatch,
+        state,
+        workspace,
+        onKey(input, key) {
+            if (isMouseInput(input)) {
+                // Mouse reports never reach the keymap (they would read as a paste).
+                if (state().mouse)
+                    for (const event of parseSgr(input))
+                        onMouse(event);
+                return;
+            }
+            const s = state();
+            const v = s.view;
+            const viewHooks = hooks.get(v.kind);
+            const ctx = {
+                commandMode: s.command.mode,
+                editingLeaf: v.kind === 'input' && v.editing !== null,
+                scope: v.kind === 'repos' || v.kind === 'workspaces' || v.kind === 'dashboard' ? 'list'
+                    : v.kind === 'task' ? (v.tab === 'output' ? 'tree' : isLogTab(v.tab) ? 'logs' : 'list')
+                        : v.kind === 'input' ? 'tree'
+                            : 'none',
+                editable: v.kind === 'input',
+                tabs: v.kind === 'task' ? taskTabsOf(s, v.ws, v.task).length : v.kind === 'help' ? HELP_TABS.length : 0,
+                pendingKey: s.pendingKey,
+            };
+            const action = resolveKey(input, key, ctx);
+            if (s.pendingKey !== null)
+                dispatch({ type: 'pendingKey', key: null });
+            if (action === null)
+                return;
+            deps.log(`key ${JSON.stringify(input)} → ${action.kind}`);
+            if (viewHooks?.key?.(action, s, controller) === true)
+                return;
+            handleAction(action, s, viewHooks);
+        },
+        async execute(text) {
+            const trimmed = text.trim();
+            if (trimmed === '') {
+                dispatch({ type: 'command/clear' });
+                return;
+            }
+            if (!trimmed.startsWith('/')) {
+                const candidates = complete(trimmed, buildCatalogue(state(), deps.glyphs));
+                const first = candidates[0];
+                if (first === undefined) {
+                    controller.toast(`no match for ${trimmed}`, 'warn');
+                    return;
+                }
+                await controller.execute(first.insert);
+                return;
+            }
+            const parsed = parseCommand(trimmed);
+            if (!parsed.ok) {
+                controller.toast(parsed.error, 'neg');
+                return;
+            }
+            dispatch({ type: 'command/clear' });
+            try {
+                await runCommand(parsed.command, trimmed);
+            }
+            catch (err) {
+                deps.log(`command ${trimmed} failed: ${describeError(err)}`);
+                controller.toast(describeError(err), 'neg');
+            }
+        },
+        toast(text, tone = 'pos', glyph) {
+            const id = ++toastSeq;
+            dispatch({ type: 'toast', toast: { id, text, tone, ...(glyph !== undefined ? { glyph } : {}), until: deps.now() + 3_000 } });
+            const timer = setTimeout(() => dispatch({ type: 'toast/clear', id }), 3_000);
+            timer.unref?.();
+        },
+        navigate(view, push = false) {
+            dispatch(push ? { type: 'view/push', view } : { type: 'view/set', view });
+            remember(view);
+        },
+        openTask(ws, task, tab = 'output') {
+            const s = state();
+            const v = s.view;
+            if (v.kind === 'task' && v.ws === ws && v.task === task) {
+                dispatch({ type: 'task/tab', tab });
+                return;
+            }
+            controller.navigate(taskView(ws, task, tab), v.kind === 'dashboard' || v.kind === 'task' || v.kind === 'input');
+            restoreTree(controller, ws, `.tasks.${task}.output`);
+        },
+        openInput(ws, name) {
+            const v = state().view;
+            controller.navigate(inputView(ws, name), v.kind === 'dashboard' || v.kind === 'task' || v.kind === 'input');
+            restoreTree(controller, ws, `.inputs.${name}`);
+        },
+        openWorkspace(ws) {
+            dispatch({ type: 'view/root', view: { kind: 'dashboard', ws, list: { sel: 0, top: 0 } } });
+            remember({ kind: 'dashboard', ws, list: { sel: 0, top: 0 } });
+        },
+        back() {
+            const s = state();
+            if (s.command.mode !== 'idle') {
+                dispatch({ type: 'command/clear' });
+                return;
+            }
+            if (s.history.length > 0) {
+                dispatch({ type: 'view/pop' });
+                remember(state().view);
+                return;
+            }
+            const v = s.view;
+            if (v.kind === 'task' || v.kind === 'input')
+                controller.openWorkspace(v.ws);
+        },
+        quit(force) {
+            const dirty = dirtyCount(state());
+            if (dirty > 0 && !force) {
+                dispatch({ type: 'command/confirm', confirm: { question: `quit with ${dirty} unsaved edit${dirty === 1 ? '' : 's'}?`, command: '/quit --force' } });
+                return;
+            }
+            deps.exit(0);
+        },
+        setSize(size) {
+            const current = state().size;
+            if (current.columns !== size.columns || current.rows !== size.rows)
+                dispatch({ type: 'size', size });
+        },
+        attachStdout(stream) {
+            stdout = stream;
+            void stdout;
+        },
+        updateCompletion() {
+            const s = state();
+            if (s.command.mode !== 'edit')
+                return;
+            const tags = hooks.get(s.view.kind)?.tags?.(s);
+            dispatch({ type: 'command/completion', items: complete(s.command.text, buildCatalogue(s, deps.glyphs, tags)) });
+        },
+    };
+    const startTyping = (text) => {
+        dispatch({ type: 'command/edit', text });
+        controller.updateCompletion();
+    };
+    const handleAction = (action, s, viewHooks) => {
+        switch (action.kind) {
+            case 'quit':
+                controller.quit(false);
+                return;
+            case 'help':
+                controller.navigate({ kind: 'help', tab: helpTabFor(s.view.kind) }, true);
+                return;
+            case 'back':
+                controller.back();
+                return;
+            case 'refresh':
+                deps.feeds.refresh();
+                return;
+            case 'type':
+                startTyping(action.text);
+                return;
+            case 'prefill':
+                startTyping(action.text);
+                return;
+            case 'pending':
+                dispatch({ type: 'pendingKey', key: action.key });
+                return;
+            case 'paste': {
+                if (s.command.mode === 'edit')
+                    dispatch({ type: 'command/insert', text: action.text });
+                else
+                    dispatch({ type: 'command/edit', text: action.text });
+                controller.updateCompletion();
+                if (action.submit)
+                    void controller.execute(state().command.text);
+                return;
+            }
+            case 'tab': {
+                if (s.view.kind === 'help') {
+                    dispatch({ type: 'help/tab', tab: HELP_TABS[action.index]?.tab ?? 'everywhere' });
+                }
+                else if (s.view.kind === 'task') {
+                    dispatch({ type: 'task/tab', tab: taskTabsOf(s, s.view.ws, s.view.task)[action.index] ?? 'output' });
+                }
+                return;
+            }
+            case 'tab.cycle': {
+                const wrap = (i, n) => ((i + action.delta) % n + n) % n;
+                if (s.view.kind === 'help') {
+                    const tab = s.view.tab;
+                    const i = Math.max(0, HELP_TABS.findIndex(x => x.tab === tab));
+                    dispatch({ type: 'help/tab', tab: HELP_TABS[wrap(i, HELP_TABS.length)].tab });
+                }
+                else if (s.view.kind === 'task') {
+                    const tabs = taskTabsOf(s, s.view.ws, s.view.task);
+                    dispatch({ type: 'task/tab', tab: tabs[wrap(Math.max(0, tabs.indexOf(s.view.tab)), tabs.length)] });
+                }
+                return;
+            }
+            case 'move': {
+                if (s.view.kind === 'help') {
+                    const tabs = ['everywhere', 'repos', 'workspaces', 'dashboard', 'task', 'input'];
+                    const i = tabs.indexOf(s.view.tab);
+                    if (action.op === 'up' || action.op === 'down')
+                        return;
+                    return void i;
+                }
+                if (viewHooks?.tree?.(action, s, controller) === true)
+                    return;
+                const model = listModel(s);
+                dispatch({ type: 'list/move', op: action.op, count: model.count, visible: model.visible });
+                return;
+            }
+            case 'open':
+                viewHooks?.open?.(s, controller);
+                return;
+            case 'expand':
+            case 'collapse':
+            case 'toggle':
+            case 'collapseDeep':
+            case 'next':
+            case 'prev':
+            case 'save':
+                viewHooks?.tree?.(action, s, controller);
+                return;
+            case 'retry': {
+                if (s.view.kind === 'refusal')
+                    void deps.openTarget(s.session?.target ?? refusalTarget(s));
+                return;
+            }
+            // -- the command box ------------------------------------------
+            case 'cmd.char':
+                dispatch({ type: 'command/insert', text: action.text });
+                controller.updateCompletion();
+                return;
+            case 'cmd.backspace': {
+                if (s.command.text.length <= 1) {
+                    dispatch({ type: 'command/clear' });
+                    return;
+                }
+                dispatch({ type: 'command/backspace' });
+                controller.updateCompletion();
+                return;
+            }
+            case 'cmd.delete':
+                dispatch({ type: 'command/delete' });
+                controller.updateCompletion();
+                return;
+            case 'cmd.left':
+                dispatch({ type: 'command/cursor', to: 'left' });
+                return;
+            case 'cmd.right':
+                dispatch({ type: 'command/cursor', to: 'right' });
+                return;
+            case 'cmd.home':
+                dispatch({ type: 'command/cursor', to: 'home' });
+                return;
+            case 'cmd.end':
+                dispatch({ type: 'command/cursor', to: 'end' });
+                return;
+            case 'cmd.up':
+                dispatch({ type: 'command/completionMove', delta: -1 });
+                return;
+            case 'cmd.down':
+                dispatch({ type: 'command/completionMove', delta: 1 });
+                return;
+            case 'cmd.cancel':
+                dispatch({ type: 'command/clear' });
+                return;
+            case 'cmd.complete': {
+                const completion = s.command.completion;
+                const item = completion?.items[completion.index];
+                if (item === undefined)
+                    return;
+                dispatch({ type: 'command/edit', text: item.insert });
+                controller.updateCompletion();
+                return;
+            }
+            case 'cmd.submit': {
+                if (s.command.mode === 'confirm' && s.command.confirm !== null) {
+                    const command = s.command.confirm.command;
+                    dispatch({ type: 'command/clear' });
+                    void controller.execute(command);
+                    return;
+                }
+                const completion = s.command.completion;
+                const item = completion?.items[completion.index];
+                // A picked completion row runs that item; a fully typed command runs as typed.
+                if (item !== undefined && (!s.command.text.startsWith('/') || item.kind !== 'command' && item.kind !== 'flag' && !parseCommand(s.command.text).ok)) {
+                    void controller.execute(item.insert);
+                    return;
+                }
+                if (item !== undefined && item.kind !== 'command' && item.kind !== 'flag' && parseCommand(s.command.text).ok) {
+                    const parsed = parseCommand(s.command.text);
+                    // `/task fore` with a highlighted row opens the row, not the literal.
+                    if (parsed.ok && 'target' in parsed.command && item.insert !== s.command.text) {
+                        void controller.execute(item.insert);
+                        return;
+                    }
+                }
+                void controller.execute(s.command.text);
+                return;
+            }
+            default:
+                return;
+        }
+    };
+    // -- the mouse ------------------------------------------------------
+    let dragging = false;
+    /** The primary list's first visible row (for absolute scrolls). */
+    const listTop = (s) => {
+        const v = s.view;
+        if (v.kind === 'repos' || v.kind === 'workspaces' || v.kind === 'dashboard')
+            return v.list.top;
+        if (v.kind === 'task')
+            return v.tab === 'runs' ? v.runs.top : v.tab === 'reads' ? v.reads.top : v.tree.top;
+        if (v.kind === 'input')
+            return v.tree.top;
+        return 0;
+    };
+    const scrollBy = (s, to) => {
+        if (hooks.get(s.view.kind)?.scroll?.(to, s, controller) === true)
+            return;
+        const model = listModel(s);
+        if (model.count === 0)
+            return;
+        const delta = 'delta' in to ? to.delta : to.top - listTop(s);
+        dispatch({ type: 'list/scroll', delta, count: model.count, visible: model.visible });
+    };
+    // Terminals send several wheel reports per notch. The rows they add up
+    // to are applied once per tick — one scroll, one dispatch — instead of
+    // a scroll per report.
+    let wheelRows = 0;
+    let wheelFlush = null;
+    const flushWheel = () => {
+        if (wheelFlush !== null) {
+            clearImmediate(wheelFlush);
+            wheelFlush = null;
+        }
+        const delta = wheelRows;
+        wheelRows = 0;
+        if (delta !== 0)
+            scrollBy(state(), { delta });
+    };
+    const wheel = (rows) => {
+        wheelRows += rows;
+        if (wheelFlush === null)
+            wheelFlush = setImmediate(flushWheel);
+    };
+    const onMouse = (event) => {
+        const frame = lastFrame();
+        if (frame === null)
+            return;
+        if (event.kind === 'wheelUp') {
+            wheel(-WHEEL_ROWS);
+            return;
+        }
+        if (event.kind === 'wheelDown') {
+            wheel(WHEEL_ROWS);
+            return;
+        }
+        // A click or a drag lands after the wheel rows before it.
+        flushWheel();
+        const s = state();
+        if (event.kind === 'release') {
+            dragging = false;
+            return;
+        }
+        if (event.kind === 'drag') {
+            if (dragging && frame.pane !== null)
+                scrollBy(s, { top: paneTopFromRow(frame.pane, event.y) });
+            return;
+        }
+        if (event.kind !== 'press' || event.button !== 'left')
+            return;
+        const pane = frame.pane;
+        if (pane !== null && event.x === frame.layout.columns - 1 && event.y >= pane.top && event.y < pane.top + pane.rows && pane.total > pane.visible) {
+            dragging = true;
+            scrollBy(s, { top: paneTopFromRow(pane, event.y) });
+            return;
+        }
+        const target = hitAt(frame, event.x, event.y);
+        if (target === null)
+            return;
+        deps.log(`click ${event.x},${event.y} → ${target.kind}`);
+        const viewHooks = hooks.get(s.view.kind);
+        if (viewHooks?.click?.(target, event, s, controller) === true)
+            return;
+        switch (target.kind) {
+            case 'list': {
+                const model = listModel(s);
+                dispatch({ type: 'list/select', index: target.index, count: model.count, visible: model.visible });
+                return;
+            }
+            case 'tab':
+                handleAction({ kind: 'tab', index: target.index }, s, viewHooks);
+                return;
+            case 'crumb': {
+                if (target.index === 0) {
+                    if (s.session?.repo === null)
+                        controller.navigate({ kind: 'repos', list: { sel: 0, top: 0 } }, s.view.kind !== 'repos');
+                    else
+                        controller.navigate({ kind: 'workspaces', list: { sel: 0, top: 0 } }, s.view.kind !== 'workspaces');
+                }
+                else if (target.index === 1) {
+                    const ws = workspace();
+                    if (ws !== null && s.view.kind !== 'dashboard')
+                        controller.openWorkspace(ws);
+                }
+                return;
+            }
+            case 'pill': {
+                if (target.pill === 'running')
+                    startTyping('/stop');
+                else if (target.pill === 'dirty')
+                    startTyping('/apply');
+                else
+                    void controller.execute('/refresh');
+                return;
+            }
+            case 'completion': {
+                const item = s.command.completion?.items[target.index];
+                if (item !== undefined)
+                    void controller.execute(item.insert);
+                return;
+            }
+            default:
+                return;
+        }
+    };
+    const refusalTarget = (s) => {
+        if (s.view.kind !== 'refusal')
+            return '.';
+        const r = s.view.refusal;
+        if (r.kind === 'not-repo')
+            return r.target;
+        if (r.kind === 'not-logged-in')
+            return r.repo !== null ? `${r.origin}/repos/${r.repo}` : r.origin;
+        if (r.kind === 'unreachable')
+            return r.url.replace(/\/api\/repos(\/[^/]+)?.*$/, (_m, repo) => (repo !== undefined ? `/repos${repo}` : ''));
+        return '.';
+    };
+    /** Commands that leave the current view (they ask first while edits are pending). */
+    const LEAVES = new Set(['task', 'input', 'dataset', 'workspace', 'workspaces', 'repos', 'repo', 'logs', 'runs']);
+    const runCommand = async (command, text) => {
+        const s = state();
+        const ws = workspace();
+        const viewHooks = hooks.get(s.view.kind);
+        const dirty = dirtyCount(s);
+        if (dirty > 0 && LEAVES.has(command.name) && command.name !== 'repo') {
+            dispatch({ type: 'command/confirm', confirm: { question: `discard ${dirty} unsaved edit${dirty === 1 ? '' : 's'} and ${describe(command, { workspace: ws, taskCount: 0, running: false, concurrency: 4, dirty }).text}?`, command: `/discard --then "${text.replace(/"/g, '')}"` } });
+            return;
+        }
+        if (viewHooks?.command !== undefined && await viewHooks.command(command, s, controller))
+            return;
+        switch (command.name) {
+            case 'task': {
+                if (ws === null) {
+                    controller.toast('open a workspace first', 'warn');
+                    return;
+                }
+                controller.openTask(ws, command.target);
+                return;
+            }
+            case 'input': {
+                if (ws === null) {
+                    controller.toast('open a workspace first', 'warn');
+                    return;
+                }
+                controller.openInput(ws, command.target);
+                return;
+            }
+            case 'dataset': {
+                if (ws === null) {
+                    controller.toast('open a workspace first', 'warn');
+                    return;
+                }
+                const path = `.${command.target.replace(/^\./, '')}`;
+                const input = /^\.inputs\.([^.]+)$/.exec(path);
+                const task = /^\.tasks\.([^.]+)\.output$/.exec(path);
+                if (input !== null)
+                    controller.openInput(ws, input[1]);
+                else if (task !== null)
+                    controller.openTask(ws, task[1]);
+                else
+                    controller.toast(`${path} is not an input or a task output`, 'warn');
+                return;
+            }
+            case 'workspace': {
+                const known = s.data.workspaces;
+                if (known !== null && !known.some(w => w.name === command.target)) {
+                    controller.toast(`no workspace ${command.target}`, 'warn');
+                    return;
+                }
+                controller.openWorkspace(command.target);
+                return;
+            }
+            case 'workspaces':
+                controller.navigate({ kind: 'workspaces', list: { sel: 0, top: 0 } }, s.view.kind !== 'workspaces');
+                return;
+            case 'repos': {
+                if (s.session?.origin === null) {
+                    controller.toast('a local repository has no repository list', 'warn');
+                    return;
+                }
+                controller.navigate({ kind: 'repos', list: { sel: 0, top: 0 } }, s.view.kind !== 'repos');
+                return;
+            }
+            case 'repo': {
+                const dirty = dirtyCount(s);
+                if (dirty > 0) {
+                    dispatch({ type: 'command/confirm', confirm: { question: `discard ${dirty} unsaved edit${dirty === 1 ? '' : 's'} and open ${command.target}?`, command: `/discard --then "/repo ${command.target}"` } });
+                    return;
+                }
+                await deps.openTarget(command.target);
+                return;
+            }
+            case 'login':
+                await deps.login(command.url);
+                return;
+            case 'run': {
+                const here = viewWorkspace(s);
+                if (here === null) {
+                    controller.toast('open a workspace first', 'warn');
+                    return;
+                }
+                await startRun(controller, here, { force: command.force, filter: command.filter, concurrency: command.concurrency });
+                return;
+            }
+            case 'stop': {
+                const here = viewWorkspace(s);
+                if (here === null) {
+                    controller.toast('open a workspace first', 'warn');
+                    return;
+                }
+                await cancelRun(controller, here);
+                return;
+            }
+            case 'logs': {
+                if (ws === null) {
+                    controller.toast('open a workspace first', 'warn');
+                    return;
+                }
+                controller.openTask(ws, command.task, command.stream ?? 'stdout');
+                return;
+            }
+            case 'runs': {
+                if (ws === null) {
+                    controller.toast('open a workspace first', 'warn');
+                    return;
+                }
+                controller.openTask(ws, command.task, 'runs');
+                return;
+            }
+            case 'refresh':
+                deps.feeds.refresh();
+                controller.toast('polling every feed now', 'info');
+                return;
+            case 'help':
+                controller.navigate({ kind: 'help', tab: helpTabFor(s.view.kind) }, true);
+                return;
+            case 'about':
+                controller.navigate({ kind: 'about' }, true);
+                return;
+            case 'quit':
+                controller.quit(command.force);
+                return;
+            case 'discard': {
+                if (state().edit !== null) {
+                    dispatch({ type: 'edit/set', edit: null });
+                    dispatch({ type: 'input/editing', editing: null });
+                }
+                if (command.then !== undefined)
+                    await controller.execute(command.then);
+                return;
+            }
+            default:
+                controller.toast(`/${command.name} does nothing here`, 'warn');
+                return;
+        }
+    };
+    return controller;
+}
+//# sourceMappingURL=controller.js.map