@dexto/tui 1.6.2

package/dist/index.d.cts

@@ -0,0 +1,195 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { DextoAgent, LLMProvider } from '@dexto/core';
+
+/**
+ * Core state types for Ink CLI
+ * Central type definitions for the CLI state machine
+ */
+
+/**
+ * Update information for version check
+ */
+interface UpdateInfo {
+    current: string;
+    latest: string;
+    updateCommand: string;
+}
+/**
+ * Startup information displayed in CLI header
+ */
+interface StartupInfo {
+    connectedServers: {
+        count: number;
+        names: string[];
+    };
+    failedConnections: string[];
+    toolCount: number;
+    logFile: string | null;
+    /** Update info if a newer version is available */
+    updateInfo?: UpdateInfo | undefined;
+    /** True if installed agents differ from bundled and user should sync */
+    needsAgentSync?: boolean | undefined;
+}
+
+/**
+ * Sound configuration interface
+ *
+ * Note: Default values are defined in PreferenceSoundsSchema (packages/agent-management/src/preferences/schemas.ts)
+ * which is the single source of truth for sound preferences.
+ */
+interface SoundConfig {
+    enabled: boolean;
+    onStartup: boolean;
+    startupSoundFile?: string | undefined;
+    onApprovalRequired: boolean;
+    approvalSoundFile?: string | undefined;
+    onTaskComplete: boolean;
+    completeSoundFile?: string | undefined;
+}
+/**
+ * Sound notification service that respects configuration
+ *
+ * All fields are required - callers should provide complete config from preferences.
+ * Default values come from PreferenceSoundsSchema in @dexto/agent-management.
+ */
+declare class SoundNotificationService {
+    private config;
+    constructor(config: SoundConfig);
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<SoundConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): SoundConfig;
+    /**
+     * Play CLI startup sound if enabled
+     */
+    playStartupSound(): void;
+    /**
+     * Play approval required sound if enabled
+     */
+    playApprovalSound(): void;
+    /**
+     * Play task complete sound if enabled
+     */
+    playCompleteSound(): void;
+}
+
+interface InkCLIProps {
+    agent: DextoAgent;
+    initialSessionId: string | null;
+    initialPrompt?: string | undefined;
+    startupInfo: StartupInfo;
+    soundService: SoundNotificationService | null;
+    configFilePath: string | null;
+    initialBypassPermissions?: boolean;
+}
+/**
+ * Modern CLI interface using React Ink
+ *
+ * Wraps the CLI with:
+ * - ErrorBoundary for graceful error handling
+ * - KeypressProvider for unified keyboard input
+ * - MouseProvider (only in alternate buffer mode)
+ */
+declare function InkCLIRefactored({ agent, initialSessionId, initialPrompt, startupInfo, soundService, configFilePath, initialBypassPermissions, }: InkCLIProps): react_jsx_runtime.JSX.Element;
+/**
+ * Options for starting the Ink CLI
+ */
+interface InkCLIOptions {
+    /** Update info if a newer version is available */
+    updateInfo?: {
+        current: string;
+        latest: string;
+        updateCommand: string;
+    } | undefined;
+    /** True if installed agents differ from bundled and user should sync */
+    needsAgentSync?: boolean | undefined;
+    /** Source agent config file path (if available) */
+    configFilePath?: string | null | undefined;
+    /** If provided, auto-submits this prompt once the UI is ready */
+    initialPrompt?: string | undefined;
+    /** Start the UI with bypass permissions mode enabled */
+    bypassPermissions?: boolean | undefined;
+}
+/**
+ * Start the modern Ink-based CLI
+ */
+declare function startInkCliRefactored(agent: DextoAgent, initialSessionId: string | null, options?: InkCLIOptions): Promise<void>;
+
+interface TuiAuthConfig {
+    token?: string | undefined;
+    refreshToken?: string | undefined;
+    userId?: string | undefined;
+    email?: string | undefined;
+    expiresAt?: number | undefined;
+    createdAt: number;
+    dextoApiKey?: string | undefined;
+    dextoKeyId?: string | undefined;
+    dextoApiKeySource?: 'provisioned' | 'user-supplied' | undefined;
+}
+interface TuiOAuthConfig {
+    authUrl: string;
+    clientId: string;
+    provider?: string;
+    scopes?: string[];
+}
+interface TuiOAuthResult {
+    accessToken: string;
+    refreshToken?: string | undefined;
+    expiresIn?: number | undefined;
+    user?: {
+        id: string;
+        email: string;
+        name?: string | undefined;
+    } | undefined;
+}
+interface TuiOAuthLoginSession {
+    authUrl: string;
+    result: Promise<TuiOAuthResult>;
+}
+type TuiDextoApiKeyProvisionStatusLevel = 'info' | 'success' | 'warning' | 'error';
+interface TuiDextoApiKeyProvisionStatus {
+    level: TuiDextoApiKeyProvisionStatusLevel;
+    message: string;
+}
+interface TuiRuntimeServices {
+    registerGracefulShutdown?: (getAgent: () => DextoAgent, options: {
+        inkMode: boolean;
+    }) => void;
+    capture?: (event: string, properties?: Record<string, unknown>) => void;
+    applyLayeredEnvironmentLoading?: () => Promise<void>;
+    getProviderDisplayName?: (provider: LLMProvider | string) => string;
+    isValidApiKeyFormat?: (apiKey: string, provider: LLMProvider) => boolean;
+    getProviderInstructions?: (provider: LLMProvider) => {
+        title: string;
+        content: string;
+        url?: string | undefined;
+    } | null;
+    beginOAuthLogin?: (config: TuiOAuthConfig, options?: {
+        signal?: AbortSignal | undefined;
+    }) => Promise<TuiOAuthLoginSession>;
+    defaultOAuthConfig?: TuiOAuthConfig;
+    ensureDextoApiKeyForAuthToken?: (authToken: string, options?: {
+        onStatus?: ((status: TuiDextoApiKeyProvisionStatus) => void) | undefined;
+    }) => Promise<{
+        dextoApiKey: string;
+        keyId: string | null;
+    } | null>;
+    loadAuth?: () => Promise<TuiAuthConfig | null>;
+    storeAuth?: (config: TuiAuthConfig) => Promise<void>;
+    removeAuth?: () => Promise<void>;
+    removeDextoApiKeyFromEnv?: (options?: {
+        expectedValue?: string;
+    }) => Promise<{
+        removed: boolean;
+        targetEnvPath: string;
+    }>;
+    isUsingDextoCredits?: () => Promise<boolean>;
+    canUseDextoProvider?: () => Promise<boolean>;
+}
+declare function setTuiRuntimeServices(adapter: TuiRuntimeServices): void;
+
+export { type InkCLIOptions, InkCLIRefactored, type TuiRuntimeServices, setTuiRuntimeServices, startInkCliRefactored };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { startInkCliRefactored, type InkCLIOptions, InkCLIRefactored } from './InkCLIRefactored.js';
+export { setTuiRuntimeServices, type TuiRuntimeServices } from './host/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,KAAK,aAAa,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEpG,OAAO,EAAE,qBAAqB,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+import { startInkCliRefactored, InkCLIRefactored } from "./InkCLIRefactored.js";
+import { setTuiRuntimeServices } from "./host/index.js";
+export {
+  InkCLIRefactored,
+  setTuiRuntimeServices,
+  startInkCliRefactored
+};

package/dist/interactive-commands/auth/index.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var auth_exports = {};
+__export(auth_exports, {
+  loginCommand: () => loginCommand,
+  logoutCommand: () => logoutCommand
+});
+module.exports = __toCommonJS(auth_exports);
+var import_command_parser = require("../command-parser.js");
+const loginCommand = {
+  name: "login",
+  description: "Login to Dexto",
+  usage: "/login",
+  category: "General",
+  handler: import_command_parser.overlayOnlyHandler
+};
+const logoutCommand = {
+  name: "logout",
+  description: "Logout from Dexto",
+  usage: "/logout",
+  category: "General",
+  handler: import_command_parser.overlayOnlyHandler
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loginCommand,
+  logoutCommand
+});

package/dist/interactive-commands/auth/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Auth Commands Module
+ *
+ * Authentication commands for interactive CLI.
+ */
+import type { CommandDefinition } from '../command-parser.js';
+/**
+ * Login command - triggers OAuth flow for Dexto authentication
+ * Only available when DEXTO_FEATURE_AUTH=true
+ */
+export declare const loginCommand: CommandDefinition;
+export declare const logoutCommand: CommandDefinition;
+//# sourceMappingURL=index.d.ts.map

package/dist/interactive-commands/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/interactive-commands/auth/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG9D;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,iBAM1B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,iBAM3B,CAAC"}

package/dist/interactive-commands/auth/index.js

@@ -0,0 +1,19 @@
+import { overlayOnlyHandler } from "../command-parser.js";
+const loginCommand = {
+  name: "login",
+  description: "Login to Dexto",
+  usage: "/login",
+  category: "General",
+  handler: overlayOnlyHandler
+};
+const logoutCommand = {
+  name: "logout",
+  description: "Logout from Dexto",
+  usage: "/logout",
+  category: "General",
+  handler: overlayOnlyHandler
+};
+export {
+  loginCommand,
+  logoutCommand
+};

package/dist/interactive-commands/command-parser.cjs

@@ -0,0 +1,184 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var command_parser_exports = {};
+__export(command_parser_exports, {
+  displayAllCommands: () => displayAllCommands,
+  formatCommandHelp: () => formatCommandHelp,
+  getCommandSuggestions: () => getCommandSuggestions,
+  overlayOnlyHandler: () => overlayOnlyHandler,
+  parseInput: () => parseInput
+});
+module.exports = __toCommonJS(command_parser_exports);
+var import_chalk = __toESM(require("chalk"), 1);
+const overlayOnlyHandler = async () => true;
+function parseQuotedArguments(input) {
+  const args = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    const nextChar = input[i + 1];
+    if (!inQuotes && (char === '"' || char === "'")) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (inQuotes && char === quoteChar) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (!inQuotes && char === " ") {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+    } else if (char === "\\" && nextChar) {
+      current += nextChar;
+      i++;
+    } else {
+      current += char;
+    }
+    i++;
+  }
+  if (current) {
+    args.push(current);
+  }
+  return args.filter((arg) => arg.length > 0);
+}
+function parseInput(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("!")) {
+    const shellCommand = trimmed.slice(1).trim();
+    return {
+      type: "command",
+      command: "shell",
+      args: [shellCommand],
+      rawInput: trimmed
+    };
+  }
+  if (trimmed.startsWith("/")) {
+    const args = parseQuotedArguments(trimmed.slice(1));
+    const command = args[0] || "";
+    const commandArgs = args.slice(1);
+    return {
+      type: "command",
+      command,
+      args: commandArgs,
+      rawInput: trimmed
+    };
+  }
+  return {
+    type: "prompt",
+    rawInput: input
+  };
+}
+function getCommandSuggestions(partial, commands) {
+  const suggestions = [];
+  for (const cmd of commands) {
+    if (cmd.name.startsWith(partial)) {
+      suggestions.push(cmd.name);
+    }
+    if (cmd.aliases) {
+      for (const alias of cmd.aliases) {
+        if (alias.startsWith(partial)) {
+          suggestions.push(alias);
+        }
+      }
+    }
+  }
+  return suggestions.sort();
+}
+function formatCommandHelp(cmd, detailed = false) {
+  let help = import_chalk.default.cyan(`/${cmd.name}`) + " - " + cmd.description;
+  if (detailed) {
+    help += "\n" + import_chalk.default.gray(`Usage: ${cmd.usage}`);
+    if (cmd.aliases && cmd.aliases.length > 0) {
+      help += "\n" + import_chalk.default.gray(`Aliases: ${cmd.aliases.map((a) => `/${a}`).join(", ")}`);
+    }
+    if (cmd.subcommands && cmd.subcommands.length > 0) {
+      help += "\n" + import_chalk.default.gray("Subcommands:");
+      for (const sub of cmd.subcommands) {
+        help += "\n  " + import_chalk.default.cyan(`/${cmd.name} ${sub.name}`) + " - " + sub.description;
+      }
+    }
+  }
+  return help;
+}
+function displayAllCommands(commands) {
+  console.log(import_chalk.default.bold.green("\n\u{1F4CB} Available Commands:\n"));
+  const categoryOrder = [
+    "General",
+    "Session Management",
+    "Model Management",
+    "MCP Management",
+    "Plugin Management",
+    "Tool Management",
+    "Prompt Management",
+    "System"
+  ];
+  const categories = {};
+  for (const category of categoryOrder) {
+    categories[category] = [];
+  }
+  for (const cmd of commands) {
+    const category = cmd.category || "General";
+    if (!categories[category]) {
+      categories[category] = [];
+    }
+    categories[category].push(cmd);
+  }
+  for (const category of categoryOrder) {
+    const cmds = categories[category];
+    if (cmds && cmds.length > 0) {
+      console.log(import_chalk.default.bold.rgb(255, 165, 0)(`${category}:`));
+      for (const cmd of cmds) {
+        console.log("  " + formatCommandHelp(cmd));
+      }
+      console.log();
+    }
+  }
+  for (const [category, cmds] of Object.entries(categories)) {
+    if (!categoryOrder.includes(category) && cmds.length > 0) {
+      console.log(import_chalk.default.bold.rgb(255, 165, 0)(`${category}:`));
+      for (const cmd of cmds) {
+        console.log("  " + formatCommandHelp(cmd));
+      }
+      console.log();
+    }
+  }
+  console.log(import_chalk.default.gray("\u{1F4A1} Tip: Use /help <command> for detailed help on any command"));
+  console.log(import_chalk.default.gray("\u{1F4A1} Tip: Type your message normally (without /) to chat with the AI\n"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  displayAllCommands,
+  formatCommandHelp,
+  getCommandSuggestions,
+  overlayOnlyHandler,
+  parseInput
+});

package/dist/interactive-commands/command-parser.d.ts

@@ -0,0 +1,56 @@
+import type { DextoAgent } from '@dexto/core';
+import type { StyledOutput, SendMessageMarker } from '../services/CommandService.js';
+export interface CommandResult {
+    type: 'command' | 'prompt';
+    command?: string;
+    args?: string[];
+    rawInput: string;
+}
+/**
+ * Command handler return type:
+ * - boolean: Command handled (true) or not found (false)
+ * - string: Output text to display
+ * - StyledOutput: Styled output with structured data for rich rendering
+ * - SendMessageMarker: Send text through normal streaming flow (for prompt commands)
+ */
+export type CommandHandlerResult = boolean | string | StyledOutput | SendMessageMarker;
+/**
+ * Context passed to command handlers
+ */
+export interface CommandContext {
+    /** Current session ID, or null if no active session */
+    sessionId: string | null;
+    /** Source config file path for persistence and display (if available) */
+    configFilePath: string | null;
+}
+export interface CommandDefinition {
+    name: string;
+    description: string;
+    usage: string;
+    category?: string;
+    aliases?: string[];
+    subcommands?: CommandDefinition[];
+    handler: (args: string[], agent: DextoAgent, ctx: CommandContext) => Promise<CommandHandlerResult>;
+}
+/**
+ * No-op handler for overlay-only commands.
+ * Used by commands in ALWAYS_OVERLAY that are handled entirely by the overlay system.
+ */
+export declare const overlayOnlyHandler: () => Promise<CommandHandlerResult>;
+/**
+ * Parses user input to determine if it's a slash command, shell command, or regular prompt
+ */
+export declare function parseInput(input: string): CommandResult;
+/**
+ * Finds command suggestions based on partial input
+ */
+export declare function getCommandSuggestions(partial: string, commands: CommandDefinition[]): string[];
+/**
+ * Formats help text for a command
+ */
+export declare function formatCommandHelp(cmd: CommandDefinition, detailed?: boolean): string;
+/**
+ * Displays a formatted list of all available commands
+ */
+export declare function displayAllCommands(commands: CommandDefinition[]): void;
+//# sourceMappingURL=command-parser.d.ts.map

package/dist/interactive-commands/command-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-parser.d.ts","sourceRoot":"","sources":["../../src/interactive-commands/command-parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAErF,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,MAAM,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAEvF;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,uDAAuD;IACvD,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,yEAAyE;IACzE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAClC,OAAO,EAAE,CACL,IAAI,EAAE,MAAM,EAAE,EACd,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,cAAc,KAClB,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACtC;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAa,OAAO,CAAC,oBAAoB,CAAS,CAAC;AA4ClF;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAiCvD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAAE,GAAG,MAAM,EAAE,CAoB9F;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,iBAAiB,EAAE,QAAQ,GAAE,OAAe,GAAG,MAAM,CAmB3F;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAwDtE"}

package/dist/interactive-commands/command-parser.js

@@ -0,0 +1,146 @@
+import chalk from "chalk";
+const overlayOnlyHandler = async () => true;
+function parseQuotedArguments(input) {
+  const args = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    const nextChar = input[i + 1];
+    if (!inQuotes && (char === '"' || char === "'")) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (inQuotes && char === quoteChar) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (!inQuotes && char === " ") {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+    } else if (char === "\\" && nextChar) {
+      current += nextChar;
+      i++;
+    } else {
+      current += char;
+    }
+    i++;
+  }
+  if (current) {
+    args.push(current);
+  }
+  return args.filter((arg) => arg.length > 0);
+}
+function parseInput(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("!")) {
+    const shellCommand = trimmed.slice(1).trim();
+    return {
+      type: "command",
+      command: "shell",
+      args: [shellCommand],
+      rawInput: trimmed
+    };
+  }
+  if (trimmed.startsWith("/")) {
+    const args = parseQuotedArguments(trimmed.slice(1));
+    const command = args[0] || "";
+    const commandArgs = args.slice(1);
+    return {
+      type: "command",
+      command,
+      args: commandArgs,
+      rawInput: trimmed
+    };
+  }
+  return {
+    type: "prompt",
+    rawInput: input
+  };
+}
+function getCommandSuggestions(partial, commands) {
+  const suggestions = [];
+  for (const cmd of commands) {
+    if (cmd.name.startsWith(partial)) {
+      suggestions.push(cmd.name);
+    }
+    if (cmd.aliases) {
+      for (const alias of cmd.aliases) {
+        if (alias.startsWith(partial)) {
+          suggestions.push(alias);
+        }
+      }
+    }
+  }
+  return suggestions.sort();
+}
+function formatCommandHelp(cmd, detailed = false) {
+  let help = chalk.cyan(`/${cmd.name}`) + " - " + cmd.description;
+  if (detailed) {
+    help += "\n" + chalk.gray(`Usage: ${cmd.usage}`);
+    if (cmd.aliases && cmd.aliases.length > 0) {
+      help += "\n" + chalk.gray(`Aliases: ${cmd.aliases.map((a) => `/${a}`).join(", ")}`);
+    }
+    if (cmd.subcommands && cmd.subcommands.length > 0) {
+      help += "\n" + chalk.gray("Subcommands:");
+      for (const sub of cmd.subcommands) {
+        help += "\n  " + chalk.cyan(`/${cmd.name} ${sub.name}`) + " - " + sub.description;
+      }
+    }
+  }
+  return help;
+}
+function displayAllCommands(commands) {
+  console.log(chalk.bold.green("\n\u{1F4CB} Available Commands:\n"));
+  const categoryOrder = [
+    "General",
+    "Session Management",
+    "Model Management",
+    "MCP Management",
+    "Plugin Management",
+    "Tool Management",
+    "Prompt Management",
+    "System"
+  ];
+  const categories = {};
+  for (const category of categoryOrder) {
+    categories[category] = [];
+  }
+  for (const cmd of commands) {
+    const category = cmd.category || "General";
+    if (!categories[category]) {
+      categories[category] = [];
+    }
+    categories[category].push(cmd);
+  }
+  for (const category of categoryOrder) {
+    const cmds = categories[category];
+    if (cmds && cmds.length > 0) {
+      console.log(chalk.bold.rgb(255, 165, 0)(`${category}:`));
+      for (const cmd of cmds) {
+        console.log("  " + formatCommandHelp(cmd));
+      }
+      console.log();
+    }
+  }
+  for (const [category, cmds] of Object.entries(categories)) {
+    if (!categoryOrder.includes(category) && cmds.length > 0) {
+      console.log(chalk.bold.rgb(255, 165, 0)(`${category}:`));
+      for (const cmd of cmds) {
+        console.log("  " + formatCommandHelp(cmd));
+      }
+      console.log();
+    }
+  }
+  console.log(chalk.gray("\u{1F4A1} Tip: Use /help <command> for detailed help on any command"));
+  console.log(chalk.gray("\u{1F4A1} Tip: Type your message normally (without /) to chat with the AI\n"));
+}
+export {
+  displayAllCommands,
+  formatCommandHelp,
+  getCommandSuggestions,
+  overlayOnlyHandler,
+  parseInput
+};