citadel_cli 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/index'
+export {}

package/dist/src/App.d.ts

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

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

@@ -0,0 +1,11 @@
+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/Cursor.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { CursorStyle } from './types/cursor';
+interface CursorProps {
+    style?: Partial<CursorStyle> & Pick<CursorStyle, 'type'>;
+    isValid?: boolean;
+    errorMessage?: string;
+}
+export declare const Cursor: React.FC<CursorProps>;
+export {};

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,9 @@
+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/components/CommandInput.d.ts

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

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

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { OutputItem } from '../types/state';
+interface CommandOutputProps {
+    output: OutputItem[];
+    outputRef: React.RefObject<HTMLDivElement>;
+}
+export declare const CommandOutput: React.FC<CommandOutputProps>;
+export {};

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

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { CommandStatus } from '../types/command-results';
+interface CommandOutputLineProps {
+    command: string;
+    timestamp: string;
+    status: CommandStatus;
+}
+export declare const CommandOutputLine: React.FC<CommandOutputLineProps>;
+export {};

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

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const Spinner: React.FC;

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

@@ -0,0 +1 @@
+export {};

package/dist/src/components/Citadel/components/__tests__/CommandInput.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/Citadel/components/__tests__/CommandOutput.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/Citadel/components/__tests__/CommandOutputLine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/Citadel/components/__tests__/Spinner.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,11 @@
+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/config/__tests__/CitadelConfigContext.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,26 @@
+import { CitadelConfig } from './types';
+/**
+ * Default configuration for Citadel command interface
+ *
+ * @property commandTimeoutMs - The time in milliseconds before a command execution fails with a timeout. Default: 10000.
+ *
+ * @property includeHelpCommand - When true, automatically adds a 'help' command that displays all available commands.
+ *                               When false, no help command is included in the command trie. Default: true.
+ *
+ * @property maxHeight - The maximum CSS height of the interface. Default: '80vh'.
+ *
+ * @property outputFontSize - The TailwindCSS class for the font size of the output text. Default: 'text-sm'.
+ *
+ * @property resetStateOnHide - When true, hiding the interface (via Escape key or other means) will clear the command input.
+ *                             When false, the interface preserves the last input when hidden. Default: false.
+ *
+ * @property showCitadelKey - The keyboard key that shows the command interface. Default: '.' (period).
+ *
+ * @property cursorType - The type of cursor animation to display. Can be one of 'blink', 'spin', 'solid', or 'bbs'. Default: 'bbs'.
+ *
+ * @property cursorColor - The color of the cursor. Default: 'var(--cursor-color, #fff)'.
+ *
+ * @property cursorSpeed - The speed of cursor animation in milliseconds. Default varies by cursor type:
+ *                        blink: 530ms, spin/bbs: 120ms, solid: N/A
+ */
+export declare const defaultConfig: CitadelConfig;

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

@@ -0,0 +1,56 @@
+import { CursorType } from '../types/cursor';
+import { StorageConfig } from '../types/storage';
+export interface CitadelConfig {
+    /**
+     * Configuration for command history storage
+     */
+    storage?: StorageConfig;
+    /**
+     * Whether to include the default help command in the command trie.
+     */
+    includeHelpCommand?: boolean;
+    /**
+     * Whether to reset the state when the interface is hidden (via Escape key or other means).
+     */
+    resetStateOnHide?: boolean;
+    /**
+     * The keyboard key that shows the command interface.
+     */
+    showCitadelKey?: string;
+    /**
+     * The time in milliseconds before a command execution fails with a timeout.
+     */
+    commandTimeoutMs?: number;
+    /**
+     * Optional CSS value for the maximum height of the command interface.
+     * If provided, this value will be set as the `max-height` property of the interface.
+     *
+     * Example:
+     * ```
+     * <Citadel config={{ maxHeight: '90vh' }} />
+     * ```
+     */
+    maxHeight?: string;
+    minHeight?: string;
+    /**
+     * The font size for the command output text.
+     * Accepts Tailwind text size classes: 'text-xs', 'text-sm', 'text-base', 'text-lg', etc.
+     */
+    outputFontSize?: string;
+    /**
+     * The type of cursor to display. Can be one of 'blink', 'spin', 'solid', or 'bbs'.
+     */
+    cursorType?: CursorType;
+    /**
+     * The color of the cursor.
+     * Accepts any valid CSS color value.
+     */
+    cursorColor?: string;
+    /**
+     * The speed of the cursor animation in milliseconds.
+     * - For 'blink': Time between blinks (default: 530ms)
+     * - For 'spin' and 'bbs': Time between frame changes (default: 120ms)
+     * - For 'solid': Has no effect
+     */
+    cursorSpeed?: number;
+}

package/dist/src/components/Citadel/hooks/__tests__/useCitadelState.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+import { CitadelState, CitadelActions } from '../types/state';
+export declare const useCitadelState: () => {
+    state: CitadelState;
+    actions: CitadelActions;
+    getAvailableCommands: () => import('../types/command-trie').CommandNode[];
+};

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

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

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

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

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

@@ -0,0 +1,8 @@
+interface UseGlobalShortcutProps {
+    onOpen: () => void;
+    onClose: () => void;
+    isVisible: boolean;
+    showCitadelKey: string;
+}
+export declare const useGlobalShortcut: ({ onOpen, onClose, isVisible, showCitadelKey }: UseGlobalShortcutProps) => void;
+export {};

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

@@ -0,0 +1,14 @@
+interface SlideAnimationOptions {
+    isVisible: boolean;
+    isClosing: boolean;
+    onAnimationComplete?: () => void;
+}
+export declare const useSlideAnimation: (options: SlideAnimationOptions) => {
+    style: {
+        opacity: number;
+        transform: string;
+        transition: string;
+    };
+    animationClass: string;
+};
+export {};

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

@@ -0,0 +1,2 @@
+export { Citadel } from './Citadel';
+export * from './types';

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

@@ -0,0 +1,15 @@
+import { CommandStorage, StoredCommand } from '../types/storage';
+export interface HistoryService {
+    getCommands(): Promise<StoredCommand[]>;
+    addCommand(command: StoredCommand): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class DefaultHistoryService implements HistoryService {
+    private readonly storage;
+    constructor(storage: CommandStorage);
+    getCommands(): Promise<StoredCommand[]>;
+    addCommand(command: StoredCommand): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare function getHistoryService(storage?: CommandStorage): HistoryService;
+export declare function initializeHistoryService(storage: CommandStorage): void;

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

@@ -0,0 +1,25 @@
+import { CommandStorage, StorageConfig, StoredCommand } from '../types/storage';
+/**
+ * Base class for command history storage implementations
+ */
+export declare abstract class BaseStorage implements CommandStorage {
+    protected config: Required<StorageConfig>;
+    constructor(config?: StorageConfig);
+    /**
+     * Add a command to history, enforcing storage limits
+     */
+    addCommand(command: StoredCommand): Promise<void>;
+    /**
+     * Get all stored commands, ordered by timestamp ascending
+     */
+    abstract getCommands(): Promise<StoredCommand[]>;
+    /**
+     * Clear all stored commands
+     */
+    abstract clear(): Promise<void>;
+    /**
+     * Save commands to storage
+     * @protected
+     */
+    protected abstract saveCommands(commands: StoredCommand[]): Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+import { StorageConfig, StoredCommand } from '../types/storage';
+import { BaseStorage } from './BaseStorage';
+/**
+ * localStorage-based command history storage
+ */
+export declare class LocalStorage extends BaseStorage {
+    private readonly storageKey;
+    constructor(config: StorageConfig);
+    getCommands(): Promise<StoredCommand[]>;
+    clear(): Promise<void>;
+    protected saveCommands(commands: StoredCommand[]): Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+import { StorageConfig, StoredCommand } from '../types/storage';
+import { BaseStorage } from './BaseStorage';
+/**
+ * In-memory command history storage
+ */
+export declare class MemoryStorage extends BaseStorage {
+    private commands;
+    constructor(config?: StorageConfig);
+    getCommands(): Promise<StoredCommand[]>;
+    clear(): Promise<void>;
+    protected saveCommands(commands: StoredCommand[]): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import { CommandStorage, StorageConfig } from '../types/storage';
+export declare class StorageFactory {
+    private static instance;
+    private currentStorage?;
+    private constructor();
+    static getInstance(): StorageFactory;
+    initializeStorage(config: StorageConfig): void;
+    getStorage(): CommandStorage;
+}

package/dist/src/components/Citadel/storage/__tests__/LocalStorage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/Citadel/storage/__tests__/MemoryStorage.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+export declare enum CommandStatus {
+    Pending = "pending",
+    Success = "success",
+    Failure = "failure",
+    Timeout = "timeout"
+}
+export declare abstract class CommandResult {
+    readonly timestamp: number;
+    private _status;
+    constructor(timestamp?: number);
+    get status(): CommandStatus;
+    markSuccess(): void;
+    markFailure(): void;
+    markTimeout(): void;
+    abstract render(): React.ReactNode;
+}
+export declare class JsonCommandResult extends CommandResult {
+    readonly data: any;
+    constructor(data: any, timestamp?: number);
+    render(): React.ReactNode;
+}
+export declare class TextCommandResult extends CommandResult {
+    readonly text: string;
+    constructor(text: string, timestamp?: number);
+    render(): React.ReactNode;
+}
+export declare class ErrorCommandResult extends CommandResult {
+    readonly error: string;
+    constructor(error: string, timestamp?: number);
+    render(): React.ReactNode;
+}
+export declare class PendingCommandResult extends CommandResult {
+    render(): React.ReactNode;
+}
+export declare class ImageCommandResult extends CommandResult {
+    readonly imageUrl: string;
+    readonly altText: string;
+    constructor(imageUrl: string, altText?: string, timestamp?: number);
+    render(): React.ReactNode;
+}