dexto 1.2.4 → 1.2.5

package/dist/cli/commands/interactive-commands/utils/command-output.js

@@ -0,0 +1,75 @@
+/**
+ * Command Output Helper
+ * Utilities for consistent command output handling across all slash commands
+ */
+import chalk from 'chalk';
+import { logger } from '@dexto/core';
+import { formatForInkCli } from './format-output.js';
+/**
+ * Command output helper for consistent display and error handling
+ */
+export class CommandOutputHelper {
+    /**
+     * Display success message consistently
+     * Logs to console with color and returns formatted string for ink-cli
+     */
+    static success(message) {
+        console.log(chalk.green(message));
+        return formatForInkCli(message);
+    }
+    /**
+     * Display info message consistently
+     * Logs to console with color and returns formatted string for ink-cli
+     */
+    static info(message) {
+        console.log(chalk.blue(message));
+        return formatForInkCli(message);
+    }
+    /**
+     * Display warning message consistently
+     * Logs to console with color and returns formatted string for ink-cli
+     */
+    static warning(message) {
+        console.log(chalk.yellow(message));
+        return formatForInkCli(message);
+    }
+    /**
+     * Handle errors consistently across all commands
+     * Logs error and returns formatted error string
+     */
+    static error(error, context) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const fullMessage = context ? `❌ ${context}: ${errorMessage}` : `❌ ${errorMessage}`;
+        logger.error(fullMessage);
+        console.error(chalk.red(fullMessage));
+        return formatForInkCli(fullMessage);
+    }
+    /**
+     * Build multi-line output with consistent formatting
+     * Logs to console and returns formatted string for ink-cli
+     */
+    static output(lines) {
+        const output = lines.join('\n');
+        console.log(output);
+        return formatForInkCli(output);
+    }
+    /**
+     * Validate required argument and return error if missing
+     * Returns null if valid, error string if invalid
+     */
+    static validateRequiredArg(args, index, argName, usage) {
+        if (args.length <= index || !args[index]) {
+            const errorMsg = `❌ ${argName} is required\nUsage: ${usage}`;
+            console.error(chalk.red(`❌ ${argName} is required`));
+            console.error(chalk.dim(`Usage: ${usage}`));
+            return formatForInkCli(errorMsg);
+        }
+        return null;
+    }
+    /**
+     * No output (command executed successfully with no output to display)
+     */
+    static noOutput() {
+        return '';
+    }
+}

package/dist/cli/commands/interactive-commands/utils/format-output.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Utility functions for formatting command output for ink-cli
+ * Strips chalk formatting and provides plain text versions
+ */
+/**
+ * Strip ANSI color codes from a string
+ */
+export declare function stripAnsi(str: string): string;
+/**
+ * Format output for ink-cli (removes chalk formatting)
+ * This allows commands to use chalk for regular CLI while returning plain text for ink-cli
+ */
+export declare function formatForInkCli(output: string): string;
+//# sourceMappingURL=format-output.d.ts.map

package/dist/cli/commands/interactive-commands/utils/format-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-output.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/interactive-commands/utils/format-output.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/dist/cli/commands/interactive-commands/utils/format-output.js

@@ -0,0 +1,18 @@
+/**
+ * Utility functions for formatting command output for ink-cli
+ * Strips chalk formatting and provides plain text versions
+ */
+import { stripVTControlCharacters } from 'node:util';
+/**
+ * Strip ANSI color codes from a string
+ */
+export function stripAnsi(str) {
+    return stripVTControlCharacters(str);
+}
+/**
+ * Format output for ink-cli (removes chalk formatting)
+ * This allows commands to use chalk for regular CLI while returning plain text for ink-cli
+ */
+export function formatForInkCli(output) {
+    return stripAnsi(output);
+}

package/dist/cli/commands/list-agents.d.ts

@@ -5,12 +5,12 @@ declare const ListAgentsCommandSchema: z.ZodObject<{
     available: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     installed: boolean;
-    verbose: boolean;
     available: boolean;
+    verbose: boolean;
 }, {
     installed?: boolean | undefined;
-    verbose?: boolean | undefined;
     available?: boolean | undefined;
+    verbose?: boolean | undefined;
 }>;
 export type ListAgentsCommandOptions = z.output<typeof ListAgentsCommandSchema>;
 export type ListAgentsCommandOptionsInput = z.input<typeof ListAgentsCommandSchema>;

package/dist/cli/commands/list-agents.js

@@ -4,7 +4,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import chalk from 'chalk';
 import { z } from 'zod';
-import { getAgentRegistry, getDextoGlobalPath, globalPreferencesExist, loadGlobalPreferences, } from '@dexto/core';
+import { getAgentRegistry, getDextoGlobalPath, globalPreferencesExist, loadGlobalPreferences, } from '@dexto/agent-management';
 // Zod schema for list-agents command validation
 const ListAgentsCommandSchema = z
     .object({

package/dist/cli/commands/session-commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-commands.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/session-commands.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAU,UAAU,EAAwB,MAAM,aAAa,CAAC;AA0CvE;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAmD/E;AAED;;GAEG;AACH,wBAAsB,2BAA2B,CAC7C,KAAK,EAAE,UAAU,EACjB,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC5C,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAqBf;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC5C,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACL,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;CACb,GACP,OAAO,CAAC,IAAI,CAAC,CAyFf"}
+{"version":3,"file":"session-commands.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/session-commands.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAU,UAAU,EAAwB,MAAM,aAAa,CAAC;AAgEvE;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAoD/E;AAED;;GAEG;AACH,wBAAsB,2BAA2B,CAC7C,KAAK,EAAE,UAAU,EACjB,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAyBf;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC5C,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAcf;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC5C,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACL,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;CACb,GACP,OAAO,CAAC,IAAI,CAAC,CAyFf"}

package/dist/cli/commands/session-commands.js

@@ -14,12 +14,30 @@ function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 /**
- * Helper to get current session info
+ * Helper to get most recent session info (for non-interactive CLI)
+ * Non-interactive commands don't have a "current session" concept,
+ * so we use the most recently active session as a sensible default.
  */
-async function getCurrentSessionInfo(agent) {
-    const currentId = agent.getCurrentSessionId();
-    const metadata = await agent.getSessionMetadata(currentId);
-    return { id: currentId, metadata };
+async function getMostRecentSessionInfo(agent) {
+    const sessionIds = await agent.listSessions();
+    if (sessionIds.length === 0) {
+        return null;
+    }
+    // Find most recently active session
+    let mostRecentId = null;
+    let mostRecentActivity = 0;
+    for (const sessionId of sessionIds) {
+        const metadata = await agent.getSessionMetadata(sessionId);
+        if (metadata && metadata.lastActivity > mostRecentActivity) {
+            mostRecentActivity = metadata.lastActivity;
+            mostRecentId = sessionId;
+        }
+    }
+    if (!mostRecentId) {
+        return null;
+    }
+    const metadata = await agent.getSessionMetadata(mostRecentId);
+    return { id: mostRecentId, metadata };
 }
 /**
  * Helper to display session history with consistent formatting
@@ -44,7 +62,7 @@ export async function handleSessionListCommand(agent) {
     try {
         console.log(chalk.bold.blue('\n📋 Sessions:\n'));
         const sessionIds = await agent.listSessions();
-        const current = await getCurrentSessionInfo(agent);
+        const mostRecent = await getMostRecentSessionInfo(agent);
         if (sessionIds.length === 0) {
             console.log(chalk.dim('  No sessions found. Run `dexto` to start a new session, or use `dexto -c`/`dexto -r <id>`.\n'));
             return;
@@ -64,8 +82,9 @@ export async function handleSessionListCommand(agent) {
         for (const { id, metadata } of entries) {
             if (!metadata)
                 continue;
-            const isCurrent = id === current.id;
-            console.log(`  ${formatSessionInfo(id, metadata, isCurrent)}`);
+            // Mark most recent session with indicator (instead of "current")
+            const isMostRecent = mostRecent ? id === mostRecent.id : false;
+            console.log(`  ${formatSessionInfo(id, metadata, isMostRecent)}`);
             displayed++;
         }
         console.log(chalk.dim(`\n  Total: ${displayed} of ${sessionIds.length} sessions`));
@@ -81,8 +100,18 @@ export async function handleSessionListCommand(agent) {
  */
 export async function handleSessionHistoryCommand(agent, sessionId) {
     try {
-        // Use provided session ID or current session
-        const targetSessionId = sessionId || agent.getCurrentSessionId();
+        // Use provided session ID or most recent session
+        let targetSessionId = sessionId;
+        if (!targetSessionId) {
+            const recentSession = await getMostRecentSessionInfo(agent);
+            if (!recentSession) {
+                console.log(chalk.red('❌ No sessions found'));
+                console.log(chalk.dim('   Create a session first by running: dexto'));
+                throw new Error('No sessions found');
+            }
+            targetSessionId = recentSession.id;
+            console.log(chalk.dim(`Using most recent session: ${targetSessionId}\n`));
+        }
         await displaySessionHistory(targetSessionId, agent);
     }
     catch (error) {
@@ -90,8 +119,8 @@ export async function handleSessionHistoryCommand(agent, sessionId) {
             console.log(chalk.red(`❌ Session not found: ${sessionId || 'current'}`));
             console.log(chalk.dim('   Use `dexto session list` to see available sessions'));
         }
-        else {
-            logger.error(`Failed to get session history: ${error instanceof Error ? error.message : String(error)}`, null, 'red');
+        else if (error instanceof Error && error.message !== 'No sessions found') {
+            logger.error(`Failed to get session history: ${error.message}`, null, 'red');
         }
         throw error;
     }
@@ -101,13 +130,8 @@ export async function handleSessionHistoryCommand(agent, sessionId) {
  */
 export async function handleSessionDeleteCommand(agent, sessionId) {
     try {
-        const current = await getCurrentSessionInfo(agent);
-        // Check if trying to delete current session
-        if (sessionId === current.id) {
-            console.log(chalk.yellow('⚠️  Cannot delete the currently active session.'));
-            console.log(chalk.dim('   Switch to another session first, then delete this one.'));
-            return;
-        }
+        // Note: For non-interactive CLI, there's no concept of "current session"
+        // We just delete the requested session without restrictions
         await agent.deleteSession(sessionId);
         console.log(chalk.green(`✅ Deleted session: ${chalk.bold(sessionId)}`));
     }

package/dist/cli/commands/setup.d.ts

@@ -7,28 +7,28 @@ declare const SetupCommandSchema: z.ZodEffects<z.ZodObject<{
     force: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     interactive: boolean;
-    force: boolean;
     defaultAgent: string;
-    model?: string | undefined;
+    force: boolean;
     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    model?: string | undefined;
 }, {
     interactive?: boolean | undefined;
-    model?: string | undefined;
     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-    force?: boolean | undefined;
+    model?: string | undefined;
     defaultAgent?: string | undefined;
+    force?: boolean | undefined;
 }>, {
     interactive: boolean;
-    force: boolean;
     defaultAgent: string;
-    model?: string | undefined;
+    force: boolean;
     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    model?: string | undefined;
 }, {
     interactive?: boolean | undefined;
-    model?: string | undefined;
     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-    force?: boolean | undefined;
+    model?: string | undefined;
     defaultAgent?: string | undefined;
+    force?: boolean | undefined;
 }>;
 export type CLISetupOptions = z.output<typeof SetupCommandSchema>;
 export type CLISetupOptionsInput = z.input<typeof SetupCommandSchema>;

package/dist/cli/commands/setup.js

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import { z } from 'zod';
 import { getDefaultModelForProvider, LLM_PROVIDERS, isValidProviderModel, getSupportedModels, } from '@dexto/core';
 import { getPrimaryApiKeyEnvVar, resolveApiKeyForProvider } from '@dexto/core';
-import { createInitialPreferences, saveGlobalPreferences } from '@dexto/core';
+import { createInitialPreferences, saveGlobalPreferences } from '@dexto/agent-management';
 import { interactiveApiKeySetup } from '../utils/api-key-setup.js';
 import { selectProvider } from '../utils/provider-setup.js';
 import { requiresSetup } from '../utils/setup-utils.js';

package/dist/cli/commands/uninstall.d.ts

@@ -4,13 +4,13 @@ declare const UninstallCommandSchema: z.ZodObject<{
     all: z.ZodDefault<z.ZodBoolean>;
     force: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    force: boolean;
-    agents: string[];
     all: boolean;
+    agents: string[];
+    force: boolean;
 }, {
     agents: string[];
-    force?: boolean | undefined;
     all?: boolean | undefined;
+    force?: boolean | undefined;
 }>;
 export type UninstallCommandOptions = z.output<typeof UninstallCommandSchema>;
 export declare function handleUninstallCommand(agents: string[], options: Partial<UninstallCommandOptions>): Promise<void>;

package/dist/cli/commands/uninstall.js

@@ -1,6 +1,6 @@
 // packages/cli/src/cli/commands/uninstall.ts
 import { z } from 'zod';
-import { getAgentRegistry } from '@dexto/core';
+import { getAgentRegistry } from '@dexto/agent-management';
 import { capture } from '../../analytics/index.js';
 // Zod schema for uninstall command validation
 const UninstallCommandSchema = z

package/dist/cli/commands/which.js

@@ -1,7 +1,7 @@
 // packages/cli/src/cli/commands/which.ts
 import chalk from 'chalk';
 import { z } from 'zod';
-import { resolveAgentPath, getAgentRegistry } from '@dexto/core';
+import { resolveAgentPath, getAgentRegistry } from '@dexto/agent-management';
 // Zod schema for which command validation
 const WhichCommandSchema = z
     .object({

package/dist/cli/ink-cli/InkCLIRefactored.d.ts

@@ -0,0 +1,44 @@
+/**
+ * InkCLI Component (Refactored)
+ *
+ * Main orchestrator component - dramatically simplified from 1150 lines to ~150 lines
+ *
+ * Architecture:
+ * - State managed by useReducer with typed actions
+ * - Business logic in services
+ * - Event handling via custom hooks
+ * - UI in presentational components
+ * - Smart containers orchestrate interactions
+ *
+ * Before: 50+ useState hooks, 15+ useEffect hooks, complex state management
+ * After: 1 useReducer, 5 custom hooks, clear separation of concerns
+ */
+import type { DextoAgent } from '@dexto/core';
+import { type StartupInfo } from './state/index.js';
+interface InkCLIProps {
+    agent: DextoAgent;
+    initialSessionId: string | null;
+    startupInfo: StartupInfo;
+}
+/**
+ * Modern CLI interface using React Ink
+ *
+ * Refactored for:
+ * - Clear separation of concerns
+ * - Testability
+ * - Maintainability
+ * - Performance
+ * - Type safety
+ *
+ * Uses explicit sessionId in state (like WebUI) instead of defaultSession pattern
+ */
+export declare function InkCLIRefactored({ agent, initialSessionId, startupInfo }: InkCLIProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Start the modern Ink-based CLI
+ * Entry point for the refactored CLI
+ * @param agent - The DextoAgent instance
+ * @param initialSessionId - The session ID to use for this CLI session
+ */
+export declare function startInkCliRefactored(agent: DextoAgent, initialSessionId: string | null): Promise<void>;
+export {};
+//# sourceMappingURL=InkCLIRefactored.d.ts.map

package/dist/cli/ink-cli/InkCLIRefactored.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InkCLIRefactored.d.ts","sourceRoot":"","sources":["../../../src/cli/ink-cli/InkCLIRefactored.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,OAAO,EAAkC,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAqBpF,UAAU,WAAW;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,WAAW,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,EAAE,WAAW,2CA+IrF;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACvC,KAAK,EAAE,UAAU,EACjB,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAChC,OAAO,CAAC,IAAI,CAAC,CAiBf"}

package/dist/cli/ink-cli/InkCLIRefactored.js

@@ -0,0 +1,159 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * InkCLI Component (Refactored)
+ *
+ * Main orchestrator component - dramatically simplified from 1150 lines to ~150 lines
+ *
+ * Architecture:
+ * - State managed by useReducer with typed actions
+ * - Business logic in services
+ * - Event handling via custom hooks
+ * - UI in presentational components
+ * - Smart containers orchestrate interactions
+ *
+ * Before: 50+ useState hooks, 15+ useEffect hooks, complex state management
+ * After: 1 useReducer, 5 custom hooks, clear separation of concerns
+ */
+import { useReducer, useMemo, useEffect } from 'react';
+import { Box, render } from 'ink';
+import { registerGracefulShutdown } from '../../utils/graceful-shutdown.js';
+// State management
+import { cliReducer, createInitialState } from './state/index.js';
+// Custom hooks
+import { useAgentEvents, useInputHistory, useKeyboardShortcuts } from './hooks/index.js';
+// Services
+import { InputService, MessageService } from './services/index.js';
+// Utils
+import { getStartupInfo, convertHistoryToUIMessages } from './utils/messageFormatting.js';
+// Components
+import { ChatView } from './components/chat/ChatView.js';
+import { Footer } from './components/chat/Footer.js';
+import { ErrorBoundary } from './components/ErrorBoundary.js';
+import { StatusBar } from './components/StatusBar.js';
+// Containers
+import { InputContainer } from './containers/InputContainer.js';
+import { OverlayContainer } from './containers/OverlayContainer.js';
+/**
+ * Modern CLI interface using React Ink
+ *
+ * Refactored for:
+ * - Clear separation of concerns
+ * - Testability
+ * - Maintainability
+ * - Performance
+ * - Type safety
+ *
+ * Uses explicit sessionId in state (like WebUI) instead of defaultSession pattern
+ */
+export function InkCLIRefactored({ agent, initialSessionId, startupInfo }) {
+    // Initialize state with reducer and set initial sessionId (may be null for deferred creation)
+    const [state, dispatch] = useReducer(cliReducer, undefined, () => {
+        const initialModelName = agent.getCurrentLLMConfig().model;
+        const initial = createInitialState([], initialModelName);
+        initial.session.id = initialSessionId;
+        initial.session.hasActiveSession = initialSessionId !== null;
+        return initial;
+    });
+    // Initialize services (memoized)
+    const inputService = useMemo(() => new InputService(), []);
+    const messageService = useMemo(() => new MessageService(), []);
+    // Setup event bus subscriptions
+    useAgentEvents({ agent, dispatch, isCancelling: state.ui.isCancelling });
+    // Session is now managed in state - no need for sync hook
+    // useSessionSync removed - sessionId is in state from initialization or SESSION_SET actions
+    // Setup input history navigation
+    useInputHistory({
+        inputState: state.input,
+        dispatch,
+        isActive: !state.ui.isProcessing && !state.approval && state.ui.activeOverlay === 'none',
+    });
+    // Setup global keyboard shortcuts
+    useKeyboardShortcuts({ state, dispatch, agent });
+    // Hydrate conversation history when resuming a session
+    useEffect(() => {
+        if (!initialSessionId || !state.session.hasActiveSession || state.messages.length > 0) {
+            return;
+        }
+        let cancelled = false;
+        (async () => {
+            try {
+                const history = await agent.getSessionHistory(initialSessionId);
+                if (!history?.length || cancelled)
+                    return;
+                const historyMessages = convertHistoryToUIMessages(history, initialSessionId);
+                dispatch({ type: 'MESSAGE_ADD_MULTIPLE', messages: historyMessages });
+            }
+            catch (error) {
+                if (cancelled)
+                    return;
+                dispatch({
+                    type: 'ERROR',
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                });
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [agent, dispatch, initialSessionId, state.messages.length, state.session.hasActiveSession]);
+    // Detect overlays based on input (with guards to prevent infinite loop)
+    useEffect(() => {
+        // Don't detect overlays if processing or approval is active
+        if (state.ui.isProcessing || state.approval)
+            return;
+        const autocompleteType = inputService.detectAutocompleteType(state.input.value);
+        const selectorType = inputService.detectInteractiveSelector(state.input.value);
+        // Determine what overlay should be shown
+        let desiredOverlay = 'none';
+        // Priority: selector > autocomplete
+        if (selectorType === 'model') {
+            desiredOverlay = 'model-selector';
+        }
+        else if (selectorType === 'session') {
+            desiredOverlay = 'session-selector';
+        }
+        else if (autocompleteType === 'slash') {
+            desiredOverlay = 'slash-autocomplete';
+        }
+        else if (autocompleteType === 'resource') {
+            desiredOverlay = 'resource-autocomplete';
+        }
+        // Only dispatch if overlay needs to change
+        if (desiredOverlay !== state.ui.activeOverlay && state.ui.activeOverlay !== 'approval') {
+            if (desiredOverlay === 'none') {
+                dispatch({ type: 'CLOSE_OVERLAY' });
+            }
+            else {
+                dispatch({ type: 'SHOW_OVERLAY', overlay: desiredOverlay });
+            }
+        }
+    }, [
+        state.input.value,
+        state.ui.isProcessing,
+        state.approval,
+        state.ui.activeOverlay,
+        inputService,
+        dispatch,
+    ]);
+    // Get visible messages (performance optimization)
+    // Limit to last 30 messages to prevent scrolling issues
+    const visibleMessages = useMemo(() => {
+        return messageService.getVisibleMessages(state.messages, 30);
+    }, [state.messages, messageService]);
+    return (_jsx(ErrorBoundary, { children: _jsxs(Box, { flexDirection: "column", height: "100%", width: "100%", children: [_jsx(ChatView, { messages: visibleMessages, modelName: state.session.modelName, sessionId: state.session.id || undefined, hasActiveSession: state.session.hasActiveSession, startupInfo: startupInfo }), _jsx(StatusBar, { isProcessing: state.ui.isProcessing, isThinking: state.ui.isThinking, approvalQueueCount: state.approvalQueue.length }), _jsx(OverlayContainer, { state: state, dispatch: dispatch, agent: agent, inputService: inputService }), _jsx(InputContainer, { state: state, dispatch: dispatch, agent: agent, inputService: inputService }), _jsx(Footer, {})] }) }));
+}
+/**
+ * Start the modern Ink-based CLI
+ * Entry point for the refactored CLI
+ * @param agent - The DextoAgent instance
+ * @param initialSessionId - The session ID to use for this CLI session
+ */
+export async function startInkCliRefactored(agent, initialSessionId) {
+    registerGracefulShutdown(() => agent);
+    // Note: Console suppression is done in index.ts before calling this function
+    const startupInfo = await getStartupInfo(agent);
+    const inkApp = render(_jsx(InkCLIRefactored, { agent: agent, initialSessionId: initialSessionId, startupInfo: startupInfo }));
+    // Wait for the Ink app to exit before resolving
+    // This ensures console suppression remains active until the UI is fully closed
+    await inkApp.waitUntilExit();
+}

package/dist/cli/ink-cli/components/ApprovalPrompt.d.ts

@@ -0,0 +1,21 @@
+export interface ApprovalRequest {
+    approvalId: string;
+    type: string;
+    sessionId?: string;
+    timeout?: number;
+    timestamp: Date;
+    metadata: Record<string, unknown>;
+}
+interface ApprovalPromptProps {
+    approval: ApprovalRequest;
+    onApprove: (rememberChoice: boolean) => void;
+    onDeny: () => void;
+    onCancel: () => void;
+}
+/**
+ * Compact approval prompt component that displays above the input area
+ * Shows three options in a vertical list: Yes, Yes for Session, and No
+ */
+export declare function ApprovalPrompt({ approval, onApprove, onDeny, onCancel }: ApprovalPromptProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=ApprovalPrompt.d.ts.map

package/dist/cli/ink-cli/components/ApprovalPrompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApprovalPrompt.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/components/ApprovalPrompt.tsx"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED,UAAU,mBAAmB;IACzB,QAAQ,EAAE,eAAe,CAAC;IAC1B,SAAS,EAAE,CAAC,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,QAAQ,EAAE,MAAM,IAAI,CAAC;CACxB;AAID;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,mBAAmB,2CA6G5F"}

package/dist/cli/ink-cli/components/ApprovalPrompt.js

@@ -0,0 +1,55 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+/**
+ * Compact approval prompt component that displays above the input area
+ * Shows three options in a vertical list: Yes, Yes for Session, and No
+ */
+export function ApprovalPrompt({ approval, onApprove, onDeny, onCancel }) {
+    const isCommandConfirmation = approval.type === 'command_confirmation';
+    const [selectedOption, setSelectedOption] = useState('yes');
+    // Handle keyboard navigation (vertical)
+    useInput((input, key) => {
+        if (key.upArrow) {
+            // Move up (skip yes-session for command confirmations)
+            setSelectedOption((current) => {
+                if (current === 'yes')
+                    return 'no';
+                if (current === 'yes-session')
+                    return 'yes';
+                // no -> yes-session (or yes for command confirmations)
+                return isCommandConfirmation ? 'yes' : 'yes-session';
+            });
+        }
+        else if (key.downArrow) {
+            // Move down (skip yes-session for command confirmations)
+            setSelectedOption((current) => {
+                if (current === 'yes')
+                    return isCommandConfirmation ? 'no' : 'yes-session';
+                if (current === 'yes-session')
+                    return 'no';
+                return 'yes'; // no -> yes (wrap)
+            });
+        }
+        else if (key.return) {
+            // Enter key - confirm selection
+            if (selectedOption === 'yes') {
+                onApprove(false);
+            }
+            else if (selectedOption === 'yes-session') {
+                onApprove(true);
+            }
+            else {
+                onDeny();
+            }
+        }
+        else if (key.escape) {
+            // Escape key - cancel
+            onCancel();
+        }
+    }, { isActive: true });
+    // Extract information from metadata based on approval type
+    const toolName = approval.metadata.toolName;
+    const command = approval.metadata.command;
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "yellow", paddingX: 1, paddingY: 0, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", marginBottom: 0, children: [_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: "yellow", bold: true, children: ["\uD83D\uDD10 Approval:", ' '] }), toolName && _jsx(Text, { color: "cyan", children: toolName })] }), isCommandConfirmation && command && (_jsxs(Box, { flexDirection: "row", marginTop: 0, children: [_jsx(Text, { color: "gray", children: '  Command: ' }), _jsx(Text, { color: "red", children: command })] }))] }), _jsxs(Box, { flexDirection: "column", marginTop: 0, children: [_jsx(Box, { children: selectedOption === 'yes' ? (_jsxs(Text, { color: "green", bold: true, children: ['  ▶ ', "Yes"] })) : (_jsxs(Text, { color: "gray", children: ['    ', "Yes"] })) }), !isCommandConfirmation && (_jsx(Box, { children: selectedOption === 'yes-session' ? (_jsxs(Text, { color: "green", bold: true, children: ['  ▶ ', "Yes (Session)"] })) : (_jsxs(Text, { color: "gray", children: ['    ', "Yes (Session)"] })) })), _jsx(Box, { children: selectedOption === 'no' ? (_jsxs(Text, { color: "red", bold: true, children: ['  ▶ ', "No"] })) : (_jsxs(Text, { color: "gray", children: ['    ', "No"] })) })] }), _jsx(Box, { marginTop: 0, children: _jsxs(Text, { color: "gray", dimColor: true, children: ['  ', "\u2191\u2193 to select \u2022 Enter to confirm \u2022 Esc to cancel"] }) })] }));
+}

package/dist/cli/ink-cli/components/CustomInput.d.ts

@@ -0,0 +1,17 @@
+interface CustomInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    placeholder?: string;
+    isProcessing?: boolean;
+    onWordDelete?: () => void;
+    onLineDelete?: () => void;
+    onToggleMultiLine?: () => void;
+}
+/**
+ * Custom input component that handles keyboard shortcuts
+ * Fully custom implementation without TextInput to properly handle shortcuts
+ */
+export default function CustomInput({ value, onChange, onSubmit, placeholder, isProcessing, onWordDelete, onLineDelete, onToggleMultiLine, }: CustomInputProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=CustomInput.d.ts.map

package/dist/cli/ink-cli/components/CustomInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomInput.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/components/CustomInput.tsx"],"names":[],"mappings":"AAEA,UAAU,gBAAgB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,EAChC,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,YAAoB,EACpB,YAAY,EACZ,YAAY,EACZ,iBAAiB,GACpB,EAAE,gBAAgB,2CAoElB"}