epiq 0.0.2 → 0.0.4

package/dist/cli.js

@@ -1,57 +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 { BoardActions } from './board/actions/board-action-map.js';
+import { initListeners } from './navigation/keypress-listener.js';
+import { appState, initAppState } from './navigation/state/state.js';
 import { board } from './board/mock/board.js';
-import { buildDefaultActions } from './navigation/actions/default-actions-routes.js';
-import { navigate } from './navigation/navigation.js';
-import { setState } from './navigation/state/state.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 const main = () => {
-    console.clear();
-    navigate({
-        index: 0,
-        breadCrumb: [board],
-        callbacks: {
-            render: () => {
-                render(React.createElement(App, { board: board }));
-            },
-            onSelectChange: (selected, breadCrumb) => {
-                if (!selected)
-                    return;
-                const type = selected
-                    .actionContext; // Fix so that we can infer this type
-                setState(state => ({
-                    ...state,
-                    currentNode: selected,
-                    breadCrumb,
-                    availableActions: [...buildDefaultActions(), ...BoardActions[type]],
-                }));
-            },
-        },
-    });
+export let renderBoard = () => {
+    render(React.createElement(App, { board: appState.rootNode }));
 };
-main();
-process.stdout.on('resize', () => {
-    render(React.createElement(App, { board: board }));
-});
+process.stdout.on('resize', () => renderBoard());
+(() => {
+    debug(cli);
+    if (cli.flags.init) {
+        initProject();
+    }
+    else if (!Object.keys(cli.flags).length) {
+        initAppState(board);
+        initListeners();
+    }
+})();

package/dist/debug-logger.d.ts

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

package/dist/debug-logger.js

@@ -0,0 +1,16 @@
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+const DEFAULT_PATH = path.resolve(process.cwd(), 'debug.log');
+export function debug(...args) {
+    // const timestamp = new Date().toISOString();
+    const message = util.format(...args);
+    // 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.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/add-actions.d.ts

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

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

@@ -0,0 +1,25 @@
+import { board } from '../../../board/mock/board.js';
+import { triggerRender } from '../../../cli.js';
+import { Mode } from '../../model/action-map.model.js';
+import { KeyIntent } from '../../utils/key-intent.js';
+export const AddItemActions = [
+    {
+        intent: KeyIntent.AddItem,
+        mode: Mode.DEFAULT,
+        description: '[A] Add item',
+        action: () => {
+            const newItem = {
+                id: `item-${Date.now()}`,
+                name: 'New Item',
+                actionContext: 'SWIMLANE',
+                children: [],
+                isSelected: false,
+                childrenRenderAxis: 'vertical',
+                enableChildNavigationAcrossContainers: true,
+                description: '',
+            };
+            board.children.push(newItem);
+            triggerRender();
+        },
+    },
+];

package/dist/navigation/actions/add/add-item-actions.d.ts

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

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

@@ -0,0 +1,25 @@
+import { board } from '../../../board/mock/board.js';
+import { triggerRender } from '../../../cli.js';
+import { Mode } from '../../model/action-map.model.js';
+import { KeyIntent } from '../../utils/key-intent.js';
+export const AddItemActions = [
+    {
+        intent: KeyIntent.AddItem,
+        mode: Mode.DEFAULT,
+        description: '[A] Add item',
+        action: () => {
+            const newItem = {
+                id: `item-${Date.now()}`,
+                name: 'New Item',
+                actionContext: 'SWIMLANE',
+                children: [],
+                isSelected: false,
+                childrenRenderAxis: 'vertical',
+                enableChildNavigationAcrossContainers: true,
+                description: '',
+            };
+            board.children.push(newItem);
+            triggerRender();
+        },
+    },
+];

package/dist/navigation/actions/add-item/add-item-actions.d.ts

@@ -0,0 +1,3 @@
+import { CommandLineActionEntry } from '../../model/action-map.model.js';
+export declare const addSwimlaneAction: NonNullable<CommandLineActionEntry['action']>;
+export declare const addTicketAction: NonNullable<CommandLineActionEntry['action']>;

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

@@ -0,0 +1,45 @@
+import { BoardItemTypes, } from '../../../board/model/board.model.js';
+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,
+        isSelected: false,
+        childrenRenderAxis: 'vertical',
+        enableChildNavigationAcrossContainers: true,
+        children: [],
+    };
+    const parent = appState.currentNode;
+    parent.children ?? (parent.children = []);
+    const newItemIndex = parent.children.length;
+    parent.children.push(newItem);
+    navigator.navigate({ selectedIndex: newItemIndex });
+};
+export const addTicketAction = async (_ctx, _cmd, { value }) => {
+    const newItem = {
+        id: `${Date.now()}`,
+        name: value || 'New issue',
+        actionContext: BoardItemTypes.TICKET_LIST_ITEM,
+        isSelected: false,
+        childrenRenderAxis: 'vertical',
+        children: [
+            {
+                isSelected: false,
+                id: `${Date.now()}`,
+                name: 'Description',
+                description: '...add description',
+                actionContext: BoardItemTypes.TICKET,
+                childrenRenderAxis: 'vertical',
+                children: [],
+            },
+        ],
+    };
+    const parent = appState.currentNode;
+    parent.children ?? (parent.children = []);
+    const newItemIndex = parent.children.length;
+    parent.children.push(newItem);
+    navigator.navigate({ selectedIndex: newItemIndex });
+};

package/dist/navigation/actions/board-action-map.d.ts

@@ -0,0 +1,10 @@
+import { BoardItemTypes } from '../../board/model/board.model.js';
+import { ActionEntry, ActionMap } from '../model/action-map.model.js';
+type BoardActionMap = ActionMap<{
+    [BoardItemTypes.BOARD]: ActionEntry[];
+    [BoardItemTypes.SWIMLANE]: ActionEntry[];
+    [BoardItemTypes.TICKET_LIST_ITEM]: ActionEntry[];
+    [BoardItemTypes.TICKET]: ActionEntry[];
+}>;
+export declare const ContextualActionMap: BoardActionMap;
+export {};

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

@@ -0,0 +1,12 @@
+import { BoardItemTypes } from '../../board/model/board.model.js';
+import { moveAcrossParents, moveWithinParent, toggleMoveMode, } from './move/move-actions.js';
+export const ContextualActionMap = {
+    [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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,101 @@
+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 = (appState.selectedIndex + offset + len) % len;
+    navigationUtils.updateSelection(newIndex);
+};
+export const navigateToNextItem = () => navigateByOffset(1);
+export const navigateToPreviousItem = () => navigateByOffset(-1);
+const navigateToSiblingContainer = (ctx, direction) => {
+    if (!appState.currentNode.enableChildNavigationAcrossContainers)
+        return;
+    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);
+    const sliced = direction === -1
+        ? grandParent.children.toSpliced(parentIndex).toReversed()
+        : grandParent.children.slice(parentIndex + 1);
+    const nextSibling = sliced.find(x => x.children.length);
+    if (!nextSibling?.children?.length)
+        return;
+    const prevIndex = appState.selectedIndex;
+    const boundedIndex = Math.min(prevIndex, nextSibling.children.length - 1);
+    ctx.selectNone();
+    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 = appState.breadCrumb.at(-1);
+    const focusNode = currentNode?.children[appState.selectedIndex];
+    if (!currentNode || !focusNode)
+        return;
+    if (!focusNode?.children?.length) {
+        await ctx.enterChildNode(focusNode);
+        return;
+    }
+    else {
+        ctx.enterChildNode(focusNode);
+    }
+};
+export const exitToParentNode = (ctx) => {
+    if (appState.breadCrumb.length >= 2) {
+        ctx.enterParentNode();
+    }
+};

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

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

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

@@ -0,0 +1,64 @@
+import { CmdIntent } from '../../command-line/command-line-sequence-intent.js';
+import { Mode } from '../../model/action-map.model.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: Intent.ToggleCommandLine,
+        mode: Mode.DEFAULT,
+        description: '[:] Toggle command line',
+        action: () => patchState({ mode: Mode.COMMAND_LINE }),
+    },
+    {
+        intent: Intent.ToggleCommandLine,
+        mode: Mode.COMMAND_LINE,
+        description: '[ESC] Toggle command line',
+        action: () => patchState({ mode: Mode.DEFAULT }),
+    },
+    {
+        intent: Intent.Confirm,
+        mode: Mode.DEFAULT,
+        description: '[ENTER] Confirm/Enter context',
+        action: navigator.enterChildNode,
+    },
+    {
+        intent: Intent.Exit,
+        mode: Mode.DEFAULT,
+        description: '[ESC/Q] Exit application',
+        action: navigator.enterParentNode,
+    },
+    {
+        mode: Mode.DEFAULT,
+        description: '[ARROWS/HJKL] Navigate',
+    },
+    {
+        intent: Intent.NavPreviousItem,
+        mode: Mode.DEFAULT,
+        action: navigator.navigateToPreviousItem,
+    },
+    {
+        intent: Intent.NavNextItem,
+        mode: Mode.DEFAULT,
+        action: navigator.navigateToNextItem,
+    },
+    {
+        intent: Intent.NavToPreviousContainer,
+        mode: Mode.DEFAULT,
+        action: navigator.navigateToPreviousContainer,
+    },
+    {
+        intent: Intent.NavToNextContainer,
+        mode: Mode.DEFAULT,
+        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.d.ts

@@ -0,0 +1,2 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const onConfirmCommandLineSequenceInput: (...args: Parameters<NonNullable<ActionEntry["action"]>>) => void;

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

@@ -0,0 +1,18 @@
+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();
+    const [ctx] = [...args];
+    const [firstItem, ...rest] = commandSequence.split(' ');
+    const command = (firstItem || '').trim();
+    const value = rest.join(' ').trim();
+    if (!command)
+        return;
+    const intent = getCommandIntent(command);
+    const actionMeta = commands.find(x => x.intent === intent);
+    actionMeta?.action?.(ctx, actionMeta, { command, value });
+    updateCommandHistory();
+    clearCommandLine();
+    return;
+};

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

@@ -0,0 +1,8 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const CommandLineIntent: {
+    readonly AddItem: "add-item";
+    readonly ViewHelp: "view-help";
+};
+export declare const getCommandLineIntent: (input: string) => "add-item" | "view-help" | undefined;
+export declare const inputActions: ActionEntry[];
+export declare const onConfirmCommandLineInput: (input: string) => void;

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

@@ -0,0 +1,47 @@
+import { Mode } from '../../model/action-map.model.js';
+import { patchState } from '../../state/state.js';
+export const CommandLineIntent = {
+    AddItem: 'add-item',
+    ViewHelp: 'view-help',
+};
+export const getCommandLineIntent = (input) => {
+    switch (input) {
+        case 'help':
+        case 'h':
+            return CommandLineIntent.ViewHelp;
+        case 'add':
+        case 'a':
+            return CommandLineIntent.AddItem;
+        default:
+            return;
+    }
+};
+export const inputActions = [
+    {
+        intent: CommandLineIntent.ViewHelp,
+        mode: Mode.DEFAULT, // Make accept array
+        action: () => {
+            patchState({
+                mode: Mode.HELP,
+                commandLineInput: '',
+            });
+        },
+    },
+];
+export const onConfirmCommandLineInput = (input) => {
+    switch (input.trim()) {
+        case 'help':
+        case 'h':
+            patchState({
+                mode: Mode.HELP,
+                commandLineInput: '',
+            });
+            return;
+        default:
+            patchState({
+                mode: Mode.DEFAULT,
+                commandLineInput: '',
+            });
+            return;
+    }
+};

package/dist/navigation/actions/input/input-actions.d.ts

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