citadel_cli 1.0.0 → 1.1.3

package/dist/src/App.d.ts

@@ -1,4 +0,0 @@
-import { CitadelConfig } from './components/Citadel/config/types';
-export declare const config: CitadelConfig;
-declare function App(): import("react/jsx-runtime").JSX.Element;
-export default App;

package/dist/src/__test-utils__/factories.d.ts

@@ -1,21 +0,0 @@
-import { CommandNode, CommandTrie, CommandHandler } from '../components/Citadel/types/command-trie';
-import { CitadelState, CitadelActions } from '../components/Citadel/types';
-import { StoredCommand } from '../components/Citadel/types/storage';
-import { CommandHistory, CommandHistoryActions } from '../components/Citadel/hooks/useCommandHistory';
-interface MockNodeOptions {
-    argument?: {
-        name: string;
-        description: string;
-    };
-    handler?: CommandHandler;
-    description?: string;
-    isLeaf?: boolean;
-}
-export declare const createMockNode: (name: string, options?: MockNodeOptions) => CommandNode;
-export declare const createMockCommandTrie: () => CommandTrie;
-export declare const createMockStoredCommand: (overrides?: {}) => StoredCommand;
-export declare const createMockCommandHistory: (overrides?: {}) => CommandHistory;
-export declare const createMockCommandHistoryActions: (overrides?: {}) => CommandHistoryActions;
-export declare const createMockCitadelState: (overrides?: {}) => CitadelState;
-export declare const createMockCitadelActions: (overrides?: {}) => CitadelActions;
-export {};

package/dist/src/components/Citadel/Citadel.d.ts

@@ -1,11 +0,0 @@
-import { CitadelConfig } from './config/types';
-export interface CitadelProps {
-    config?: CitadelConfig;
-    commands?: Record<string, any>;
-    containerId?: string;
-}
-export declare const Citadel: ({ config, commands, containerId }: {
-    config?: CitadelConfig | undefined;
-    commands?: {} | undefined;
-    containerId?: null | undefined;
-}) => null;

package/dist/src/components/Citadel/commands/history-commands.d.ts

@@ -1,2 +0,0 @@
-import { CommandNode } from '../types/command-trie';
-export declare function createHistoryCommands(): [string, CommandNode];

package/dist/src/components/Citadel/components/AvailableCommands.d.ts

@@ -1,9 +0,0 @@
-import { default as React } from 'react';
-import { CommandNode } from '../types/command-trie';
-import { CitadelState } from '../types/state';
-interface AvailableCommandsProps {
-    state: CitadelState;
-    availableCommands: CommandNode[];
-}
-export declare const AvailableCommands: React.FC<AvailableCommandsProps>;
-export {};

package/dist/src/components/Citadel/config/CitadelConfigContext.d.ts

@@ -1,11 +0,0 @@
-import { default as React } from 'react';
-import { CitadelConfig } from './types';
-import { CommandStorage } from '../types/storage';
-export declare const CitadelConfigProvider: React.FC<{
-    config?: CitadelConfig;
-    commands?: Record<string, any>;
-    children: React.ReactNode;
-}>;
-export declare const useCitadelConfig: () => CitadelConfig;
-export declare const useCitadelCommands: () => Record<string, any> | undefined;
-export declare const useCitadelStorage: () => CommandStorage | undefined;

package/dist/src/components/Citadel/hooks/useCommandHistory.d.ts

@@ -1,17 +0,0 @@
-import { StoredCommand } from '../types/storage';
-export interface CommandHistory {
-    commands: StoredCommand[];
-    position: number | null;
-    savedInput: string | null;
-}
-export interface CommandHistoryActions {
-    addCommand: (command: StoredCommand) => Promise<void>;
-    getCommands: () => StoredCommand[];
-    navigateHistory: (direction: 'up' | 'down', currentInput: string) => {
-        command: StoredCommand | null;
-        position: number | null;
-    };
-    saveInput: (input: string) => void;
-    clear: () => Promise<void>;
-}
-export declare function useCommandHistory(): [CommandHistory, CommandHistoryActions];

package/dist/src/components/Citadel/hooks/useCommandParser.d.ts

@@ -1,19 +0,0 @@
-import { CommandNode, CommandTrie } from '../types/command-trie';
-import { CitadelState, CitadelActions } from '../types/state';
-import { StoredCommand } from '../types/storage';
-type InputState = 'idle' | 'entering_command' | 'entering_argument';
-interface UseCommandParserProps {
-    commandTrie?: CommandTrie;
-}
-export declare function useCommandParser({ commandTrie: propsTrie }?: UseCommandParserProps): {
-    handleInputChange: (newValue: string, state: CitadelState, actions: CitadelActions) => void;
-    handleKeyDown: (e: KeyboardEvent, state: CitadelState, actions: CitadelActions) => void;
-    executeCommand: (commandStack: string[], actions: CitadelActions, args?: string[]) => void;
-    inputState: InputState;
-    replayCommand: (command: StoredCommand, state: CitadelState, actions: CitadelActions) => Promise<void>;
-    findMatchingCommands: (input: string, availableNodes: CommandNode[]) => CommandNode[];
-    getAutocompleteSuggestion: (input: string, availableNodes: CommandNode[]) => string | null;
-    getAvailableNodes: (currentNode?: CommandNode) => CommandNode[];
-    isValidCommandInput: (input: string, availableNodes: CommandNode[]) => boolean;
-};
-export {};

package/dist/src/components/Citadel/hooks/useCommandTrie.d.ts

@@ -1,2 +0,0 @@
-import { CommandTrie } from '../types/command-trie';
-export declare const useCommandTrie: () => CommandTrie;

package/dist/src/components/Citadel/types/command-context.d.ts

@@ -1,4 +0,0 @@
-import { HistoryService } from '../services/HistoryService';
-export interface CommandContext {
-    history?: HistoryService;
-}

package/dist/src/components/Citadel/types/command-trie.d.ts

@@ -1,238 +0,0 @@
-import { CommandResult } from './command-results';
-/** Function type for handling command execution */
-export type CommandHandler = (args: string[]) => Promise<CommandResult>;
-/**
- * Represents an argument that can be passed to a command
- */
-export interface CommandArgument {
-    name: string;
-    description: string;
-}
-export interface CommandNodeParams {
-    fullPath: string[];
-    description: string;
-    parent?: CommandNode;
-    argument?: CommandArgument;
-    handler?: CommandHandler;
-}
-export interface CommandSignature {
-    signature: string[];
-}
-/**
- * A no-op handler that returns an empty string. Used as the default handler
- * for CommandNodes that don't specify a handler.
- */
-export declare const NoopHandler: CommandHandler;
-export declare class CommandNode {
-    private _fullPath;
-    private _description;
-    private _children;
-    private _argument?;
-    private _handler;
-    private _parent?;
-    private _signature?;
-    /**
-     * Creates a new CommandNode representing a command the user can enter. From a
-     * high level, a command is one or more words followed by an optional
-     * argument, and with an optional handler.
-     *
-     * @param params Configuration parameters for the node
-     * @param params.fullPath Complete path from root to this node (e.g., ['service', 'deploy'])
-     * @param params.description Human-readable description of the command
-     * @param params.parent Optional parent node in the command hierarchy
-     * @param params.handler Optional async function to execute when command is invoked
-     * @param params.argument Optional argument definition for the command
-     * @throws {Error} If fullPath is empty or undefined
-     *
-     */
-    constructor(params: CommandNodeParams);
-    /**
-     * Gets the name of this command (last segment of the path)
-     */
-    get name(): string;
-    /**
-     * Whether this is a leaf node (has no children)
-     */
-    get isLeaf(): boolean;
-    /**
-     * Whether this command has a handler
-     */
-    get hasHandler(): boolean;
-    /**
-     * Whether this command requires an argument
-     */
-    get requiresArgument(): boolean;
-    /**
-     * Gets the parent node if it exists
-     */
-    get parent(): CommandNode | undefined;
-    /**
-     * Gets the command's signature
-     */
-    get signature(): string | undefined;
-    /**
-     * Sets the signature for this command based on the current command trie state
-     * @param trie The command trie to use for signature generation
-     */
-    setSignature(trie: CommandTrie): void;
-    /**
-     * Gets the map of child commands
-     */
-    get children(): ReadonlyMap<string, CommandNode>;
-    /**
-     * Whether this command has any children
-     */
-    get hasChildren(): boolean;
-    /**
-     * Adds a child command
-     */
-    addChild(segment: string, node: CommandNode): void;
-    /**
-     * Gets a child command by name
-     */
-    getChild(name: string): CommandNode | undefined;
-    /**
-     * Gets the full path from root to this command
-     */
-    get fullPath(): string[];
-    /**
-     * Gets the command's description
-     */
-    get description(): string;
-    /**
-     * Gets the command's argument definition if it exists
-     */
-    get argument(): CommandArgument | undefined;
-    /**
-     * Sets the command's argument definition
-     */
-    set argument(value: CommandArgument | undefined);
-    /**
-     * Gets the command's handler
-     */
-    get handler(): CommandHandler;
-    /**
-     * Sets the command's handler
-     */
-    set handler(value: CommandHandler);
-}
-/**
- * A trie data structure for managing hierarchical commands.
- * Provides functionality for adding commands, retrieving commands,
- * and getting command completions.
- */
-export declare class CommandTrie {
-    private readonly _root;
-    /**
-     * Creates a new CommandTrie instance.
-     */
-    constructor();
-    /**
-     * Adds a new command to the trie.
-     *
-     * @param params Parameters for the command.
-     * @param params.path The path segments for the command (e.g., ['service', 'deploy'])
-     * @param params.description Description of what the command does
-     * @param params.handler Optional function to execute when command is invoked
-     * @param params.argument Optional argument definition for the command
-     * @throws {Error} If attempting to add a duplicate leaf command or a subcommand to a leaf
-     *
-     */
-    addCommand(params: Omit<ConstructorParameters<typeof CommandNode>[0], 'fullPath' | 'parent'> & {
-        path: string[];
-    }): void;
-    /**
-     * Retrieves a command from the trie.
-     *
-     * @param path The path of the command.
-     * @returns The command node or undefined if not found.
-     */
-    getCommand(path: string[]): CommandNode | undefined;
-    /**
-     * Gets command completions for a given path.
-     *
-     * @param path The path to get completions for.
-     * @returns An array of completion strings.
-     */
-    getCompletions(path: string[]): string[];
-    /**
-     * Executes a command with the given path and arguments.
-     * @param path The command path
-     * @param args Arguments to pass to the command handler
-     * @returns The command result or undefined if command not found
-     * @throws Error if command validation fails
-     */
-    executeCommand(path: string[], args?: string[]): Promise<CommandResult | undefined>;
-    /**
-     * Gets the root commands in the trie.
-     *
-     * @returns An array of root command nodes.
-     */
-    getRootCommands(): CommandNode[];
-    /**
-     * Gets the leaf commands in the trie.
-     *
-     * @returns An array of leaf command nodes.
-     */
-    getLeafCommands(): CommandNode[];
-    /**
-     * Retrieves a command using its unique signature.
-     * A signature is the minimal sequence of prefixes that uniquely identifies a command.
-     *
-     * @param signature Array of minimal prefixes that uniquely identify the command
-     * @returns The matching command node or undefined if not found
-     *
-     * @example
-     * // Will match 'image random cat' command
-     * getCommandBySignature(['i', 'r', 'c'])
-     * // Will match 'user show' command (not ambiguous with 'user status')
-     * getCommandBySignature(['u', 'sh'])
-     */
-    getCommandBySignature(signature: CommandSignature): CommandNode | undefined;
-    /**
-     * Generates a minimal unique signature for a command node.
-     * The signature consists of the shortest prefixes that uniquely identify each segment
-     * in the path from root to this node.
-     *
-     * @param command The command node to generate a signature for
-     * @returns Array of minimal prefixes that uniquely identify the command
-     *
-     * @example
-     * // For commands: ['image', 'random', 'cat'] and ['image', 'random', 'dog']
-     * buildSignatureForCommand(catCommand) // returns ['i', 'r', 'c']
-     * // For commands: ['user', 'show'] and ['user', 'status']
-     * buildSignatureForCommand(showCommand) // returns ['u', 'sh']
-     */
-    buildSignatureForCommand(command: CommandNode): CommandSignature;
-    /**
-     * Validates the command trie structure for common errors.
-     *
-     * Performs the following validations:
-     * 1. Checks for duplicate command paths
-     * 2. Ensures non-leaf nodes (nodes with children) use NoopHandler
-     * 3. Ensures non-leaf nodes don't have arguments
-     * 4. Verifies all nodes have a handler (either custom or NoopHandler)
-     * 5. Validates command path uniqueness
-     *
-     * @returns An object containing:
-     *  - isValid: boolean indicating if the trie is valid
-     *  - errors: array of error messages describing any validation failures
-     *
-     * @example
-     * ```typescript
-     * const result = commandTrie.validate();
-     * if (!result.isValid) {
-     *   console.error('Command trie validation failed:');
-     *   result.errors.forEach(error => console.error(error));
-     * }
-     * ```
-     */
-    /**
-     * Updates signatures for all nodes in the trie
-     */
-    setSignatures(): void;
-    validate(): {
-        isValid: boolean;
-        errors: string[];
-    };
-}

package/dist/src/components/Citadel/types/help-command.d.ts

@@ -1,3 +0,0 @@
-import { CommandNode, CommandTrie } from './command-trie';
-import { CitadelConfig } from '../config/types';
-export declare const createHelpCommand: (trie: CommandTrie, config: CitadelConfig) => [string, CommandNode];

package/dist/src/components/Citadel/utils/keySimulation.d.ts

@@ -1,2 +0,0 @@
-import { CitadelState, CitadelActions } from '../types/state';
-export declare const simulateKeyPress: (key: string, state: CitadelState, actions: CitadelActions) => void;

package/dist/src/index.d.ts

@@ -1,4 +0,0 @@
-export { Citadel } from './components/Citadel/Citadel';
-export type { CitadelProps } from './components/Citadel/Citadel';
-export type { CitadelConfig } from './components/Citadel/config/types';
-export * from './components/Citadel/types';