epiq 0.0.2 → 0.0.4

package/dist/navigation/model/navigation-tree.model.d.ts

@@ -1,9 +1,11 @@
+import { BoardItemTypes } from '../../board/model/board.model.js';
 export type NavigationTree<TMeta = Record<string, unknown>> = {
     id: string;
     isSelected: boolean;
     childrenRenderAxis: 'vertical' | 'horizontal';
     name: string;
+    description?: string;
     children: NavigationTree<unknown>[];
-    actionContext: string;
+    actionContext: (typeof BoardItemTypes)[keyof typeof BoardItemTypes];
     enableChildNavigationAcrossContainers?: boolean;
 } & TMeta;

package/dist/navigation/navigation.d.ts

@@ -1,10 +1,3 @@
-import { NavigationTree } from './model/navigation-tree.model.js';
-export declare function navigate<T extends NavigationTree>({ index, breadCrumb, callbacks, }: {
-    index: number;
-    breadCrumb: Array<NavigationTree<NavigationTree>>;
-    callbacks: Partial<{
-        render: () => void;
-        onSelectChange: (s: T['children'][number], breadCrumb: T['children']) => void;
-        onConfirm: (s: T['children'][number]) => void;
-    }>;
-}): void;
+import { NavigateUtils } from './model/navigation-ctx.model.js';
+export declare const navigationUtils: NavigateUtils;
+export declare function initListeners(): void;

package/dist/navigation/navigation.js

@@ -1,74 +1,82 @@
 import readline from 'readline';
-import { navigationState } from './state/state.js';
+import { appState, patchState, updateState } from './state/state.js';
 import { getKeyIntent } from './utils/key-intent.js';
-export function navigate({ index = 0, breadCrumb, callbacks, }) {
-    const { render = () => { }, onSelectChange = () => { }, onConfirm = () => { }, } = callbacks;
-    const ctx = {
-        breadCrumb,
-        get navigationNode() {
-            return this.breadCrumb.at(-1);
-        },
-        get children() {
-            return this.navigationNode.children ?? [];
-        },
-        selectNone: () => {
-            ctx.select(-1);
-        },
-        _selectedIndex: 0,
-        getSelectedIndex() {
-            return this._selectedIndex;
-        },
-        select(i) {
-            this._selectedIndex = i;
-            updateSelection(ctx.navigationNode, breadCrumb, i, onSelectChange);
-        },
-        render,
-        reInvokeNavigate(index, breadCrumb) {
-            return reInvokeNavigate(index, breadCrumb);
-        },
-        confirm: sel => onConfirm(sel),
-        exit: () => {
-            cleanup();
-            process.exit(0);
-        },
-        enterChildNode: node => reInvokeNavigate(0, [...breadCrumb, node]),
-        enterParentNode: () => {
-            ctx.select(-1); // Clear all on this level
-            if (breadCrumb.length < 2)
-                return; // Need at least grandparent + parent
-            const ancestors = breadCrumb;
-            const parent = ancestors[ancestors.length - 1];
-            const grandParent = ancestors[ancestors.length - 2];
-            if (!parent || !grandParent)
-                return;
-            const parentIndex = grandParent?.children.findIndex(x => parent.id === x.id);
-            reInvokeNavigate(parentIndex, breadCrumb.slice(0, -1)); // Go to parent level
-        },
-    };
-    ctx.select(index);
-    function onKeyPress(_, key) {
-        if (key.ctrl && key.name === 'c')
-            return ctx.exit();
-        const filteredActions = navigationState.availableActions.filter(x => x.mode === navigationState.mode);
-        const action = filteredActions?.find(actionMeta => {
-            const intent = getKeyIntent(key, ctx);
-            return intent === actionMeta.intent;
+let currentKeypressListener;
+export const navigationUtils = {
+    updateSelection: (idx) => {
+        updateState(oldState => {
+            const currentNode = oldState.breadCrumb.at(-1) ?? oldState.breadCrumb[0];
+            if (!currentNode)
+                return oldState;
+            currentNode.children?.forEach((child, i) => (child.isSelected = i === idx));
+            return {
+                ...oldState,
+                selectedIndex: idx,
+                currentNode: currentNode, // keep currentNode in sync
+                breadCrumb: [...oldState.breadCrumb], // keep reference fresh if you rely on it
+            };
         });
-        action?.action?.(ctx);
-        ctx.render();
-    }
-    const cleanup = () => process.stdin.removeListener('keypress', onKeyPress);
-    const reInvokeNavigate = (idx, crumb) => {
-        cleanup();
-        navigate({ index: idx, breadCrumb: [...crumb], callbacks });
+    },
+    selectNone() {
+        this.updateSelection(-1);
+    },
+    confirm(sel) {
+        console.log(sel);
+    },
+    exit() {
+        process.exit(0);
+    },
+    enterChildNode(childNode) {
+        patchState({
+            breadCrumb: [...appState.breadCrumb, childNode],
+            currentNode: childNode,
+            selectedIndex: 0,
+        });
+        this.updateSelection(0);
+    },
+    enterParentNode() {
+        const crumb = appState.breadCrumb;
+        if (crumb.length < 2)
+            return;
+        const newCrumb = crumb.slice(0, -1);
+        const parentLevelNode = newCrumb.at(-1);
+        // find old parent index inside grandparent
+        const grandParent = newCrumb.at(-2);
+        const parentIndex = grandParent?.children?.findIndex(x => x.id === parentLevelNode.id) ?? 0;
+        patchState({
+            breadCrumb: newCrumb,
+            currentNode: parentLevelNode,
+            selectedIndex: parentIndex,
+        });
+        this.updateSelection(parentIndex);
+    },
+};
+const getKeyPressListener = () => {
+    navigationUtils.updateSelection(appState.selectedIndex ?? 0);
+    return async function onKeyPress(_, key) {
+        if (key.ctrl && key.name === 'c')
+            return navigationUtils.exit();
+        const filteredActions = appState.availableActions.filter(a => a.mode === appState.mode);
+        const actionMeta = filteredActions.find(({ intent, mode }) => getKeyIntent(key, mode) === intent);
+        if (!actionMeta?.action)
+            return;
+        try {
+            const res = actionMeta.action(navigationUtils, actionMeta, key);
+            if (res instanceof Promise)
+                await res;
+        }
+        catch (err) {
+            console.error(err);
+        }
     };
-    render();
+};
+export function initListeners() {
+    if (currentKeypressListener) {
+        process.stdin.removeListener('keypress', currentKeypressListener);
+    }
+    currentKeypressListener = getKeyPressListener();
     readline.emitKeypressEvents(process.stdin);
     if (process.stdin.isTTY)
         process.stdin.setRawMode(true);
-    process.stdin.on('keypress', onKeyPress);
-}
-function updateSelection({ children }, breadCrumb, idx, onSelectChange) {
-    children.forEach((c, i) => (c.isSelected = i === idx));
-    onSelectChange(children[idx], breadCrumb);
+    process.stdin.on('keypress', currentKeypressListener);
 }

package/dist/navigation/state/command-line.state.d.ts

@@ -0,0 +1,18 @@
+export declare const commandDelimiter = " ";
+export type CommandLineState = {
+    value: string;
+    commandHistory: string[];
+    commandHistoryIndex: number;
+};
+export declare let commandLineState: CommandLineState;
+type Listener = () => void;
+export declare const subscribeCommandLineState: (listener: Listener) => () => boolean;
+export declare const updateCommandLineState: (cb: (old: CommandLineState) => CommandLineState) => void;
+export declare const updateCommandLineInput: (cb: (previous: string) => string) => void;
+export declare const updateCommandHistory: () => void;
+export declare const getPrevCommand: () => void;
+export declare const getNextCommand: () => void;
+export declare const clearCommandLine: () => void;
+export declare const getCommandLineInput: () => string;
+export declare const getCommandLineArgumentValue: () => string;
+export {};

package/dist/navigation/state/command-line.state.js

@@ -0,0 +1,60 @@
+export const commandDelimiter = ' ';
+export let commandLineState = {
+    commandHistory: [],
+    value: '',
+    commandHistoryIndex: -1,
+};
+const listeners = new Set();
+const notify = () => {
+    for (const l of listeners)
+        l();
+};
+export const subscribeCommandLineState = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+};
+// ===== Updates =====
+export const updateCommandLineState = (cb) => {
+    const next = cb(structuredClone(commandLineState));
+    commandLineState = next;
+    notify();
+};
+export const updateCommandLineInput = (cb) => {
+    updateCommandLineState(state => ({
+        ...state,
+        value: cb(state.value),
+    }));
+};
+export const updateCommandHistory = () => {
+    updateCommandLineState(state => ({
+        ...state,
+        commandHistory: [state.value, ...state.commandHistory].slice(0, 20),
+    }));
+};
+export const getPrevCommand = () => {
+    updateCommandLineState(s => {
+        const nextIndex = Math.min(s.commandHistoryIndex + 1, s.commandHistory.length - 1);
+        return {
+            ...s,
+            commandHistoryIndex: nextIndex,
+            value: s.commandHistory[nextIndex] ?? '',
+        };
+    });
+};
+export const getNextCommand = () => {
+    updateCommandLineState(s => {
+        // typically you want to clamp down to -1 (meaning "no selection")
+        const nextIndex = Math.max(s.commandHistoryIndex - 1, -1);
+        return {
+            ...s,
+            commandHistoryIndex: nextIndex,
+            value: nextIndex === -1 ? '' : s.commandHistory[nextIndex] ?? '',
+        };
+    });
+};
+export const clearCommandLine = () => updateCommandLineInput(() => '');
+export const getCommandLineInput = () => commandLineState.value;
+export const getCommandLineArgumentValue = () => {
+    const [_, ...rest] = commandLineState.value.split(commandDelimiter);
+    return rest.join(commandDelimiter);
+};

package/dist/navigation/state/state.d.ts

@@ -1,11 +1,20 @@
-import { ActionEntry, ModeOptions } from '../model/action-map.model.js';
-import { NavigateCtx } from '../model/navigation-ctx.model.js';
+import { Board } from '../../board/model/board.model.js';
+import { ActionEntry, ModeUnion } from '../model/action-map.model.js';
 import { NavigationTree } from '../model/navigation-tree.model.js';
-export declare let navigationState: {
-    mode: ModeOptions;
-    availableActions: ActionEntry<[NavigateCtx]>[];
-    viewHelp: boolean;
-    currentNode: NavigationTree<NavigationTree> | null;
-    breadCrumb: NavigationTree<NavigationTree>[];
+export type AppState = {
+    readonly selectedIndex: number;
+    readonly mode: ModeUnion;
+    readonly availableActions: ActionEntry[];
+    readonly availableHints: readonly string[];
+    readonly currentNode: NavigationTree<NavigationTree>;
+    readonly breadCrumb: NavigationTree<NavigationTree>[];
+    readonly rootNode: Board;
 };
-export declare const setState: (cb: (oldState: typeof navigationState) => typeof navigationState) => void;
+export declare let appState: AppState;
+export declare const initAppState: (board: Board) => void;
+export declare const updateState: (cb: (oldState: typeof appState) => typeof appState, opts?: {
+    render?: boolean;
+}) => void;
+export declare const patchState: (patch: Partial<typeof appState>, opts?: {
+    render?: boolean;
+}) => void;

package/dist/navigation/state/state.js

@@ -1,10 +1,38 @@
-export let navigationState = {
-    mode: 'default',
-    availableActions: [],
-    viewHelp: false,
-    currentNode: null,
-    breadCrumb: [],
+import { Hints } from '../../board/hints/hints.js';
+import { renderBoard } from '../../cli.js';
+import { ContextualActionMap } from '../actions/board-action-map.js';
+import { DefaultActions } from '../actions/default/default-actions.js';
+import { inputActions } from '../actions/input/input-actions.js';
+export let appState;
+const derived = (state) => {
+    const { currentNode, mode } = state;
+    const availableHints = Hints[currentNode.actionContext + mode] ?? Hints[currentNode.actionContext];
+    const actionContext = currentNode?.actionContext;
+    const availableActions = [
+        ...DefaultActions,
+        ...ContextualActionMap[actionContext],
+        ...inputActions,
+    ];
+    return {
+        ...state,
+        availableHints,
+        availableActions,
+    };
 };
-export const setState = (cb) => {
-    navigationState = cb(navigationState);
+export const initAppState = (board) => {
+    appState = derived({
+        ...appState,
+        rootNode: board,
+        breadCrumb: [board],
+        selectedIndex: 0,
+        mode: 'default',
+        currentNode: board,
+    });
+    renderBoard();
 };
+export const updateState = (cb, opts = { render: true }) => {
+    appState = derived(cb(appState));
+    if (opts.render)
+        renderBoard();
+};
+export const patchState = (patch, opts = { render: true }) => updateState(old => ({ ...old, ...patch }), opts);

package/dist/navigation/utils/get-command-line-intent.d.ts

@@ -0,0 +1,3 @@
+import { Intent } from './key-intent.js';
+import readline from 'readline';
+export declare const getCommandLineIntent: (key: readline.Key) => Intent.Confirm | Intent.ToggleCommandLine | Intent.CaptureInput | Intent.EraseInput | Intent.GetLastCommandFromHistory | Intent.GetNextCommandFromHistory;

package/dist/navigation/utils/get-command-line-intent.js

@@ -0,0 +1,17 @@
+import { Intent } from './key-intent.js';
+export const getCommandLineIntent = (key) => {
+    switch (key.name) {
+        case 'up':
+            return Intent.GetLastCommandFromHistory;
+        case 'down':
+            return Intent.GetNextCommandFromHistory;
+        case 'return':
+            return Intent.Confirm;
+        case 'backspace':
+            return Intent.EraseInput;
+        case 'escape':
+            return Intent.ToggleCommandLine;
+        default:
+            return Intent.CaptureInput;
+    }
+};

package/dist/navigation/utils/getKeyIntent.d.ts

@@ -0,0 +1,5 @@
+import readline from 'readline';
+import { ModeUnion } from '../model/action-map.model.js';
+import { NavigateCtx } from '../model/navigation-ctx.model.js';
+import { KeyIntent } from './key-intent.js';
+export declare function getKeyIntent(key: readline.Key, ctx: NavigateCtx, mode: ModeUnion): KeyIntent | null;

package/dist/navigation/utils/getKeyIntent.js

@@ -0,0 +1,71 @@
+import { Mode } from '../model/action-map.model.js';
+import { KeyIntent, getDir, mapDirectionalIntent } from './key-intent.js';
+export function getKeyIntent(key, ctx, mode) {
+    if (key.sequence === ':') {
+        return KeyIntent.ToggleCommandLine;
+    }
+    if (mode === Mode.COMMAND_LINE) {
+        switch (key.name) {
+            case 'return':
+                return KeyIntent.Confirm;
+            case 'backspace':
+                return KeyIntent.EraseInput;
+            case 'escape':
+                return KeyIntent.ToggleCommandLine;
+            default:
+                return KeyIntent.CaptureInput;
+        }
+    }
+    const axis = ctx.navigationNode.childrenRenderAxis;
+    const enableAcrossContainers = ctx.navigationNode.enableChildNavigationAcrossContainers;
+    if (key.name === 'escape' && mode === Mode.HELP) {
+        return KeyIntent.ToggleHelp;
+    }
+    // Hard exits
+    if (key.ctrl && key.name === 'c')
+        return KeyIntent.Exit;
+    if (key.name === 'escape')
+        return KeyIntent.Exit;
+    // Move mode
+    if (mode === Mode.MOVE) {
+        if (key.name === 'y')
+            return KeyIntent.ToggleMove;
+        const dir = getDir(key);
+        if (!dir)
+            return null;
+        return mapDirectionalIntent(dir, axis, Boolean(enableAcrossContainers), {
+            prevItem: KeyIntent.MovePreviousItem,
+            nextItem: KeyIntent.MoveNextItem,
+            prevContainer: KeyIntent.MoveToPreviousContainer,
+            nextContainer: KeyIntent.MoveToNextContainer,
+        });
+    }
+    // Normal mode
+    if (key.name === 'y')
+        return KeyIntent.ToggleMove;
+    // Edit (vim-ish)
+    if (key.name === 'i')
+        return KeyIntent.Edit;
+    // Navigation (arrows + vim hjkl)
+    const dir = getDir(key);
+    if (dir) {
+        return mapDirectionalIntent(dir, axis, Boolean(enableAcrossContainers), {
+            prevItem: KeyIntent.NavPreviousItem,
+            nextItem: KeyIntent.NavNextItem,
+            prevContainer: KeyIntent.NavToPreviousContainer,
+            nextContainer: KeyIntent.NavToNextContainer,
+        });
+    }
+    // Actions
+    switch (key.name) {
+        case 'a':
+            return KeyIntent.AddItem;
+        case 'return':
+        case 'e':
+            return KeyIntent.Confirm;
+        case 'q':
+            return KeyIntent.Exit;
+        default:
+            return null;
+    }
+}

package/dist/navigation/utils/key-intent.d.ts

@@ -1,16 +1,25 @@
 import readline from 'readline';
-import { NavigateCtx } from '../model/navigation-ctx.model.js';
-export declare enum KeyIntent {
-    NavPreviousItem = "nav-previous-item",
-    NavNextItem = "nav-next-item",
-    NavToPreviousContainer = "nav-to-previous-container",
-    NavToNextContainer = "nav-to-next-container",
-    MovePreviousItem = "move-previous-item",
-    MoveNextItem = "move-next-item",
-    MoveToPreviousContainer = "move-to-previous-container",
-    MoveToNextContainer = "move-to-next-container",
+import { ModeUnion } from '../model/action-map.model.js';
+export declare enum Intent {
+    NavPreviousItem = "navPreviousItem",
+    NavNextItem = "navNextItem",
+    NavToPreviousContainer = "navToPreviousContainer",
+    NavToNextContainer = "navToNextContainer",
+    MovePreviousItem = "movePreviousItem",
+    MoveNextItem = "moveNextItem",
+    MoveToPreviousContainer = "moveToPreviousContainer",
+    MoveToNextContainer = "moveToNextContainer",
     Confirm = "confirm",
+    Edit = "edit",
     Exit = "exit",
-    ToggleHelp = "toggle-help"
+    ViewHelp = "viewHelp",
+    HideHelp = "hideHelp",
+    InitMove = "initMove",
+    ToggleCommandLine = "toggleCommandLine",
+    CaptureInput = "captureInput",
+    EraseInput = "eraseInput",
+    AddItem = "addItem",
+    GetLastCommandFromHistory = "getLastCommandFromHistory",
+    GetNextCommandFromHistory = "getNextCommandFromHistory"
 }
-export declare function getKeyIntent(key: readline.Key, ctx: NavigateCtx): KeyIntent | null;
+export declare function getKeyIntent(key: readline.Key, mode: ModeUnion): Intent | null;

package/dist/navigation/utils/key-intent.js

@@ -1,64 +1,118 @@
-export var KeyIntent;
-(function (KeyIntent) {
-    KeyIntent["NavPreviousItem"] = "nav-previous-item";
-    KeyIntent["NavNextItem"] = "nav-next-item";
-    KeyIntent["NavToPreviousContainer"] = "nav-to-previous-container";
-    KeyIntent["NavToNextContainer"] = "nav-to-next-container";
-    KeyIntent["MovePreviousItem"] = "move-previous-item";
-    KeyIntent["MoveNextItem"] = "move-next-item";
-    KeyIntent["MoveToPreviousContainer"] = "move-to-previous-container";
-    KeyIntent["MoveToNextContainer"] = "move-to-next-container";
-    KeyIntent["Confirm"] = "confirm";
-    KeyIntent["Exit"] = "exit";
-    KeyIntent["ToggleHelp"] = "toggle-help";
-})(KeyIntent || (KeyIntent = {}));
-export function getKeyIntent(key, ctx) {
-    const axis = ctx.navigationNode.childrenRenderAxis;
-    if (key.shift) {
-        switch (key.name) {
-            case 'up':
-                return axis === 'vertical' ? KeyIntent.MovePreviousItem : null;
-            case 'down':
-                return axis === 'vertical' ? KeyIntent.MoveNextItem : null;
-            case 'left':
-                return axis === 'horizontal'
-                    ? KeyIntent.MovePreviousItem
-                    : ctx.navigationNode.enableChildNavigationAcrossContainers
-                        ? KeyIntent.MoveToPreviousContainer
-                        : null;
-            case 'right':
-                return axis === 'horizontal'
-                    ? KeyIntent.MoveNextItem
-                    : ctx.navigationNode.enableChildNavigationAcrossContainers
-                        ? KeyIntent.MoveToNextContainer
-                        : null;
-            default:
-                return null;
-        }
-    }
+import { Mode } from '../model/action-map.model.js';
+import { appState } from '../state/state.js';
+import { getCommandLineIntent } from './get-command-line-intent.js';
+export var Intent;
+(function (Intent) {
+    Intent["NavPreviousItem"] = "navPreviousItem";
+    Intent["NavNextItem"] = "navNextItem";
+    Intent["NavToPreviousContainer"] = "navToPreviousContainer";
+    Intent["NavToNextContainer"] = "navToNextContainer";
+    Intent["MovePreviousItem"] = "movePreviousItem";
+    Intent["MoveNextItem"] = "moveNextItem";
+    Intent["MoveToPreviousContainer"] = "moveToPreviousContainer";
+    Intent["MoveToNextContainer"] = "moveToNextContainer";
+    Intent["Confirm"] = "confirm";
+    Intent["Edit"] = "edit";
+    Intent["Exit"] = "exit";
+    Intent["ViewHelp"] = "viewHelp";
+    Intent["HideHelp"] = "hideHelp";
+    Intent["InitMove"] = "initMove";
+    // Command line
+    Intent["ToggleCommandLine"] = "toggleCommandLine";
+    Intent["CaptureInput"] = "captureInput";
+    Intent["EraseInput"] = "eraseInput";
+    Intent["AddItem"] = "addItem";
+    Intent["GetLastCommandFromHistory"] = "getLastCommandFromHistory";
+    Intent["GetNextCommandFromHistory"] = "getNextCommandFromHistory";
+})(Intent || (Intent = {}));
+function getDir(key) {
     switch (key.name) {
+        // arrows
+        case 'up':
+        case 'down':
+        case 'left':
+        case 'right':
+            return key.name;
+        // vim
+        case 'k':
+            return 'up';
+        case 'j':
+            return 'down';
         case 'h':
-            return KeyIntent.ToggleHelp;
+            return 'left';
+        case 'l':
+            return 'right';
+        default:
+            return null;
+    }
+}
+function mapDirectionalIntent(axis, dir, intents) {
+    const enableAcrossContainers = appState.currentNode.enableChildNavigationAcrossContainers;
+    switch (dir) {
         case 'up':
-            return axis === 'vertical' ? KeyIntent.NavPreviousItem : null;
+            return axis === 'vertical'
+                ? intents.prevItem
+                : enableAcrossContainers
+                    ? intents.prevContainer
+                    : null;
         case 'down':
-            return axis === 'vertical' ? KeyIntent.NavNextItem : null;
+            return axis === 'vertical'
+                ? intents.nextItem
+                : enableAcrossContainers
+                    ? intents.nextContainer
+                    : null;
         case 'left':
             return axis === 'horizontal'
-                ? KeyIntent.NavPreviousItem
-                : ctx.navigationNode.enableChildNavigationAcrossContainers
-                    ? KeyIntent.NavToPreviousContainer
+                ? intents.prevItem
+                : enableAcrossContainers
+                    ? intents.prevContainer
                     : null;
         case 'right':
             return axis === 'horizontal'
-                ? KeyIntent.NavNextItem
-                : ctx.navigationNode.enableChildNavigationAcrossContainers
-                    ? KeyIntent.NavToNextContainer
+                ? intents.nextItem
+                : enableAcrossContainers
+                    ? intents.nextContainer
                     : null;
-        case 'return':
-            return KeyIntent.Confirm;
+    }
+}
+export function getKeyIntent(key, mode) {
+    if (key.sequence === ':')
+        return Intent.ToggleCommandLine;
+    if (mode === Mode.COMMAND_LINE)
+        return getCommandLineIntent(key);
+    // Navigation keys
+    const dir = getDir(key);
+    if (dir) {
+        let dirMap = mode === Mode.MOVE
+            ? {
+                prevItem: Intent.MovePreviousItem,
+                nextItem: Intent.MoveNextItem,
+                prevContainer: Intent.MoveToPreviousContainer,
+                nextContainer: Intent.MoveToNextContainer,
+            }
+            : {
+                prevItem: Intent.NavPreviousItem,
+                nextItem: Intent.NavNextItem,
+                prevContainer: Intent.NavToPreviousContainer,
+                nextContainer: Intent.NavToNextContainer,
+            };
+        return mapDirectionalIntent(appState.currentNode.childrenRenderAxis, dir, dirMap);
+    }
+    // Hard exit
+    if (key.ctrl && key.name === 'c')
+        return Intent.Exit;
+    // Default actions
+    switch (key.name) {
+        case 'i':
+            return Intent.Edit;
+        case 'y':
+            return Intent.InitMove;
         case 'e':
-            return KeyIntent.Exit;
+        case 'return':
+            return Intent.Confirm;
+        case 'q':
+        case 'escape':
+            return Intent.Exit;
         default:
             return null;
     }