epiq 0.0.3 → 0.0.4

package/dist/navigation/actions/move/move-actions-utils.d.ts

@@ -1,5 +1,4 @@
-import { NavigateCtx } from '../../model/navigation-ctx.model.js';
-export declare const moveChildToNextParent: (ctx: NavigateCtx) => void;
-export declare const moveChildToPreviousParent: (ctx: NavigateCtx) => void;
-export declare const moveChildPreviousWithinParent: (ctx: NavigateCtx) => void;
-export declare const moveChildNextWithinParent: (ctx: NavigateCtx) => void;
+export declare const moveChildToNextParent: () => void;
+export declare const moveChildToPreviousParent: () => void;
+export declare const moveChildPreviousWithinParent: () => void;
+export declare const moveChildNextWithinParent: () => void;

package/dist/navigation/actions/move/move-actions-utils.js

@@ -1,3 +1,5 @@
+import { appState } from '../../state/state.js';
+import { navigator } from '../default/navigation-action-utils.js';
 function moveItemInArray({ array, from, to, }) {
     if (from < 0 || from >= array.length || to < 0 || to >= array.length)
         return;
@@ -5,49 +7,60 @@ function moveItemInArray({ array, from, to, }) {
     if (item)
         array.splice(to, 0, item);
 }
-function moveNodeToSiblingContainer(ctx, direction) {
-    const parent = ctx.breadCrumb.at(-1);
-    const grandParent = ctx.breadCrumb.at(-2);
-    if (!parent || !grandParent)
+function moveNodeToSiblingContainer(direction) {
+    const currentNode = appState.breadCrumb.at(-1);
+    const parentNode = appState.breadCrumb.at(-2);
+    if (!currentNode || !parentNode)
         return;
-    if (!Array.isArray(grandParent.children))
+    if (!Array.isArray(parentNode.children))
         return;
-    const parentIndex = grandParent.children.findIndex(x => x.id === parent.id);
-    const targetIndex = parentIndex + direction;
-    if (parentIndex < 0 ||
-        targetIndex < 0 ||
-        targetIndex >= grandParent.children.length)
+    const currentNodeIndex = parentNode.children.findIndex(x => x.id === currentNode.id);
+    const targetNodeIndex = currentNodeIndex + direction;
+    if (currentNodeIndex < 0 ||
+        targetNodeIndex < 0 ||
+        targetNodeIndex >= parentNode.children.length)
         return;
-    const sibling = grandParent.children[targetIndex];
-    if (!sibling)
+    const siblingNode = parentNode.children[targetNodeIndex];
+    if (!siblingNode)
         return;
-    if (!Array.isArray(parent.children))
+    if (!Array.isArray(currentNode.children))
         return;
-    if (!Array.isArray(sibling.children))
-        sibling.children = []; // normalize empty container
-    const currentIndex = ctx.getSelectedIndex();
-    if (currentIndex < 0 || currentIndex >= parent.children.length)
+    if (!Array.isArray(siblingNode.children))
+        siblingNode.children = []; // normalize empty container
+    const currentSelectionIndex = appState.selectedIndex;
+    if (currentSelectionIndex < 0 ||
+        currentSelectionIndex >= currentNode.children.length)
         return;
-    const [node] = parent.children.splice(currentIndex, 1);
-    if (!node)
+    const [moveNode] = currentNode.children.splice(currentSelectionIndex, 1);
+    if (!moveNode)
         return;
-    sibling.children.push(node);
-    const newBreadCrumb = [...ctx.breadCrumb.slice(0, -1), sibling];
-    ctx.reInvokeNavigate(sibling.children.length - 1, newBreadCrumb);
+    siblingNode.children.push(moveNode);
+    navigator.navigate({
+        selectedIndex: siblingNode.children.length - 1,
+        currentNode: siblingNode,
+    });
 }
-export const moveChildToNextParent = (ctx) => moveNodeToSiblingContainer(ctx, 1);
-export const moveChildToPreviousParent = (ctx) => moveNodeToSiblingContainer(ctx, -1);
-function moveChildWithinParent(ctx, direction) {
-    const from = ctx._selectionIndex;
+export const moveChildToNextParent = () => {
+    moveNodeToSiblingContainer(1);
+};
+export const moveChildToPreviousParent = () => {
+    moveNodeToSiblingContainer(-1);
+};
+function moveChildWithinParent(direction) {
+    const from = appState.selectedIndex;
     const to = from + direction;
-    if (to < 0 || to >= ctx.navigationNode.children.length)
+    if (to < 0 || to >= appState.currentNode.children.length)
         return;
     moveItemInArray({
-        array: ctx.navigationNode.children,
+        array: appState.currentNode.children,
         from,
         to,
     });
-    ctx.updateSelection(to);
+    navigator.navigate({ selectedIndex: to });
 }
-export const moveChildPreviousWithinParent = (ctx) => moveChildWithinParent(ctx, -1);
-export const moveChildNextWithinParent = (ctx) => moveChildWithinParent(ctx, 1);
+export const moveChildPreviousWithinParent = () => {
+    moveChildWithinParent(-1);
+};
+export const moveChildNextWithinParent = () => {
+    moveChildWithinParent(1);
+};

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

@@ -1,10 +1,20 @@
 import { Mode } from '../../model/action-map.model.js';
 import { patchState } from '../../state/state.js';
-import { KeyIntent } from '../../utils/key-intent.js';
+import { Intent } from '../../utils/key-intent.js';
 import { moveChildNextWithinParent, moveChildPreviousWithinParent, moveChildToNextParent, moveChildToPreviousParent, } from './move-actions-utils.js';
 export const toggleMoveMode = [
     {
-        intent: KeyIntent.ToggleMove,
+        intent: Intent.Exit,
+        mode: Mode.MOVE,
+        description: '[Y] Exit yank mode',
+        action: () => {
+            patchState({
+                mode: Mode.DEFAULT,
+            });
+        },
+    },
+    {
+        intent: Intent.InitMove,
         mode: Mode.DEFAULT,
         description: '[Y] Toggle move/yank mode',
         action: () => {
@@ -14,7 +24,7 @@ export const toggleMoveMode = [
         },
     },
     {
-        intent: KeyIntent.ToggleMove,
+        intent: Intent.InitMove, // Change name to toggle move?
         mode: Mode.MOVE,
         action: () => {
             patchState({
@@ -25,28 +35,24 @@ export const toggleMoveMode = [
 ];
 export const moveWithinParent = [
     {
-        mode: Mode.MOVE,
-        description: '[Y, ARROW KEYS] Move item',
-    },
-    {
-        intent: KeyIntent.MovePreviousItem,
+        intent: Intent.MovePreviousItem,
         mode: Mode.MOVE,
         action: moveChildPreviousWithinParent,
     },
     {
-        intent: KeyIntent.MoveNextItem,
+        intent: Intent.MoveNextItem,
         mode: Mode.MOVE,
         action: moveChildNextWithinParent,
     },
 ];
 export const moveAcrossParents = [
     {
-        intent: KeyIntent.MoveToNextContainer,
+        intent: Intent.MoveToNextContainer,
         mode: Mode.MOVE,
         action: moveChildToNextParent,
     },
     {
-        intent: KeyIntent.MoveToPreviousContainer,
+        intent: Intent.MoveToPreviousContainer,
         mode: Mode.MOVE,
         action: moveChildToPreviousParent,
     },

package/dist/navigation/command-line/command-line-sequence-actions.d.ts

@@ -1,2 +1,2 @@
 import { CommandLineActionEntry } from '../model/action-map.model.js';
-export declare const commandLineSequenceActions: CommandLineActionEntry[];
+export declare const commands: CommandLineActionEntry[];

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

@@ -1,19 +1,16 @@
 import { addSwimlaneAction, addTicketAction, } from '../actions/add-item/add-item-actions.js';
 import { Mode } from '../model/action-map.model.js';
-import { patchState } from '../state/state.js';
-import { CommandLineSequenceIntent } from './command-line-sequence-intent.js';
-export const commandLineSequenceActions = [
+import { getCommandLineArgumentValue } from '../state/command-line.state.js';
+import { patchState, updateState } from '../state/state.js';
+import { CmdIntent } from './command-line-sequence-intent.js';
+export const commands = [
     {
-        intent: CommandLineSequenceIntent.ViewHelp,
+        intent: CmdIntent.ViewHelp,
         mode: Mode.COMMAND_LINE,
-        action: () => {
-            patchState({
-                mode: Mode.HELP,
-            });
-        },
+        action: () => patchState({ mode: Mode.HELP }),
     },
     {
-        intent: CommandLineSequenceIntent.AddSwimlane,
+        intent: CmdIntent.AddSwimlane,
         mode: Mode.COMMAND_LINE,
         action: (...args) => {
             addSwimlaneAction(...args);
@@ -21,11 +18,27 @@ export const commandLineSequenceActions = [
         },
     },
     {
-        intent: CommandLineSequenceIntent.AddTicket,
+        intent: CmdIntent.AddTicket,
         mode: Mode.COMMAND_LINE,
         action: (...args) => {
             addTicketAction(...args);
             patchState({ mode: Mode.DEFAULT });
         },
     },
+    {
+        intent: CmdIntent.Rename,
+        mode: Mode.COMMAND_LINE,
+        action: () => {
+            updateState(s => ({
+                ...s,
+                mode: Mode.DEFAULT,
+                currentNode: s.currentNode
+                    ? {
+                        ...s.currentNode,
+                        name: getCommandLineArgumentValue(),
+                    }
+                    : null,
+            }));
+        },
+    },
 ];

package/dist/navigation/command-line/command-line-sequence-intent.d.ts

@@ -1,7 +1,8 @@
-export declare const CommandLineSequenceIntent: {
+export declare const CmdIntent: {
     readonly None: "none";
     readonly AddSwimlane: "add-swimlane";
     readonly AddTicket: "add-ticket";
     readonly ViewHelp: "view-help";
+    readonly Rename: "rename";
 };
-export declare const getCommandLineIntent: (command: string) => (typeof CommandLineSequenceIntent)[keyof typeof CommandLineSequenceIntent];
+export declare const getCommandIntent: (command: string) => (typeof CmdIntent)[keyof typeof CmdIntent];

package/dist/navigation/command-line/command-line-sequence-intent.js

@@ -1,29 +1,32 @@
 import { BoardItemTypes } from '../../board/model/board.model.js';
-import { navigationState } from '../state/state.js';
-export const CommandLineSequenceIntent = {
+import { appState } from '../state/state.js';
+export const CmdIntent = {
     None: 'none',
     AddSwimlane: 'add-swimlane',
     AddTicket: 'add-ticket',
     ViewHelp: 'view-help',
+    Rename: 'rename',
 };
-export const getCommandLineIntent = (command) => {
-    const actionContext = navigationState?.currentNode?.actionContext;
+export const getCommandIntent = (command) => {
+    const actionContext = appState?.currentNode?.actionContext;
     if (!actionContext)
-        return CommandLineSequenceIntent.None;
+        return CmdIntent.None;
     switch (command) {
         case 'help':
         case 'he':
-            return CommandLineSequenceIntent.ViewHelp;
+            return CmdIntent.ViewHelp;
+        case 'rename':
+            return CmdIntent.Rename;
         case 'add':
             switch (actionContext) {
                 case BoardItemTypes.SWIMLANE:
-                    return CommandLineSequenceIntent.AddSwimlane;
+                    return CmdIntent.AddSwimlane;
                 case BoardItemTypes.TICKET:
-                    return CommandLineSequenceIntent.AddTicket;
+                    return CmdIntent.AddTicket;
                 default:
-                    return CommandLineSequenceIntent.None;
+                    return CmdIntent.None;
             }
         default:
-            return CommandLineSequenceIntent.None;
+            return CmdIntent.None;
     }
 };

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

@@ -0,0 +1,2 @@
+import { CommandLineActionEntry } from '../model/action-map.model.js';
+export declare const commands: CommandLineActionEntry[];

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

@@ -0,0 +1,58 @@
+import { addSwimlaneAction, addTicketAction, } from '../actions/add-item/add-item-actions.js';
+import { Mode } from '../model/action-map.model.js';
+import { getCommandLineArgumentValue } from '../state/command-line.state.js';
+import { appState, patchState, updateState } from '../state/state.js';
+import { CmdIntent } from './command-line-sequence-intent.js';
+export const commands = [
+    {
+        intent: CmdIntent.ViewHelp,
+        mode: Mode.COMMAND_LINE,
+        action: () => patchState({ mode: Mode.HELP }),
+    },
+    {
+        intent: CmdIntent.AddSwimlane,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addSwimlaneAction(...args);
+            patchState({ mode: Mode.DEFAULT });
+        },
+    },
+    {
+        intent: CmdIntent.AddTicket,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addTicketAction(...args);
+            patchState({ mode: Mode.DEFAULT });
+        },
+    },
+    {
+        intent: CmdIntent.Rename,
+        mode: Mode.COMMAND_LINE,
+        action: () => {
+            updateState(s => {
+                // Update board on file
+                const newBoard = appState.rootNode;
+                const currentId = s.currentNode?.id;
+                if (!currentId)
+                    return s;
+                const findItemInBoard = (item, id) => {
+                    if (item.id === id)
+                        return item;
+                    return (item.children.find((child) => findItemInBoard(child, id)) ||
+                        undefined);
+                };
+                const newName = getCommandLineArgumentValue();
+                const itemInBoard = findItemInBoard(newBoard, currentId);
+                if (!itemInBoard)
+                    return s;
+                itemInBoard.name = newName;
+                return {
+                    ...s,
+                    mode: Mode.DEFAULT,
+                    rootNode: newBoard,
+                    currentNode: itemInBoard,
+                };
+            });
+        },
+    },
+];

package/dist/navigation/keypress-listener.d.ts

@@ -0,0 +1 @@
+export declare function initListeners(): void;

package/dist/navigation/keypress-listener.js

@@ -0,0 +1,33 @@
+import readline from 'readline';
+import { appState } from './state/state.js';
+import { getKeyIntent } from './utils/key-intent.js';
+import { navigator } from './actions/default/navigation-action-utils.js';
+let currentKeypressListener;
+const getKeyPressListener = () => {
+    return async function onKeyPress(_, key) {
+        if (key.ctrl && key.name === 'c')
+            return navigator.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(navigator, actionMeta, key);
+            if (res instanceof Promise)
+                await res;
+        }
+        catch (err) {
+            console.error(err);
+        }
+    };
+};
+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', currentKeypressListener);
+}

package/dist/navigation/model/action-map.model.d.ts

@@ -1,4 +1,4 @@
-import { NavigateCtx } from './navigation-ctx.model.js';
+import { Navigator } from '../actions/default/navigation-action-utils.js';
 import readline from 'readline';
 export declare const Mode: {
     readonly DEFAULT: "default";
@@ -9,9 +9,9 @@ export declare const Mode: {
 export type ModeUnion = (typeof Mode)[keyof typeof Mode];
 export type ActionEntry = {
     intent?: string;
-    mode: ModeUnion | ModeUnion[];
+    mode: ModeUnion;
     description?: `[${string}] ${string}`;
-    action?: (...args: [NavigateCtx, ActionEntry, readline.Key]) => void | Promise<void>;
+    action?: (...args: [Navigator, ActionEntry, readline.Key]) => void | Promise<void>;
 };
 export type ActionMap<T extends Record<string, any[]>> = {
     [K in keyof T]: ActionEntry[];
@@ -21,6 +21,6 @@ type CommandLineInput = {
     command: string;
 };
 export type CommandLineActionEntry = Omit<ActionEntry, 'action'> & {
-    action?: (...args: [NavigateCtx, CommandLineActionEntry, CommandLineInput]) => void | Promise<void>;
+    action?: (...args: [Navigator, CommandLineActionEntry, CommandLineInput]) => void | Promise<void>;
 };
 export {};

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

@@ -1,16 +1 @@
-import { NavigationTree } from './navigation-tree.model.js';
-export interface NavigateCtx {
-    _selectionIndex: number;
-    breadCrumb: Array<NavigationTree<NavigationTree>>;
-    navigationNode: NavigationTree<NavigationTree>;
-    children: NavigationTree[];
-    getSelectedIndex(): number;
-    updateSelection(index: number): void;
-    selectNone(): void;
-    reInvokeNavigate(index: number, breadCrumb: NavigationTree<NavigationTree>[]): void;
-    render(): void;
-    confirm(selected: NavigationTree<NavigationTree>): void;
-    exit(): void;
-    enterChildNode(node: NavigationTree<NavigationTree>): void;
-    enterParentNode(): void;
-}
+export {};

package/dist/navigation/model/navigation-ctx.model.js

@@ -1,2 +1 @@
-// navigation-context.ts
 export {};

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

@@ -1,3 +1,4 @@
+import { BoardItemTypes } from '../../board/model/board.model.js';
 export type NavigationTree<TMeta = Record<string, unknown>> = {
     id: string;
     isSelected: boolean;
@@ -5,6 +6,6 @@ export type NavigationTree<TMeta = Record<string, unknown>> = {
     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] | undefined, 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,88 +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 ctx = {
-        _selectionIndex: 0,
-        breadCrumb: breadCrumb,
-        render() {
-            callbacks.render?.();
-        },
-        get navigationNode() {
-            return this.breadCrumb?.at(-1) ?? breadCrumb[0];
-        },
-        get children() {
-            return this.navigationNode.children ?? [];
-        },
-        selectNone() {
-            ctx.updateSelection(-1);
-        },
-        getSelectedIndex() {
-            return this._selectionIndex;
-        },
-        updateSelection(idx) {
-            this._selectionIndex = idx;
-            const children = this.navigationNode.children ?? [];
-            children.forEach((c, i) => (c.isSelected = i === idx));
-            if (idx < 0 || idx >= children.length) {
-                callbacks.onSelectChange?.(undefined, breadCrumb);
-                return;
-            }
-            callbacks.onSelectChange?.(children[idx], breadCrumb);
-        },
-        reInvokeNavigate(idx, crumb) {
-            cleanup();
-            navigate({ index: idx, breadCrumb: [...crumb], callbacks });
-        },
-        confirm(sel) {
-            return callbacks.onConfirm?.(sel);
-        },
-        exit() {
-            cleanup();
-            process.exit(0);
-        },
-        enterChildNode(childNode) {
-            this.updateSelection(-1); // Clear all on this level
-            this.reInvokeNavigate(0, [...breadCrumb, childNode]);
-        },
-        enterParentNode() {
-            ctx.updateSelection(-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);
-            this.reInvokeNavigate(parentIndex, breadCrumb.slice(0, -1)); // Go to parent level
-        },
-    };
-    ctx.updateSelection(index);
-    async function onKeyPress(_, key) {
-        if (key.ctrl && key.name === 'c')
-            return ctx.exit();
-        const filteredActions = navigationState.availableActions.filter(x => x.mode === navigationState.mode);
-        const actionMeta = filteredActions.find(actionMetaItem => {
-            const intent = getKeyIntent(key, ctx, navigationState.mode);
-            return intent === actionMetaItem.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
+            };
+        });
+    },
+    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,
         });
-        if (actionMeta?.action) {
-            try {
-                const res = actionMeta.action(ctx, actionMeta, key);
-                if (res instanceof Promise)
-                    await res;
-            }
-            catch (err) {
-                console.error(err);
-            }
+        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);
         }
-        ctx.render();
+    };
+};
+export function initListeners() {
+    if (currentKeypressListener) {
+        process.stdin.removeListener('keypress', currentKeypressListener);
     }
-    const cleanup = () => process.stdin.removeListener('keypress', onKeyPress);
-    callbacks.render?.();
+    currentKeypressListener = getKeyPressListener();
     readline.emitKeypressEvents(process.stdin);
     if (process.stdin.isTTY)
         process.stdin.setRawMode(true);
-    process.stdin.on('keypress', onKeyPress);
+    process.stdin.on('keypress', currentKeypressListener);
 }

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

@@ -1,9 +1,12 @@
+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;
@@ -11,3 +14,5 @@ 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 {};