@principal-ade/panel-layouts 0.2.4 → 0.2.6

package/dist/index.d.ts

@@ -24,6 +24,143 @@ import { TabsConfig } from '@principal-ade/panels';
 import { Theme } from '@principal-ade/panels';
 import { TilesConfig } from '@principal-ade/panels';
 
+/**
+ * AgentCommandInput - Input field for the Agent Command Palette
+ * Supports natural language mode and quick command mode (/ prefix)
+ */
+export declare const AgentCommandInput: default_2.FC<AgentCommandInputProps>;
+
+/**
+ * Props for AgentCommandInput component
+ */
+export declare interface AgentCommandInputProps {
+    /** Current input value */
+    value: string;
+    /** Change handler */
+    onChange: (value: string) => void;
+    /** Submit handler (Enter key) */
+    onSubmit: () => void;
+    /** Close handler (Escape key) */
+    onClose: () => void;
+    /** History previous handler (Up arrow) */
+    onHistoryPrevious: () => void;
+    /** History next handler (Down arrow) */
+    onHistoryNext: () => void;
+    /** Current mode */
+    mode: AgentCommandPaletteMode;
+    /** Current status */
+    status: AgentCommandPaletteStatus;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the input is disabled */
+    disabled?: boolean;
+    /** Auto-focus on mount */
+    autoFocus?: boolean;
+}
+
+/**
+ * AgentCommandPalette - AI-driven command palette component
+ *
+ * Displays at the bottom of the screen with an input field.
+ * Users can type natural language requests or quick commands (prefixed with /).
+ */
+export declare const AgentCommandPalette: default_2.FC<AgentCommandPaletteProps>;
+
+/**
+ * Configuration for the Agent Command Palette
+ */
+export declare interface AgentCommandPaletteConfig {
+    /** Keyboard shortcut configuration */
+    keyboard?: AgentCommandPaletteKeyboardConfig;
+    /** Placeholder text for the input */
+    placeholder?: string;
+    /** Auto-close delay after completion (ms, 0 to disable) */
+    autoCloseDelay?: number;
+    /** Maximum history entries to keep */
+    maxHistoryEntries?: number;
+    /** Custom CSS class */
+    className?: string;
+    /** Custom inline styles */
+    style?: React.CSSProperties;
+}
+
+/**
+ * Keyboard configuration for opening the palette
+ */
+export declare interface AgentCommandPaletteKeyboardConfig {
+    /** Key to trigger the command palette (default: 'p') */
+    key?: string;
+    /** Require Alt key (default: true) */
+    altKey?: boolean;
+    /** Require Ctrl key (default: false) */
+    ctrlKey?: boolean;
+    /** Require Meta/Cmd key (default: false) */
+    metaKey?: boolean;
+    /** Require Shift key (default: false) */
+    shiftKey?: boolean;
+}
+
+/**
+ * Input mode for the command palette
+ */
+export declare type AgentCommandPaletteMode = 'natural' | 'quick-command';
+
+/**
+ * Props for AgentCommandPalette component
+ */
+export declare interface AgentCommandPaletteProps {
+    /** Hook return value */
+    palette: UseAgentCommandPaletteReturn;
+    /** Configuration options */
+    config?: AgentCommandPaletteConfig;
+}
+
+/**
+ * State for the Agent Command Palette
+ */
+export declare interface AgentCommandPaletteState {
+    /** Whether the palette is open */
+    isOpen: boolean;
+    /** Current input value */
+    query: string;
+    /** Input mode (natural language or quick command) */
+    mode: AgentCommandPaletteMode;
+    /** Current execution status */
+    status: AgentCommandPaletteStatus;
+    /** Tools currently being executed */
+    pendingTools: ToolExecution[];
+    /** Tools that have completed execution */
+    completedTools: ToolExecution[];
+    /** Text response from the agent */
+    agentResponse: string;
+    /** Command history */
+    history: CommandHistoryEntry[];
+    /** Current index in history navigation */
+    historyIndex: number;
+    /** Suggested commands */
+    suggestions: string[];
+}
+
+/**
+ * Agent command palette execution status
+ */
+export declare type AgentCommandPaletteStatus = 'idle' | 'thinking' | 'executing' | 'complete' | 'error';
+
+/**
+ * AgentResponseDisplay - Shows the agent's text response
+ */
+export declare const AgentResponseDisplay: default_2.FC<AgentResponseDisplayProps>;
+
+/**
+ * Props for AgentResponseDisplay component
+ */
+export declare interface AgentResponseDisplayProps {
+    /** Response text to display */
+    response: string;
+    /** Whether the response is still streaming */
+    streaming?: boolean;
+}
+
 /**
  * Anthropic tool definition format
  */
@@ -105,6 +242,20 @@ export declare interface CommandContext {
     closeCommandPalette: () => void;
 }
 
+/**
+ * Entry in the command history
+ */
+export declare interface CommandHistoryEntry {
+    /** The query that was submitted */
+    query: string;
+    /** When the command was executed */
+    timestamp: number;
+    /** Tools that were executed */
+    toolsExecuted: string[];
+    /** Whether the command succeeded */
+    success: boolean;
+}
+
 /**
  * CommandInput - Input field for the command palette
  * Auto-focuses on mount and handles input changes
@@ -390,11 +541,32 @@ export declare function getGlobalCommandRegistry(): CommandRegistryService;
  */
 export declare function getPanelCommands(): Command[];
 
+/**
+ * Tool: Get Panel State
+ *
+ * Query the current state of a specific panel.
+ * Panels must implement a getState function to support this.
+ */
+export declare const getPanelStateTool: PanelTool;
+
 /**
  * Utility to extract parameter information for UI rendering.
  */
 export declare function getToolParameterInfo(tool: RegisteredTool): ToolParameterInfo[];
 
+/**
+ * Tool: Get Visible Panels
+ *
+ * Query which panels are currently visible and their state.
+ * Returns layout slot info including collapsed state and active panel IDs.
+ */
+export declare const getVisiblePanelsTool: PanelTool;
+
+/**
+ * Layout action tools only (for selective registration).
+ */
+export declare const layoutActionTools: PanelTool[];
+
 /**
  * All layout tools exported as an array.
  *
@@ -428,6 +600,13 @@ export declare const layoutToolsMetadata: {
     tools: PanelTool[];
 };
 
+/**
+ * Tool: List Panels With State
+ *
+ * Get a list of all panels that support state queries.
+ */
+export declare const listPanelsWithStateTool: PanelTool;
+
 /**
  * Default localStorage-based persistence adapter for web applications
  */
@@ -774,6 +953,11 @@ export { ResponsiveConfigurablePanelLayout }
 
 export { ResponsiveConfigurablePanelLayoutProps }
 
+/**
+ * State query tools only (for selective registration).
+ */
+export declare const stateQueryTools: PanelTool[];
+
 /**
  * Tool: Switch Panel
  *
@@ -821,6 +1005,44 @@ export declare interface ToolCommandBridgeConfig {
     includePanelInCategory?: boolean;
 }
 
+/**
+ * Represents a single tool execution
+ */
+export declare interface ToolExecution {
+    /** Unique identifier for this execution */
+    id: string;
+    /** Tool name being executed */
+    name: string;
+    /** Arguments passed to the tool */
+    args: Record<string, unknown>;
+    /** Current execution status */
+    status: ToolExecutionStatus;
+    /** Result from successful execution */
+    result?: string;
+    /** Error message if execution failed */
+    error?: string;
+}
+
+/**
+ * ToolExecutionList - Displays the list of tools being executed
+ */
+export declare const ToolExecutionList: default_2.FC<ToolExecutionListProps>;
+
+/**
+ * Props for ToolExecutionList component
+ */
+export declare interface ToolExecutionListProps {
+    /** Tools to display */
+    tools: ToolExecution[];
+    /** Compact single-line mode */
+    compact?: boolean;
+}
+
+/**
+ * Tool execution status
+ */
+export declare type ToolExecutionStatus = 'pending' | 'running' | 'success' | 'error';
+
 /**
  * Parameter information for UI rendering
  */
@@ -928,6 +1150,70 @@ export declare interface UpdateWorkspaceOptions {
     };
 }
 
+/**
+ * Hook for managing Agent Command Palette state and behavior
+ * Handles input, history navigation, tool execution tracking, and keyboard shortcuts
+ */
+export declare function useAgentCommandPalette({ events, keyboard, config, onExecuteTool, initialSuggestions, }?: UseAgentCommandPaletteOptions): UseAgentCommandPaletteReturn;
+
+/**
+ * Options for the useAgentCommandPalette hook
+ */
+export declare interface UseAgentCommandPaletteOptions {
+    /** Event emitter for panel events */
+    events?: PanelEventEmitter;
+    /** Keyboard configuration */
+    keyboard?: AgentCommandPaletteKeyboardConfig;
+    /** Configuration options */
+    config?: AgentCommandPaletteConfig;
+    /** Callback when a tool should be executed */
+    onExecuteTool?: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+    /** Initial suggestions to show */
+    initialSuggestions?: string[];
+}
+
+/**
+ * Return type for useAgentCommandPalette hook
+ */
+export declare interface UseAgentCommandPaletteReturn {
+    /** Whether the palette is open */
+    isOpen: boolean;
+    /** Open the palette */
+    open: () => void;
+    /** Close the palette */
+    close: () => void;
+    /** Toggle the palette */
+    toggle: () => void;
+    /** Current query value */
+    query: string;
+    /** Set the query value */
+    setQuery: (query: string) => void;
+    /** Current input mode */
+    mode: AgentCommandPaletteMode;
+    /** Current execution status */
+    status: AgentCommandPaletteStatus;
+    /** Tools being executed */
+    pendingTools: ToolExecution[];
+    /** Completed tools */
+    completedTools: ToolExecution[];
+    /** Agent's text response */
+    agentResponse: string;
+    /** Submit the current query for execution */
+    submit: () => void;
+    /** Execute a quick command directly */
+    executeQuickCommand: (command: string) => void;
+    /** Command history */
+    history: CommandHistoryEntry[];
+    /** Navigate to previous history entry */
+    historyPrevious: () => void;
+    /** Navigate to next history entry */
+    historyNext: () => void;
+    /** Suggested commands */
+    suggestions: string[];
+    /** Clear the current state (query, tools, response) */
+    clear: () => void;
+}
+
 /**
  * Hook for managing command palette state and behavior
  * Handles command registration, filtering, keyboard navigation, and execution