epiq 0.0.3 → 0.0.5

package/dist/cli.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 import './debug-logger.js';
-export declare let triggerRender: () => void;
+export declare let renderBoard: () => void;

package/dist/cli.js

@@ -1,80 +1,39 @@
 #!/usr/bin/env node
+import './debug-logger.js';
 import { render } from 'ink';
 import meow from 'meow';
 import React from 'react';
 import App from './app.js';
-import { Hints } from './board/hints/hints.js';
+import { initListeners } from './navigation/keypress-listener.js';
+import { appState, initAppState } from './navigation/state/state.js';
 import { board } from './board/mock/board.js';
-import { ContextualActionMap } from './navigation/actions/board-action-map.js';
-import { inputActions } from './navigation/actions/input/input-actions.js';
-import { DefaultActions } from './navigation/actions/default/default-actions.js';
-import { navigate } from './navigation/navigation.js';
-import { patchState, updateState } from './navigation/state/state.js';
-import './debug-logger.js';
+import { initProject } from './init-project.js';
 const cli = meow(`
-	Usage
+	  View board in directory:
 	  $ epiq
 
-	Options
-		--name  Your name
-
-	Examples
-	  $ epiq --name=Jane
-	  Hello, Jane
+	  Init project in directory:
+	  $ epiq --init "Project Name"
 `, {
     importMeta: import.meta,
     flags: {
-        name: {
+        init: {
             type: 'string',
         },
     },
 });
 cli;
+export let renderBoard = () => {
+    render(React.createElement(App, { board: appState.rootNode }));
+};
+process.stdout.on('resize', () => renderBoard());
 (() => {
-    console.clear();
-    const onBeforeRender = () => {
-        updateState(state => {
-            const { currentNode, mode } = state;
-            const hints = (currentNode && Hints[currentNode.actionContext + mode]) ??
-                (currentNode && Hints[currentNode.actionContext]) ?? [''];
-            return {
-                ...state,
-                availableHints: hints,
-            };
-        });
-    };
-    navigate({
-        index: 0,
-        breadCrumb: [board],
-        callbacks: {
-            render: () => {
-                onBeforeRender();
-                render(React.createElement(App, { board: board }));
-            },
-            onSelectChange: (selected, breadCrumb) => {
-                // container is the "list" we are navigating in (board → swimlanes, swimlane → tickets, etc)
-                const container = breadCrumb.at(-1);
-                // still remember which *child* is selected for rendering
-                const currentNode = selected ?? container;
-                // but build actions from the container type, not the selected child
-                const containerType = container
-                    .actionContext;
-                patchState({
-                    currentNode,
-                    breadCrumb,
-                    availableActions: [
-                        ...DefaultActions,
-                        ...ContextualActionMap[containerType],
-                        ...inputActions,
-                    ],
-                });
-            },
-        },
-    });
+    debug(cli);
+    if (cli.flags.init) {
+        initProject();
+    }
+    else if (!Object.keys(cli.flags).length) {
+        initAppState(board);
+        initListeners();
+    }
 })();
-export let triggerRender = () => {
-    render(React.createElement(App, { board: board }));
-};
-process.stdout.on('resize', () => {
-    render(React.createElement(App, { board: board }));
-});

package/dist/debug-logger.d.ts

@@ -1,2 +1,2 @@
-export declare function bug(...args: any[]): void;
+export declare function debug(...args: any[]): void;
 export {};

package/dist/debug-logger.js

@@ -2,14 +2,15 @@ import fs from 'fs';
 import path from 'path';
 import util from 'util';
 const DEFAULT_PATH = path.resolve(process.cwd(), 'debug.log');
-export function bug(...args) {
-    const timestamp = new Date().toISOString();
+export function debug(...args) {
+    // const timestamp = new Date().toISOString();
     const message = util.format(...args);
-    const line = `[${timestamp}] ${message}\n`;
+    // const line = `[${timestamp}] ${message}\n`;
+    const line = `${message}\n`;
     // Ensure parent directory exists
     fs.mkdirSync(path.dirname(DEFAULT_PATH), { recursive: true });
     // appendFileSync creates the file if it does not exist
     fs.appendFileSync(DEFAULT_PATH, line, 'utf8');
 }
 // make it global
-globalThis.bug = bug;
+globalThis.debug = debug;

package/dist/init-project.d.ts

@@ -0,0 +1 @@
+export declare const initProject: () => void;

package/dist/init-project.js

@@ -0,0 +1 @@
+export const initProject = () => console.log('initProject');

package/dist/navigation/actions/add-item/add-item-actions.js

@@ -1,35 +1,45 @@
 import { BoardItemTypes, } from '../../../board/model/board.model.js';
-export const addSwimlaneAction = async (ctx, _, { value }) => {
+import { appState } from '../../state/state.js';
+import { navigator } from '../default/navigation-action-utils.js';
+export const addSwimlaneAction = async (_ctx, _cmd, { value }) => {
     const newItem = {
         id: `${Date.now()}`,
         name: value || 'New lane',
         description: '...',
         actionContext: BoardItemTypes.SWIMLANE,
-        children: [],
         isSelected: false,
         childrenRenderAxis: 'vertical',
         enableChildNavigationAcrossContainers: true,
+        children: [],
     };
-    const parent = ctx.navigationNode;
+    const parent = appState.currentNode;
     parent.children ?? (parent.children = []);
     const newItemIndex = parent.children.length;
     parent.children.push(newItem);
-    ctx.updateSelection(newItemIndex);
+    navigator.navigate({ selectedIndex: newItemIndex });
 };
-export const addTicketAction = async (ctx, _, { value }) => {
+export const addTicketAction = async (_ctx, _cmd, { value }) => {
     const newItem = {
-        id: `asdf${Date.now()}`,
+        id: `${Date.now()}`,
         name: value || 'New issue',
         actionContext: BoardItemTypes.TICKET_LIST_ITEM,
-        children: [],
         isSelected: false,
         childrenRenderAxis: 'vertical',
-        enableChildNavigationAcrossContainers: true,
-        description: '',
+        children: [
+            {
+                isSelected: false,
+                id: `${Date.now()}`,
+                name: 'Description',
+                description: '...add description',
+                actionContext: BoardItemTypes.TICKET,
+                childrenRenderAxis: 'vertical',
+                children: [],
+            },
+        ],
     };
-    const parent = ctx.navigationNode;
+    const parent = appState.currentNode;
     parent.children ?? (parent.children = []);
     const newItemIndex = parent.children.length;
     parent.children.push(newItem);
-    ctx.updateSelection(newItemIndex);
+    navigator.navigate({ selectedIndex: newItemIndex });
 };

package/dist/navigation/actions/board-action-map.js

@@ -1,12 +1,12 @@
 import { BoardItemTypes } from '../../board/model/board.model.js';
 import { moveAcrossParents, moveWithinParent, toggleMoveMode, } from './move/move-actions.js';
 export const ContextualActionMap = {
-    [BoardItemTypes.BOARD]: [],
-    [BoardItemTypes.SWIMLANE]: [...toggleMoveMode, ...moveWithinParent],
-    [BoardItemTypes.TICKET_LIST_ITEM]: [
+    [BoardItemTypes.BOARD]: [...toggleMoveMode, ...moveWithinParent],
+    [BoardItemTypes.SWIMLANE]: [
         ...toggleMoveMode,
         ...moveWithinParent,
         ...moveAcrossParents,
     ],
+    [BoardItemTypes.TICKET_LIST_ITEM]: [],
     [BoardItemTypes.TICKET]: [],
 };

package/dist/navigation/actions/default/default-action-utils.d.ts

@@ -1,7 +1,8 @@
-import { NavigateCtx } from '../../model/navigation-ctx.model.js';
-export declare const navigateToNextItem: (ctx: NavigateCtx) => void;
-export declare const navigateToPreviousItem: (ctx: NavigateCtx) => void;
-export declare const navigateToNextContainer: (ctx: NavigateCtx) => void;
-export declare const navigateToPreviousContainer: (ctx: NavigateCtx) => void;
-export declare const enterChildNode: (ctx: NavigateCtx) => Promise<void>;
-export declare const exitToParentNode: (ctx: NavigateCtx) => void;
+import { NavigateUtils } from '../../model/navigation-ctx.model.js';
+export declare const navigationUtils: NavigateUtils;
+export declare const navigateToNextItem: () => void;
+export declare const navigateToPreviousItem: () => void;
+export declare const navigateToNextContainer: (ctx: NavigateUtils) => void;
+export declare const navigateToPreviousContainer: (ctx: NavigateUtils) => void;
+export declare const enterChildNode: (ctx: NavigateUtils) => Promise<void>;
+export declare const exitToParentNode: (ctx: NavigateUtils) => void;

package/dist/navigation/actions/default/default-action-utils.js

@@ -1,17 +1,67 @@
-const navigateByOffset = (ctx, offset) => {
-    const len = ctx.children.length;
+import { appState, patchState, updateState } from '../../state/state.js';
+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
+            };
+        });
+    },
+    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 navigateByOffset = (offset) => {
+    const len = appState.currentNode.children.length;
     if (len === 0)
         return;
-    const newIndex = (ctx.getSelectedIndex() + offset + len) % len;
-    ctx.updateSelection(newIndex);
+    const newIndex = (appState.selectedIndex + offset + len) % len;
+    navigationUtils.updateSelection(newIndex);
 };
-export const navigateToNextItem = (ctx) => navigateByOffset(ctx, 1);
-export const navigateToPreviousItem = (ctx) => navigateByOffset(ctx, -1);
+export const navigateToNextItem = () => navigateByOffset(1);
+export const navigateToPreviousItem = () => navigateByOffset(-1);
 const navigateToSiblingContainer = (ctx, direction) => {
-    if (!ctx.navigationNode.enableChildNavigationAcrossContainers)
+    if (!appState.currentNode.enableChildNavigationAcrossContainers)
         return;
-    const parent = ctx.breadCrumb.at(-1);
-    const grandParent = ctx.breadCrumb.at(-2);
+    const parent = appState.breadCrumb.at(-1);
+    const grandParent = appState.breadCrumb.at(-2);
     if (!parent || !grandParent)
         return;
     const parentIndex = grandParent.children.findIndex(x => x.id === parent.id);
@@ -21,19 +71,19 @@ const navigateToSiblingContainer = (ctx, direction) => {
     const nextSibling = sliced.find(x => x.children.length);
     if (!nextSibling?.children?.length)
         return;
-    const prevIndex = ctx.getSelectedIndex();
+    const prevIndex = appState.selectedIndex;
     const boundedIndex = Math.min(prevIndex, nextSibling.children.length - 1);
     ctx.selectNone();
-    ctx.reInvokeNavigate(boundedIndex, [
-        ...ctx.breadCrumb.slice(0, -1),
-        nextSibling,
-    ]);
+    patchState({
+        selectedIndex: boundedIndex,
+        breadCrumb: [...appState.breadCrumb.slice(0, -1), nextSibling],
+    });
 };
 export const navigateToNextContainer = (ctx) => navigateToSiblingContainer(ctx, 1);
 export const navigateToPreviousContainer = (ctx) => navigateToSiblingContainer(ctx, -1);
 export const enterChildNode = async (ctx) => {
-    const currentNode = ctx.breadCrumb.at(-1);
-    const focusNode = currentNode?.children[ctx.getSelectedIndex()];
+    const currentNode = appState.breadCrumb.at(-1);
+    const focusNode = currentNode?.children[appState.selectedIndex];
     if (!currentNode || !focusNode)
         return;
     if (!focusNode?.children?.length) {
@@ -45,7 +95,7 @@ export const enterChildNode = async (ctx) => {
     }
 };
 export const exitToParentNode = (ctx) => {
-    if (ctx.breadCrumb.length >= 2) {
+    if (appState.breadCrumb.length >= 2) {
         ctx.enterParentNode();
     }
 };

package/dist/navigation/actions/default/default-actions.js

@@ -1,78 +1,64 @@
+import { CmdIntent } from '../../command-line/command-line-sequence-intent.js';
 import { Mode } from '../../model/action-map.model.js';
-import { patchState } from '../../state/state.js';
-import { KeyIntent } from '../../utils/key-intent.js';
-import { enterChildNode, exitToParentNode, navigateToNextContainer, navigateToNextItem, navigateToPreviousContainer, navigateToPreviousItem, } from './default-action-utils.js';
+import { updateCommandLineInput } from '../../state/command-line.state.js';
+import { appState, patchState } from '../../state/state.js';
+import { Intent } from '../../utils/key-intent.js';
+import { navigator } from './navigation-action-utils.js';
 export const DefaultActions = [
     {
-        intent: KeyIntent.ToggleCommandLine,
+        intent: Intent.ToggleCommandLine,
         mode: Mode.DEFAULT,
         description: '[:] Toggle command line',
-        action: () => patchState({
-            mode: Mode.COMMAND_LINE,
-        }),
+        action: () => patchState({ mode: Mode.COMMAND_LINE }),
     },
     {
-        intent: KeyIntent.ToggleCommandLine,
+        intent: Intent.ToggleCommandLine,
         mode: Mode.COMMAND_LINE,
         description: '[ESC] Toggle command line',
-        action: () => patchState({
-            mode: Mode.DEFAULT,
-        }),
+        action: () => patchState({ mode: Mode.DEFAULT }),
     },
-    // {
-    // 	intent: KeyIntent.ToggleHelp,
-    // 	mode: Mode.DEFAULT,
-    // 	description: '[F1] Toggle HELP menu',
-    // 	action: () =>
-    // 		setState(state => ({
-    // 			...state,
-    // 			mode: Mode.HELP,
-    // 		})),
-    // },
-    // {
-    // 	intent: KeyIntent.ToggleHelp,
-    // 	mode: Mode.HELP,
-    // 	description: '[F1] Close HELP menu',
-    // 	action: () =>
-    // 		setState(state => ({
-    // 			...state,
-    // 			mode: Mode.DEFAULT,
-    // 		})),
-    // },
     {
-        intent: KeyIntent.Confirm,
+        intent: Intent.Confirm,
         mode: Mode.DEFAULT,
-        description: '[ENTER/E] Confirm/Enter context',
-        action: enterChildNode,
+        description: '[ENTER] Confirm/Enter context',
+        action: navigator.enterChildNode,
     },
     {
-        intent: KeyIntent.Exit,
+        intent: Intent.Exit,
         mode: Mode.DEFAULT,
         description: '[ESC/Q] Exit application',
-        action: exitToParentNode,
+        action: navigator.enterParentNode,
     },
     {
         mode: Mode.DEFAULT,
         description: '[ARROWS/HJKL] Navigate',
     },
     {
-        intent: KeyIntent.NavPreviousItem,
+        intent: Intent.NavPreviousItem,
         mode: Mode.DEFAULT,
-        action: navigateToPreviousItem,
+        action: navigator.navigateToPreviousItem,
     },
     {
-        intent: KeyIntent.NavNextItem,
+        intent: Intent.NavNextItem,
         mode: Mode.DEFAULT,
-        action: navigateToNextItem,
+        action: navigator.navigateToNextItem,
     },
     {
-        intent: KeyIntent.NavToPreviousContainer,
+        intent: Intent.NavToPreviousContainer,
         mode: Mode.DEFAULT,
-        action: navigateToPreviousContainer,
+        action: navigator.navigateToPreviousContainer,
     },
     {
-        intent: KeyIntent.NavToNextContainer,
+        intent: Intent.NavToNextContainer,
         mode: Mode.DEFAULT,
-        action: navigateToNextContainer,
+        action: navigator.navigateToNextContainer,
+    },
+    {
+        intent: Intent.Edit,
+        mode: Mode.DEFAULT,
+        action: () => {
+            patchState({ mode: Mode.COMMAND_LINE });
+            updateCommandLineInput(() => `${CmdIntent.Rename} ${appState.currentNode?.name}`);
+        },
     },
 ];

package/dist/navigation/actions/default/navigation-action-utils.d.ts

@@ -0,0 +1,16 @@
+import { NavigationTree } from '../../model/navigation-tree.model.js';
+export interface Navigator {
+    navigate({ currentNode, selectedIndex, }: {
+        currentNode?: NavigationTree<NavigationTree>;
+        selectedIndex: number;
+    }): void;
+    confirm(selected: NavigationTree<NavigationTree>): void;
+    exit(): void;
+    enterChildNode(): void;
+    enterParentNode(): void;
+    navigateToNextItem: () => void;
+    navigateToPreviousItem: () => void;
+    navigateToNextContainer: () => void;
+    navigateToPreviousContainer: () => void;
+}
+export declare const navigator: Navigator;

package/dist/navigation/actions/default/navigation-action-utils.js

@@ -0,0 +1,109 @@
+import { appState, patchState } from '../../state/state.js';
+export const navigator = {
+    confirm(sel) {
+        console.log(sel);
+    },
+    exit() {
+        process.exit(0);
+    },
+    enterChildNode() {
+        const currentNode = appState.currentNode;
+        const focusNode = currentNode?.children[appState.selectedIndex];
+        if (!currentNode || !focusNode)
+            return;
+        navigator.navigate({
+            currentNode: focusNode,
+            selectedIndex: 0,
+        });
+    },
+    enterParentNode() {
+        const breadCrumb = appState.breadCrumb;
+        if (breadCrumb.length < 2)
+            return;
+        const prevNode = breadCrumb.at(-1);
+        if (!prevNode)
+            return;
+        const newCurrentNode = breadCrumb.at(-2);
+        const newIndex = newCurrentNode?.children?.findIndex(x => x.id === prevNode.id) ?? 0;
+        navigator.navigate({
+            currentNode: newCurrentNode,
+            selectedIndex: newIndex,
+        });
+    },
+    navigateToNextItem: () => navigateByOffset(1),
+    navigateToPreviousItem: () => navigateByOffset(-1),
+    navigateToNextContainer: () => navigateToSiblingContainer(1),
+    navigateToPreviousContainer: () => navigateToSiblingContainer(-1),
+    navigate: ({ currentNode, selectedIndex }) => {
+        if (!currentNode) {
+            currentNode = appState.currentNode;
+        }
+        const findBreadCrumb = (node, targetId, path = []) => {
+            const nextPath = [...path, node];
+            if (node.id === targetId)
+                return nextPath;
+            for (const child of node.children ?? []) {
+                const found = findBreadCrumb(child, targetId, nextPath);
+                if (found.length)
+                    return found;
+            }
+            return [];
+        };
+        const setIsSelected = (node, targetId, selectedIndex) => {
+            // Clear selection for all children at this node
+            for (const child of node.children ?? []) {
+                child.isSelected = false;
+                setIsSelected(child, targetId, selectedIndex);
+            }
+            // If this is the target container, select its child at selectedIndex
+            if (node.id === targetId) {
+                const children = node.children;
+                const idx = Math.max(0, Math.min(selectedIndex, children.length - 1));
+                if (children[idx]) {
+                    children[idx].isSelected = true;
+                }
+            }
+        };
+        const root = appState.rootNode;
+        const breadCrumb = findBreadCrumb(root, currentNode.id);
+        setIsSelected(root, currentNode.id, selectedIndex);
+        patchState({
+            breadCrumb,
+            currentNode,
+            selectedIndex,
+        });
+    },
+};
+const navigateByOffset = (offset) => {
+    const len = appState.currentNode.children.length;
+    if (len === 0)
+        return;
+    const newIndex = (appState.selectedIndex + offset + len) % len;
+    navigator.navigate({ selectedIndex: newIndex });
+};
+const navigateToSiblingContainer = (direction) => {
+    if (!appState.currentNode.enableChildNavigationAcrossContainers)
+        return;
+    const currentNode = appState.breadCrumb.at(-1);
+    const parentNode = appState.breadCrumb.at(-2);
+    if (!currentNode || !parentNode)
+        return;
+    const siblings = parentNode.children ?? [];
+    const currentNodeIndex = siblings.findIndex(x => x.id === currentNode.id);
+    if (currentNodeIndex < 0)
+        return;
+    // Look for the next sibling "container" that actually has children
+    const candidates = direction === -1
+        ? siblings.slice(0, currentNodeIndex).toReversed()
+        : siblings.slice(currentNodeIndex + 1);
+    const nextSibling = candidates.find(x => (x.children?.length ?? 0) > 0);
+    if (!nextSibling?.children?.length)
+        return;
+    // Keep the same child index if possible, otherwise clamp to last child
+    const prevIndex = appState.selectedIndex;
+    const boundedIndex = Math.min(prevIndex, nextSibling.children.length - 1);
+    navigator.navigate({
+        currentNode: nextSibling,
+        selectedIndex: boundedIndex,
+    });
+};

package/dist/navigation/actions/input/command-line-input.js

@@ -1,5 +1,5 @@
-import { commandLineSequenceActions } from '../../command-line/command-line-sequence-actions.js';
-import { getCommandLineIntent } from '../../command-line/command-line-sequence-intent.js';
+import { getCommandIntent } from '../../command-line/command-line-sequence-intent.js';
+import { commands } from '../../command-line/commands.js';
 import { clearCommandLine, getCommandLineInput, updateCommandHistory, } from '../../state/command-line.state.js';
 export const onConfirmCommandLineSequenceInput = (...args) => {
     const commandSequence = getCommandLineInput();
@@ -9,8 +9,8 @@ export const onConfirmCommandLineSequenceInput = (...args) => {
     const value = rest.join(' ').trim();
     if (!command)
         return;
-    const intent = getCommandLineIntent(command);
-    const actionMeta = commandLineSequenceActions.find(x => x.intent === intent);
+    const intent = getCommandIntent(command);
+    const actionMeta = commands.find(x => x.intent === intent);
     actionMeta?.action?.(ctx, actionMeta, { command, value });
     updateCommandHistory();
     clearCommandLine();

package/dist/navigation/actions/input/input-actions.js

@@ -1,42 +1,43 @@
 import { Mode } from '../../model/action-map.model.js';
 import { getNextCommand, getPrevCommand, updateCommandLineInput, } from '../../state/command-line.state.js';
 import { patchState } from '../../state/state.js';
-import { KeyIntent } from '../../utils/key-intent.js';
+import { Intent } from '../../utils/key-intent.js';
 import { onConfirmCommandLineSequenceInput } from './command-line-input.js';
 export const inputActions = [
     {
-        intent: KeyIntent.ToggleHelp,
+        intent: Intent.ViewHelp,
+        mode: Mode.DEFAULT,
+        action: () => patchState({ mode: Mode.HELP }),
+    },
+    {
+        intent: Intent.Exit,
         mode: Mode.HELP,
-        action: () => {
-            patchState({
-                mode: Mode.DEFAULT,
-            });
-        },
+        action: () => patchState({ mode: Mode.DEFAULT }),
     },
     {
-        intent: KeyIntent.Confirm,
+        intent: Intent.Confirm,
         mode: Mode.COMMAND_LINE,
         action: (...args) => {
             onConfirmCommandLineSequenceInput(...args);
         },
     },
     {
-        intent: KeyIntent.CaptureInput,
+        intent: Intent.CaptureInput,
         mode: Mode.COMMAND_LINE,
         action: (_1, _2, { sequence }) => updateCommandLineInput(s => s + sequence),
     },
     {
-        intent: KeyIntent.EraseInput,
+        intent: Intent.EraseInput,
         mode: Mode.COMMAND_LINE,
         action: () => updateCommandLineInput(s => s.slice(0, -1)),
     },
     {
-        intent: KeyIntent.GetLastCommandFromHistory,
+        intent: Intent.GetLastCommandFromHistory,
         mode: Mode.COMMAND_LINE,
         action: () => getPrevCommand(),
     },
     {
-        intent: KeyIntent.GetNextCommandFromHistory,
+        intent: Intent.GetNextCommandFromHistory,
         mode: Mode.COMMAND_LINE,
         action: () => getNextCommand(),
     },