ccjk 3.6.1 → 3.7.2

package/dist/index.d.mts

@@ -96,52 +96,52 @@ interface ICodeTool {
     /**
      * Get tool metadata
      */
-    getMetadata(): ToolMetadata;
+    getMetadata: () => ToolMetadata;
     /**
      * Check if the tool is installed
      */
-    isInstalled(): Promise<InstallStatus>;
+    isInstalled: () => Promise<InstallStatus>;
     /**
      * Install the tool
      */
-    install(): Promise<ExecutionResult>;
+    install: () => Promise<ExecutionResult>;
     /**
      * Uninstall the tool
      */
-    uninstall(): Promise<ExecutionResult>;
+    uninstall: () => Promise<ExecutionResult>;
     /**
      * Get current configuration
      */
-    getConfig(): Promise<ToolConfig>;
+    getConfig: () => Promise<ToolConfig>;
     /**
      * Update configuration
      * @param updates Partial configuration to update
      */
-    updateConfig(updates: Partial<ToolConfig>): Promise<void>;
+    updateConfig: (updates: Partial<ToolConfig>) => Promise<void>;
     /**
      * Configure the tool with full config
      * @param config Complete configuration
      */
-    configure(config: ToolConfig): Promise<void>;
+    configure: (config: ToolConfig) => Promise<void>;
     /**
      * Validate configuration
      * @param config Configuration to validate
      */
-    validateConfig(config: Partial<ToolConfig>): Promise<boolean>;
+    validateConfig: (config: Partial<ToolConfig>) => Promise<boolean>;
     /**
      * Execute a command with the tool
      * @param command Command to execute
      * @param args Command arguments
      */
-    execute(command: string, args?: string[]): Promise<ExecutionResult>;
+    execute: (command: string, args?: string[]) => Promise<ExecutionResult>;
     /**
      * Get tool version
      */
-    getVersion(): Promise<string | undefined>;
+    getVersion: () => Promise<string | undefined>;
     /**
      * Reset tool to default configuration
      */
-    reset(): Promise<void>;
+    reset: () => Promise<void>;
 }
 /**
  * Interface for tools that support chat/conversation
@@ -151,16 +151,16 @@ interface IChatTool extends ICodeTool {
      * Start a chat session
      * @param prompt Initial prompt
      */
-    chat(prompt: string): Promise<ExecutionResult>;
+    chat: (prompt: string) => Promise<ExecutionResult>;
     /**
      * Continue a chat session
      * @param message Message to send
      */
-    continueChat(message: string): Promise<ExecutionResult>;
+    continueChat: (message: string) => Promise<ExecutionResult>;
     /**
      * End chat session
      */
-    endChat(): Promise<void>;
+    endChat: () => Promise<void>;
 }
 /**
  * Interface for tools that support file editing
@@ -171,13 +171,13 @@ interface IFileEditTool extends ICodeTool {
      * @param filePath Path to file
      * @param instructions Edit instructions
      */
-    editFile(filePath: string, instructions: string): Promise<ExecutionResult>;
+    editFile: (filePath: string, instructions: string) => Promise<ExecutionResult>;
     /**
      * Edit multiple files
      * @param files Array of file paths
      * @param instructions Edit instructions
      */
-    editFiles(files: string[], instructions: string): Promise<ExecutionResult>;
+    editFiles: (files: string[], instructions: string) => Promise<ExecutionResult>;
 }
 /**
  * Interface for tools that support code generation
@@ -188,7 +188,7 @@ interface ICodeGenTool extends ICodeTool {
      * @param prompt Generation prompt
      * @param outputPath Optional output path
      */
-    generateCode(prompt: string, outputPath?: string): Promise<ExecutionResult>;
+    generateCode: (prompt: string, outputPath?: string) => Promise<ExecutionResult>;
 }
 
 /**
@@ -294,107 +294,85 @@ declare abstract class BaseCodeTool implements ICodeTool {
 }
 
 /**
- * Tool registry for managing code tool instances
+ * Aider adapter
  */
 
 /**
- * Registry for managing code tool instances
+ * Aider tool adapter
  */
-declare class ToolRegistry {
-    private static instance;
-    private tools;
-    private toolClasses;
-    private constructor();
-    /**
-     * Get singleton instance
-     */
-    static getInstance(): ToolRegistry;
-    /**
-     * Register a tool class
-     */
-    registerToolClass(name: string, toolClass: new () => ICodeTool): void;
-    /**
-     * Register a tool instance
-     */
-    registerTool(tool: ICodeTool): void;
-    /**
-     * Get a tool instance by name
-     */
-    getTool(name: string): ICodeTool | undefined;
-    /**
-     * Get all registered tool names
-     */
-    getToolNames(): string[];
+declare class AiderTool extends BaseCodeTool implements IChatTool, IFileEditTool {
+    getMetadata(): ToolMetadata;
+    protected getInstallCheckCommand(): string;
+    protected getInstallCommand(): string;
+    protected getUninstallCommand(): string;
     /**
-     * Get all tool instances
+     * Start a chat session
      */
-    getAllTools(): ICodeTool[];
+    chat(prompt: string): Promise<ExecutionResult>;
     /**
-     * Check if a tool is registered
+     * Continue a chat session
      */
-    hasTool(name: string): boolean;
+    continueChat(message: string): Promise<ExecutionResult>;
     /**
-     * Unregister a tool
+     * End chat session
      */
-    unregisterTool(name: string): void;
+    endChat(): Promise<void>;
     /**
-     * Clear all registered tools
+     * Edit a file
      */
-    clear(): void;
+    editFile(filePath: string, instructions: string): Promise<ExecutionResult>;
     /**
-     * Get metadata for all registered tools
+     * Edit multiple files
      */
-    getAllMetadata(): Promise<ToolMetadata[]>;
+    editFiles(files: string[], instructions: string): Promise<ExecutionResult>;
 }
-/**
- * Convenience function to get the registry instance
- */
-declare function getRegistry(): ToolRegistry;
 
 /**
- * Factory for creating code tool instances
+ * Claude Code adapter
  */
 
 /**
- * Factory for creating code tool instances
+ * Claude Code tool adapter
  */
-declare class ToolFactory {
-    private registry;
-    constructor(registry?: ToolRegistry);
+declare class ClaudeCodeTool extends BaseCodeTool implements IChatTool, IFileEditTool, ICodeGenTool {
+    getMetadata(): ToolMetadata;
+    protected getInstallCheckCommand(): string;
+    protected getInstallCommand(): string;
+    protected getUninstallCommand(): string;
     /**
-     * Create a tool instance by name
+     * Start a chat session
      */
-    createTool(name: string, config?: Partial<ToolConfig>): ICodeTool;
+    chat(prompt: string): Promise<ExecutionResult>;
     /**
-     * Create multiple tool instances
+     * Continue a chat session
      */
-    createTools(names: string[]): ICodeTool[];
+    continueChat(message: string): Promise<ExecutionResult>;
     /**
-     * Create all registered tools
+     * End chat session
      */
-    createAllTools(): ICodeTool[];
+    endChat(): Promise<void>;
     /**
-     * Check if a tool can be created
+     * Edit a file
      */
-    canCreateTool(name: string): boolean;
+    editFile(filePath: string, instructions: string): Promise<ExecutionResult>;
     /**
-     * Get available tool names
+     * Edit multiple files
      */
-    getAvailableTools(): string[];
+    editFiles(files: string[], instructions: string): Promise<ExecutionResult>;
+    /**
+     * Generate code
+     */
+    generateCode(prompt: string, outputPath?: string): Promise<ExecutionResult>;
 }
-/**
- * Convenience function to create a tool
- */
-declare function createTool(name: string, config?: Partial<ToolConfig>): ICodeTool;
 
 /**
- * Claude Code adapter
+ * Cline adapter
  */
 
 /**
- * Claude Code tool adapter
+ * Cline tool adapter
  */
-declare class ClaudeCodeTool extends BaseCodeTool implements IChatTool, IFileEditTool, ICodeGenTool {
+declare class ClineTool extends BaseCodeTool implements IChatTool, IFileEditTool, ICodeGenTool {
     getMetadata(): ToolMetadata;
     protected getInstallCheckCommand(): string;
     protected getInstallCommand(): string;
@@ -443,40 +421,6 @@ declare class CodexTool extends BaseCodeTool implements ICodeGenTool {
     generateCode(prompt: string, outputPath?: string): Promise<ExecutionResult>;
 }
 
-/**
- * Aider adapter
- */
-
-/**
- * Aider tool adapter
- */
-declare class AiderTool extends BaseCodeTool implements IChatTool, IFileEditTool {
-    getMetadata(): ToolMetadata;
-    protected getInstallCheckCommand(): string;
-    protected getInstallCommand(): string;
-    protected getUninstallCommand(): string;
-    /**
-     * Start a chat session
-     */
-    chat(prompt: string): Promise<ExecutionResult>;
-    /**
-     * Continue a chat session
-     */
-    continueChat(message: string): Promise<ExecutionResult>;
-    /**
-     * End chat session
-     */
-    endChat(): Promise<void>;
-    /**
-     * Edit a file
-     */
-    editFile(filePath: string, instructions: string): Promise<ExecutionResult>;
-    /**
-     * Edit multiple files
-     */
-    editFiles(files: string[], instructions: string): Promise<ExecutionResult>;
-}
-
 /**
  * Continue adapter
  */
@@ -508,13 +452,13 @@ declare class ContinueTool extends BaseCodeTool implements IChatTool, ICodeGenTo
 }
 
 /**
- * Cline adapter
+ * Cursor adapter
  */
 
 /**
- * Cline tool adapter
+ * Cursor tool adapter
  */
-declare class ClineTool extends BaseCodeTool implements IChatTool, IFileEditTool, ICodeGenTool {
+declare class CursorTool extends BaseCodeTool implements IChatTool, IFileEditTool, ICodeGenTool {
     getMetadata(): ToolMetadata;
     protected getInstallCheckCommand(): string;
     protected getInstallCommand(): string;
@@ -546,1818 +490,1916 @@ declare class ClineTool extends BaseCodeTool implements IChatTool, IFileEditTool
 }
 
 /**
- * Cursor adapter
+ * Tool registry for managing code tool instances
  */
 
 /**
- * Cursor tool adapter
+ * Registry for managing code tool instances
  */
-declare class CursorTool extends BaseCodeTool implements IChatTool, IFileEditTool, ICodeGenTool {
-    getMetadata(): ToolMetadata;
-    protected getInstallCheckCommand(): string;
-    protected getInstallCommand(): string;
-    protected getUninstallCommand(): string;
+declare class ToolRegistry {
+    private static instance;
+    private tools;
+    private toolClasses;
+    private constructor();
     /**
-     * Start a chat session
+     * Get singleton instance
      */
-    chat(prompt: string): Promise<ExecutionResult>;
+    static getInstance(): ToolRegistry;
     /**
-     * Continue a chat session
+     * Register a tool class
      */
-    continueChat(message: string): Promise<ExecutionResult>;
+    registerToolClass(name: string, toolClass: new () => ICodeTool): void;
     /**
-     * End chat session
+     * Register a tool instance
      */
-    endChat(): Promise<void>;
+    registerTool(tool: ICodeTool): void;
     /**
-     * Edit a file
+     * Get a tool instance by name
      */
-    editFile(filePath: string, instructions: string): Promise<ExecutionResult>;
+    getTool(name: string): ICodeTool | undefined;
     /**
-     * Edit multiple files
+     * Get all registered tool names
      */
-    editFiles(files: string[], instructions: string): Promise<ExecutionResult>;
+    getToolNames(): string[];
     /**
-     * Generate code
+     * Get all tool instances
      */
-    generateCode(prompt: string, outputPath?: string): Promise<ExecutionResult>;
+    getAllTools(): ICodeTool[];
+    /**
+     * Check if a tool is registered
+     */
+    hasTool(name: string): boolean;
+    /**
+     * Unregister a tool
+     */
+    unregisterTool(name: string): void;
+    /**
+     * Clear all registered tools
+     */
+    clear(): void;
+    /**
+     * Get metadata for all registered tools
+     */
+    getAllMetadata(): Promise<ToolMetadata[]>;
 }
-
-declare const AI_OUTPUT_LANGUAGES: {
-    readonly 'zh-CN': {
-        readonly directive: "Always respond in Chinese-simplified";
-    };
-    readonly en: {
-        readonly directive: "Always respond in English";
-    };
-    readonly custom: {
-        readonly directive: "";
-    };
-};
-type AiOutputLanguage = keyof typeof AI_OUTPUT_LANGUAGES;
-
 /**
- * API configuration for Claude Code
+ * Convenience function to get the registry instance
  */
-interface ApiConfig {
-    url: string;
-    key: string;
-    authType?: 'auth_token' | 'api_key';
-}
+declare function getRegistry(): ToolRegistry;
 
-declare function ensureClaudeDir(): void;
-declare function backupExistingConfig(): string | null;
-declare function copyConfigFiles(onlyMd?: boolean): void;
-declare function configureApi(apiConfig: ApiConfig | null): ApiConfig | null;
-declare function mergeConfigs(sourceFile: string, targetFile: string): void;
 /**
- * Update custom model configuration using environment variables
- * @param primaryModel - Primary model name for general tasks
- * @param haikuModel - Default Haiku model (optional)
- * @param sonnetModel - Default Sonnet model (optional)
- * @param opusModel - Default Opus model (optional)
+ * Factory for creating code tool instances
  */
-declare function updateCustomModel(primaryModel?: string, haikuModel?: string, sonnetModel?: string, opusModel?: string): void;
+
 /**
- * Update the default model configuration in settings.json
- * @param model - The model type to set: opus, sonnet, sonnet[1m], default, or custom
- * Note: 'custom' model type is handled differently - it should use environment variables instead
+ * Factory for creating code tool instances
  */
-declare function updateDefaultModel(model: 'opus' | 'sonnet' | 'sonnet[1m]' | 'default' | 'custom'): void;
-/**
- * Merge settings.json intelligently
- * Preserves user's environment variables and custom configurations
- */
-declare function mergeSettingsFile(templatePath: string, targetPath: string): void;
+declare class ToolFactory {
+    private registry;
+    constructor(registry?: ToolRegistry);
+    /**
+     * Create a tool instance by name
+     */
+    createTool(name: string, config?: Partial<ToolConfig>): ICodeTool;
+    /**
+     * Create multiple tool instances
+     */
+    createTools(names: string[]): ICodeTool[];
+    /**
+     * Create all registered tools
+     */
+    createAllTools(): ICodeTool[];
+    /**
+     * Check if a tool can be created
+     */
+    canCreateTool(name: string): boolean;
+    /**
+     * Get available tool names
+     */
+    getAvailableTools(): string[];
+}
 /**
- * Get existing model configuration from settings.json
+ * Convenience function to create a tool
  */
-declare function getExistingModelConfig(): 'opus' | 'sonnet' | 'sonnet[1m]' | 'default' | 'custom' | null;
+declare function createTool(name: string, config?: Partial<ToolConfig>): ICodeTool;
+
 /**
- * Get existing API configuration from settings.json
+ * Array Utilities
+ * Array manipulation and transformation functions
  */
-declare function getExistingApiConfig(): ApiConfig | null;
-declare function applyAiLanguageDirective(aiOutputLang: AiOutputLanguage | string): void;
 /**
- * Switch to official login mode - remove all third-party API configurations
- * Removes: ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, ANTHROPIC_API_KEY from settings.json
- * Removes: primaryApiKey from ~/.claude/config.json
+ * Remove duplicates from array
  */
-declare function switchToOfficialLogin(): boolean;
+declare function unique<T>(arr: T[]): T[];
 /**
- * Prompt user for API configuration action when existing config is found
- * Returns the user's choice for how to handle existing configuration
+ * Remove duplicates by key
  */
-declare function promptApiConfigurationAction(): Promise<'modify-partial' | 'modify-all' | 'keep-existing' | null>;
-
-type config_ApiConfig = ApiConfig;
-declare const config_applyAiLanguageDirective: typeof applyAiLanguageDirective;
-declare const config_backupExistingConfig: typeof backupExistingConfig;
-declare const config_configureApi: typeof configureApi;
-declare const config_copyConfigFiles: typeof copyConfigFiles;
-declare const config_ensureClaudeDir: typeof ensureClaudeDir;
-declare const config_getExistingApiConfig: typeof getExistingApiConfig;
-declare const config_getExistingModelConfig: typeof getExistingModelConfig;
-declare const config_mergeConfigs: typeof mergeConfigs;
-declare const config_mergeSettingsFile: typeof mergeSettingsFile;
-declare const config_promptApiConfigurationAction: typeof promptApiConfigurationAction;
-declare const config_switchToOfficialLogin: typeof switchToOfficialLogin;
-declare const config_updateCustomModel: typeof updateCustomModel;
-declare const config_updateDefaultModel: typeof updateDefaultModel;
-declare namespace config {
-  export { config_applyAiLanguageDirective as applyAiLanguageDirective, config_backupExistingConfig as backupExistingConfig, config_configureApi as configureApi, config_copyConfigFiles as copyConfigFiles, config_ensureClaudeDir as ensureClaudeDir, config_getExistingApiConfig as getExistingApiConfig, config_getExistingModelConfig as getExistingModelConfig, config_mergeConfigs as mergeConfigs, config_mergeSettingsFile as mergeSettingsFile, config_promptApiConfigurationAction as promptApiConfigurationAction, config_switchToOfficialLogin as switchToOfficialLogin, config_updateCustomModel as updateCustomModel, config_updateDefaultModel as updateDefaultModel };
-  export type { config_ApiConfig as ApiConfig };
-}
-
-declare function getPlatform$1(): 'windows' | 'macos' | 'linux';
-declare function isTermux(): boolean;
-declare function getTermuxPrefix(): string;
-declare function isWindows$1(): boolean;
-interface WSLInfo {
-    isWSL: true;
-    distro: string | null;
-    version: string | null;
-}
-declare function isWSL(): boolean;
-declare function getWSLDistro(): string | null;
-declare function getWSLInfo(): WSLInfo | null;
+declare function uniqueBy<T>(arr: T[], key: keyof T | ((item: T) => any)): T[];
 /**
- * Get MCP command with platform-specific wrapper if needed
- * @param command - The base command to execute (default: 'npx')
- * @returns Command array with Windows wrapper if applicable
+ * Flatten nested array
  */
-declare function getMcpCommand(command?: string): string[];
+declare function flatten$1<T>(arr: any[], depth?: number): T[];
 /**
- * Normalize Windows paths by converting backslashes to forward slashes
- * This ensures Windows paths like "C:\Program Files\nodejs\npx.cmd" are correctly
- * written as "C:/Program Files/nodejs/npx.cmd" in TOML format, avoiding escape issues
- * Unified function used by getSystemRoot() and normalizePath() to avoid code duplication
- * @param str - The string to normalize (typically a Windows path)
- * @returns The normalized string with backslashes replaced by forward slashes
+ * Chunk array into smaller arrays
  */
-declare function normalizeTomlPath(str: string): string;
-declare function getSystemRoot(): string | null;
-declare function shouldUseSudoForGlobalInstall(): boolean;
-declare function wrapCommandWithSudo(command: string, args: string[]): {
-    command: string;
-    args: string[];
-    usedSudo: boolean;
-};
-declare function commandExists$1(command: string): Promise<boolean>;
+declare function chunk<T>(arr: T[], size: number): T[][];
 /**
- * Get possible Homebrew paths for a command on macOS
- * Handles both Apple Silicon (/opt/homebrew) and Intel (/usr/local) installations
- * Also checks npm global paths within Homebrew's node installation
- * and Homebrew cask installations in Caskroom
+ * Shuffle array randomly
  */
-declare function getHomebrewCommandPaths(command: string): Promise<string[]>;
+declare function shuffle<T>(arr: T[]): T[];
 /**
- * Find the actual path of a command, checking standard PATH and Homebrew locations
- * Returns null if command is not found
+ * Get random element from array
  */
-declare function findCommandPath(command: string): Promise<string | null>;
+declare function sample<T>(arr: T[]): T | undefined;
 /**
- * Find the real binary path of a command, bypassing shell functions/aliases
- * This is useful when a shell function wraps a command and we need the actual binary
- * Returns null if command is not found
+ * Get multiple random elements from array
  */
-declare function findRealCommandPath(command: string): Promise<string | null>;
+declare function sampleSize<T>(arr: T[], size: number): T[];
 /**
- * Get recommended install methods for a code tool based on current platform
- * Returns methods in priority order (most recommended first)
+ * Partition array into two arrays based on predicate
  */
-type CodeType = 'claude-code' | 'codex';
-type InstallMethod = 'npm' | 'homebrew' | 'curl' | 'powershell' | 'cmd' | 'npm-global' | 'native';
-declare function getRecommendedInstallMethods(codeType: CodeType): InstallMethod[];
-
-type platform_CodeType = CodeType;
-type platform_InstallMethod = InstallMethod;
-type platform_WSLInfo = WSLInfo;
-declare const platform_findCommandPath: typeof findCommandPath;
-declare const platform_findRealCommandPath: typeof findRealCommandPath;
-declare const platform_getHomebrewCommandPaths: typeof getHomebrewCommandPaths;
-declare const platform_getMcpCommand: typeof getMcpCommand;
-declare const platform_getRecommendedInstallMethods: typeof getRecommendedInstallMethods;
-declare const platform_getSystemRoot: typeof getSystemRoot;
-declare const platform_getTermuxPrefix: typeof getTermuxPrefix;
-declare const platform_getWSLDistro: typeof getWSLDistro;
-declare const platform_getWSLInfo: typeof getWSLInfo;
-declare const platform_isTermux: typeof isTermux;
-declare const platform_isWSL: typeof isWSL;
-declare const platform_normalizeTomlPath: typeof normalizeTomlPath;
-declare const platform_shouldUseSudoForGlobalInstall: typeof shouldUseSudoForGlobalInstall;
-declare const platform_wrapCommandWithSudo: typeof wrapCommandWithSudo;
-declare namespace platform {
-  export { commandExists$1 as commandExists, platform_findCommandPath as findCommandPath, platform_findRealCommandPath as findRealCommandPath, platform_getHomebrewCommandPaths as getHomebrewCommandPaths, platform_getMcpCommand as getMcpCommand, getPlatform$1 as getPlatform, platform_getRecommendedInstallMethods as getRecommendedInstallMethods, platform_getSystemRoot as getSystemRoot, platform_getTermuxPrefix as getTermuxPrefix, platform_getWSLDistro as getWSLDistro, platform_getWSLInfo as getWSLInfo, platform_isTermux as isTermux, platform_isWSL as isWSL, isWindows$1 as isWindows, platform_normalizeTomlPath as normalizeTomlPath, platform_shouldUseSudoForGlobalInstall as shouldUseSudoForGlobalInstall, platform_wrapCommandWithSudo as wrapCommandWithSudo };
-  export type { platform_CodeType as CodeType, platform_InstallMethod as InstallMethod, platform_WSLInfo as WSLInfo };
-}
-
+declare function partition<T>(arr: T[], predicate: (item: T) => boolean): [T[], T[]];
 /**
- * Command Execution Utilities
- * Provides utilities for executing shell commands
+ * Get intersection of arrays
  */
-interface CommandResult {
-    success: boolean;
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-    error?: string;
-}
-interface CommandOptions {
-    cwd?: string;
-    env?: Record<string, string>;
-    timeout?: number;
-    shell?: string | boolean;
-    encoding?: BufferEncoding;
-    maxBuffer?: number;
-}
+declare function intersection<T>(...arrays: T[][]): T[];
 /**
- * Execute a command and return the result
+ * Get union of arrays
  */
-declare function executeCommand(command: string, args?: string[], options?: CommandOptions): Promise<CommandResult>;
+declare function union<T>(...arrays: T[][]): T[];
 /**
- * Execute a command with streaming output
+ * Get difference between arrays (items in first but not in others)
  */
-declare function executeCommandStream(command: string, args?: string[], options?: CommandOptions & {
-    onStdout?: (data: string) => void;
-    onStderr?: (data: string) => void;
-}): Promise<CommandResult>;
+declare function difference<T>(arr: T[], ...others: T[][]): T[];
 /**
- * Build command string from command and arguments
+ * Zip arrays together
  */
-declare function buildCommand(command: string, args: string[]): string;
+declare function zip<T>(...arrays: T[][]): T[][];
 /**
- * Escape command argument
+ * Unzip array of arrays
  */
-declare function escapeArgument(arg: string): string;
+declare function unzip<T>(arr: T[][]): T[][];
 /**
- * Check if a command exists in PATH
+ * Group consecutive elements
  */
-declare function commandExists(command: string): Promise<boolean>;
+declare function groupConsecutive<T>(arr: T[], predicate: (a: T, b: T) => boolean): T[][];
 /**
- * Get command path
+ * Take first n elements
  */
-declare function getCommandPath(command: string): Promise<string | null>;
+declare function take<T>(arr: T[], n: number): T[];
 /**
- * Parse version from command output
+ * Take last n elements
  */
-declare function parseVersion(output: string): string | null;
+declare function takeLast<T>(arr: T[], n: number): T[];
 /**
- * Get command version
+ * Drop first n elements
  */
-declare function getCommandVersion(command: string, versionFlag?: string): Promise<string | null>;
+declare function drop<T>(arr: T[], n: number): T[];
 /**
- * Execute multiple commands in sequence
+ * Drop last n elements
  */
-declare function executeCommandSequence(commands: Array<{
-    command: string;
-    args?: string[];
-    options?: CommandOptions;
-}>): Promise<CommandResult[]>;
+declare function dropLast<T>(arr: T[], n: number): T[];
 /**
- * Execute multiple commands in parallel
+ * Take elements while predicate is true
  */
-declare function executeCommandParallel(commands: Array<{
-    command: string;
-    args?: string[];
-    options?: CommandOptions;
-}>): Promise<CommandResult[]>;
-
+declare function takeWhile<T>(arr: T[], predicate: (item: T) => boolean): T[];
 /**
- * Command Utilities
- * Command execution and management
+ * Drop elements while predicate is true
  */
-
-type index$6_CommandOptions = CommandOptions;
-type index$6_CommandResult = CommandResult;
-declare const index$6_buildCommand: typeof buildCommand;
-declare const index$6_commandExists: typeof commandExists;
-declare const index$6_escapeArgument: typeof escapeArgument;
-declare const index$6_executeCommand: typeof executeCommand;
-declare const index$6_executeCommandParallel: typeof executeCommandParallel;
-declare const index$6_executeCommandSequence: typeof executeCommandSequence;
-declare const index$6_executeCommandStream: typeof executeCommandStream;
-declare const index$6_getCommandPath: typeof getCommandPath;
-declare const index$6_getCommandVersion: typeof getCommandVersion;
-declare const index$6_parseVersion: typeof parseVersion;
-declare namespace index$6 {
-  export { index$6_buildCommand as buildCommand, index$6_commandExists as commandExists, index$6_escapeArgument as escapeArgument, index$6_executeCommand as executeCommand, index$6_executeCommandParallel as executeCommandParallel, index$6_executeCommandSequence as executeCommandSequence, index$6_executeCommandStream as executeCommandStream, index$6_getCommandPath as getCommandPath, index$6_getCommandVersion as getCommandVersion, index$6_parseVersion as parseVersion };
-  export type { index$6_CommandOptions as CommandOptions, index$6_CommandResult as CommandResult };
-}
-
+declare function dropWhile<T>(arr: T[], predicate: (item: T) => boolean): T[];
 /**
- * File System Utilities
- * Provides utilities for file system operations
+ * Find index of element
  */
+declare function findIndex<T>(arr: T[], predicate: (item: T) => boolean): number;
 /**
- * Check if a file or directory exists
+ * Find last index of element
  */
-declare function exists(filePath: string): Promise<boolean>;
+declare function findLastIndex<T>(arr: T[], predicate: (item: T) => boolean): number;
 /**
- * Check if path is a file
+ * Count occurrences of element
  */
-declare function isFile(filePath: string): Promise<boolean>;
+declare function count<T>(arr: T[], item: T): number;
 /**
- * Check if path is a directory
+ * Count elements matching predicate
  */
-declare function isDirectory(filePath: string): Promise<boolean>;
+declare function countBy<T>(arr: T[], predicate: (item: T) => boolean): number;
 /**
- * Create directory recursively
+ * Sum array of numbers
  */
-declare function ensureDir(dirPath: string): Promise<void>;
+declare function sum(arr: number[]): number;
 /**
- * Read file as string
+ * Sum by property or function
  */
-declare function readFile(filePath: string, encoding?: BufferEncoding): Promise<string>;
+declare function sumBy<T>(arr: T[], selector: keyof T | ((item: T) => number)): number;
 /**
- * Write file with content
+ * Get average of numbers
  */
-declare function writeFile(filePath: string, content: string, encoding?: BufferEncoding): Promise<void>;
+declare function average(arr: number[]): number;
 /**
- * Append content to file
+ * Get minimum value
  */
-declare function appendFile(filePath: string, content: string, encoding?: BufferEncoding): Promise<void>;
+declare function min(arr: number[]): number | undefined;
 /**
- * Read JSON file
+ * Get maximum value
  */
-declare function readJSON<T = any>(filePath: string): Promise<T>;
+declare function max(arr: number[]): number | undefined;
 /**
- * Write JSON file
+ * Get minimum by property or function
  */
-declare function writeJSON(filePath: string, data: any, pretty?: boolean): Promise<void>;
+declare function minBy<T>(arr: T[], selector: keyof T | ((item: T) => number)): T | undefined;
 /**
- * Copy file
+ * Get maximum by property or function
  */
-declare function copyFile(src: string, dest: string): Promise<void>;
+declare function maxBy<T>(arr: T[], selector: keyof T | ((item: T) => number)): T | undefined;
 /**
- * Move/rename file
+ * Sort array by property or function
  */
-declare function moveFile(src: string, dest: string): Promise<void>;
+declare function sortBy<T>(arr: T[], selector: keyof T | ((item: T) => any), order?: 'asc' | 'desc'): T[];
 /**
- * Delete file
+ * Check if array is empty
  */
-declare function deleteFile(filePath: string): Promise<void>;
+declare function isEmpty$1<T>(arr: T[]): boolean;
 /**
- * Delete directory recursively
+ * Compact array (remove falsy values)
  */
-declare function deleteDir(dirPath: string): Promise<void>;
+declare function compact$1<T>(arr: T[]): NonNullable<T>[];
 /**
- * List files in directory
+ * Range of numbers
  */
-declare function listFiles(dirPath: string, recursive?: boolean): Promise<string[]>;
+declare function range(start: number, end?: number, step?: number): number[];
 /**
- * List directories in directory
+ * Rotate array by n positions
  */
-declare function listDirs(dirPath: string): Promise<string[]>;
+declare function rotate<T>(arr: T[], n: number): T[];
 /**
- * Get file size in bytes
+ * Check if arrays are equal
  */
-declare function getFileSize(filePath: string): Promise<number>;
+declare function isEqual$1<T>(arr1: T[], arr2: T[]): boolean;
+
 /**
- * Get file modification time
+ * Array Utilities
+ * Array manipulation and transformation
  */
-declare function getModifiedTime(filePath: string): Promise<Date>;
+
+declare const index$6_average: typeof average;
+declare const index$6_chunk: typeof chunk;
+declare const index$6_count: typeof count;
+declare const index$6_countBy: typeof countBy;
+declare const index$6_difference: typeof difference;
+declare const index$6_drop: typeof drop;
+declare const index$6_dropLast: typeof dropLast;
+declare const index$6_dropWhile: typeof dropWhile;
+declare const index$6_findIndex: typeof findIndex;
+declare const index$6_findLastIndex: typeof findLastIndex;
+declare const index$6_groupConsecutive: typeof groupConsecutive;
+declare const index$6_intersection: typeof intersection;
+declare const index$6_max: typeof max;
+declare const index$6_maxBy: typeof maxBy;
+declare const index$6_min: typeof min;
+declare const index$6_minBy: typeof minBy;
+declare const index$6_partition: typeof partition;
+declare const index$6_range: typeof range;
+declare const index$6_rotate: typeof rotate;
+declare const index$6_sample: typeof sample;
+declare const index$6_sampleSize: typeof sampleSize;
+declare const index$6_shuffle: typeof shuffle;
+declare const index$6_sortBy: typeof sortBy;
+declare const index$6_sum: typeof sum;
+declare const index$6_sumBy: typeof sumBy;
+declare const index$6_take: typeof take;
+declare const index$6_takeLast: typeof takeLast;
+declare const index$6_takeWhile: typeof takeWhile;
+declare const index$6_union: typeof union;
+declare const index$6_unique: typeof unique;
+declare const index$6_uniqueBy: typeof uniqueBy;
+declare const index$6_unzip: typeof unzip;
+declare const index$6_zip: typeof zip;
+declare namespace index$6 {
+  export {
+    index$6_average as average,
+    index$6_chunk as chunk,
+    compact$1 as compact,
+    index$6_count as count,
+    index$6_countBy as countBy,
+    index$6_difference as difference,
+    index$6_drop as drop,
+    index$6_dropLast as dropLast,
+    index$6_dropWhile as dropWhile,
+    index$6_findIndex as findIndex,
+    index$6_findLastIndex as findLastIndex,
+    flatten$1 as flatten,
+    index$6_groupConsecutive as groupConsecutive,
+    index$6_intersection as intersection,
+    isEmpty$1 as isEmpty,
+    isEqual$1 as isEqual,
+    index$6_max as max,
+    index$6_maxBy as maxBy,
+    index$6_min as min,
+    index$6_minBy as minBy,
+    index$6_partition as partition,
+    index$6_range as range,
+    index$6_rotate as rotate,
+    index$6_sample as sample,
+    index$6_sampleSize as sampleSize,
+    index$6_shuffle as shuffle,
+    index$6_sortBy as sortBy,
+    index$6_sum as sum,
+    index$6_sumBy as sumBy,
+    index$6_take as take,
+    index$6_takeLast as takeLast,
+    index$6_takeWhile as takeWhile,
+    index$6_union as union,
+    index$6_unique as unique,
+    index$6_uniqueBy as uniqueBy,
+    index$6_unzip as unzip,
+    index$6_zip as zip,
+  };
+}
+
 /**
- * Get file creation time
+ * Async Utilities
+ * Asynchronous operation helpers
  */
-declare function getCreatedTime(filePath: string): Promise<Date>;
 /**
- * Check if file is readable
+ * Sleep for specified milliseconds
  */
-declare function isReadable(filePath: string): Promise<boolean>;
+declare function sleep(ms: number): Promise<void>;
 /**
- * Check if file is writable
+ * Retry async function with exponential backoff
  */
-declare function isWritable(filePath: string): Promise<boolean>;
+declare function retry<T>(fn: () => Promise<T>, options?: {
+    maxAttempts?: number;
+    delay?: number;
+    backoff?: number;
+    onRetry?: (error: Error, attempt: number) => void;
+}): Promise<T>;
 /**
- * Check if file is executable
+ * Timeout a promise
  */
-declare function isExecutable(filePath: string): Promise<boolean>;
+declare function timeout<T>(promise: Promise<T>, ms: number, errorMessage?: string): Promise<T>;
 /**
- * Find files matching pattern
+ * Debounce async function
  */
-declare function findFiles(dirPath: string, pattern: RegExp | string, recursive?: boolean): Promise<string[]>;
+declare function debounce<T extends (...args: any[]) => Promise<any>>(fn: T, delay: number): (...args: Parameters<T>) => Promise<ReturnType<T>>;
 /**
- * Get directory size (total size of all files)
+ * Throttle async function
  */
-declare function getDirSize(dirPath: string): Promise<number>;
+declare function throttle<T extends (...args: any[]) => Promise<any>>(fn: T, delay: number): (...args: Parameters<T>) => Promise<ReturnType<T>>;
 /**
- * Copy directory recursively
+ * Execute promises in parallel with concurrency limit
  */
-declare function copyDir(src: string, dest: string): Promise<void>;
+declare function parallelLimit<T>(tasks: (() => Promise<T>)[], limit: number): Promise<T[]>;
 /**
- * Empty directory (delete all contents but keep directory)
+ * Execute promises in sequence
  */
-declare function emptyDir(dirPath: string): Promise<void>;
-
+declare function sequence<T>(tasks: (() => Promise<T>)[]): Promise<T[]>;
 /**
- * File System Utilities
- * File and directory operations
+ * Execute promises with all settled (no rejection)
  */
-
-declare const index$5_appendFile: typeof appendFile;
-declare const index$5_copyDir: typeof copyDir;
-declare const index$5_copyFile: typeof copyFile;
-declare const index$5_deleteDir: typeof deleteDir;
-declare const index$5_deleteFile: typeof deleteFile;
-declare const index$5_emptyDir: typeof emptyDir;
-declare const index$5_ensureDir: typeof ensureDir;
-declare const index$5_exists: typeof exists;
-declare const index$5_findFiles: typeof findFiles;
-declare const index$5_getCreatedTime: typeof getCreatedTime;
-declare const index$5_getDirSize: typeof getDirSize;
-declare const index$5_getFileSize: typeof getFileSize;
-declare const index$5_getModifiedTime: typeof getModifiedTime;
-declare const index$5_isDirectory: typeof isDirectory;
-declare const index$5_isExecutable: typeof isExecutable;
-declare const index$5_isFile: typeof isFile;
-declare const index$5_isReadable: typeof isReadable;
-declare const index$5_isWritable: typeof isWritable;
-declare const index$5_listDirs: typeof listDirs;
-declare const index$5_listFiles: typeof listFiles;
-declare const index$5_moveFile: typeof moveFile;
-declare const index$5_readFile: typeof readFile;
-declare const index$5_readJSON: typeof readJSON;
-declare const index$5_writeFile: typeof writeFile;
-declare const index$5_writeJSON: typeof writeJSON;
-declare namespace index$5 {
-  export {
-    index$5_appendFile as appendFile,
-    index$5_copyDir as copyDir,
-    index$5_copyFile as copyFile,
-    index$5_deleteDir as deleteDir,
-    index$5_deleteFile as deleteFile,
-    index$5_emptyDir as emptyDir,
-    index$5_ensureDir as ensureDir,
-    index$5_exists as exists,
-    index$5_findFiles as findFiles,
-    index$5_getCreatedTime as getCreatedTime,
-    index$5_getDirSize as getDirSize,
-    index$5_getFileSize as getFileSize,
-    index$5_getModifiedTime as getModifiedTime,
-    index$5_isDirectory as isDirectory,
-    index$5_isExecutable as isExecutable,
-    index$5_isFile as isFile,
-    index$5_isReadable as isReadable,
-    index$5_isWritable as isWritable,
-    index$5_listDirs as listDirs,
-    index$5_listFiles as listFiles,
-    index$5_moveFile as moveFile,
-    index$5_readFile as readFile,
-    index$5_readJSON as readJSON,
-    index$5_writeFile as writeFile,
-    index$5_writeJSON as writeJSON,
-  };
-}
-
+declare function allSettled<T>(promises: Promise<T>[]): Promise<Array<{
+    status: 'fulfilled';
+    value: T;
+} | {
+    status: 'rejected';
+    reason: any;
+}>>;
 /**
- * Unified Input Validation Library
- * Provides reusable validation functions for common input types
+ * Race promises with timeout
  */
+declare function raceWithTimeout<T>(promises: Promise<T>[], ms: number): Promise<T>;
 /**
- * Validation result interface
+ * Memoize async function
  */
-interface ValidationResult$1 {
-    valid: boolean;
-    error?: string;
+declare function memoize<T extends (...args: any[]) => Promise<any>>(fn: T, options?: {
+    keyGenerator?: (...args: Parameters<T>) => string;
+    ttl?: number;
+}): T;
+/**
+ * Create a deferred promise
+ */
+interface Deferred<T> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason?: any) => void;
 }
+declare function defer<T>(): Deferred<T>;
 /**
- * Validate array access safety
+ * Wait for condition to be true
  */
-declare function validateArrayAccess<T>(array: T[] | null | undefined, index: number): ValidationResult$1;
+declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
+    timeout?: number;
+    interval?: number;
+    timeoutMessage?: string;
+}): Promise<void>;
 /**
- * Safely access array element
+ * Execute function with mutex lock
  */
-declare function safeArrayAccess<T>(array: T[] | null | undefined, index: number, defaultValue?: T): T | undefined;
+declare class Mutex {
+    private locked;
+    private queue;
+    acquire(): Promise<void>;
+    release(): void;
+    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+}
 /**
- * Validate object key access
+ * Create a semaphore for limiting concurrent operations
  */
-declare function validateObjectKeyAccess<T extends Record<string, unknown>>(obj: T | null | undefined, key: string): ValidationResult$1;
+declare class Semaphore {
+    private permits;
+    private queue;
+    constructor(permits: number);
+    acquire(): Promise<void>;
+    release(): void;
+    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+}
 /**
- * Safely access object property
+ * Batch async operations
  */
-declare function safeObjectAccess<T extends Record<string, unknown>, K extends keyof T>(obj: T | null | undefined, key: K, defaultValue?: T[K]): T[K] | undefined;
+declare function batch<T, R>(items: T[], batchSize: number, processor: (batch: T[]) => Promise<R[]>): Promise<R[]>;
 /**
- * Validate environment variable name
+ * Poll for result
  */
-declare function isValidEnvVarName(name: string): ValidationResult$1;
+declare function poll<T>(fn: () => Promise<T>, options?: {
+    interval?: number;
+    timeout?: number;
+    validate?: (result: T) => boolean;
+}): Promise<T>;
+
 /**
- * Sanitize environment variable value
+ * Async Utilities
+ * Asynchronous operation helpers
  */
-declare function sanitizeEnvValue(value: string): string;
+
+type index$5_Deferred<T> = Deferred<T>;
+type index$5_Mutex = Mutex;
+declare const index$5_Mutex: typeof Mutex;
+type index$5_Semaphore = Semaphore;
+declare const index$5_Semaphore: typeof Semaphore;
+declare const index$5_allSettled: typeof allSettled;
+declare const index$5_batch: typeof batch;
+declare const index$5_debounce: typeof debounce;
+declare const index$5_defer: typeof defer;
+declare const index$5_memoize: typeof memoize;
+declare const index$5_parallelLimit: typeof parallelLimit;
+declare const index$5_poll: typeof poll;
+declare const index$5_raceWithTimeout: typeof raceWithTimeout;
+declare const index$5_retry: typeof retry;
+declare const index$5_sequence: typeof sequence;
+declare const index$5_sleep: typeof sleep;
+declare const index$5_throttle: typeof throttle;
+declare const index$5_timeout: typeof timeout;
+declare const index$5_waitFor: typeof waitFor;
+declare namespace index$5 {
+  export { index$5_Mutex as Mutex, index$5_Semaphore as Semaphore, index$5_allSettled as allSettled, index$5_batch as batch, index$5_debounce as debounce, index$5_defer as defer, index$5_memoize as memoize, index$5_parallelLimit as parallelLimit, index$5_poll as poll, index$5_raceWithTimeout as raceWithTimeout, index$5_retry as retry, index$5_sequence as sequence, index$5_sleep as sleep, index$5_throttle as throttle, index$5_timeout as timeout, index$5_waitFor as waitFor };
+  export type { index$5_Deferred as Deferred };
+}
+
 /**
- * Validate URL format
+ * Command Execution Utilities
+ * Provides utilities for executing shell commands
  */
-declare function isValidUrl(url: string): ValidationResult$1;
+interface CommandResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    error?: string;
+}
+interface CommandOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    shell?: string | boolean;
+    encoding?: BufferEncoding;
+    maxBuffer?: number;
+}
 /**
- * Validate file path safety (no directory traversal)
+ * Execute a command and return the result
  */
-declare function isValidFilePath(path: string): ValidationResult$1;
+declare function executeCommand(command: string, args?: string[], options?: CommandOptions): Promise<CommandResult>;
 /**
- * Validate path entry (filename or directory name)
+ * Execute a command with streaming output
  */
-declare function isValidPathEntry(entry: string): ValidationResult$1;
+declare function executeCommandStream(command: string, args?: string[], options?: CommandOptions & {
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+}): Promise<CommandResult>;
 /**
- * Validate user input string
+ * Build command string from command and arguments
  */
-declare function validateUserInput(input: string, options?: {
-    minLength?: number;
-    maxLength?: number;
-    pattern?: RegExp;
-    allowedChars?: string;
-}): ValidationResult$1;
+declare function buildCommand(command: string, args: string[]): string;
 /**
- * Sanitize user input
+ * Escape command argument
  */
-declare function sanitizeUserInput(input: string, maxLength?: number): string;
+declare function escapeArgument(arg: string): string;
 /**
- * Validate API key format
+ * Check if a command exists in PATH
  */
-declare function isValidApiKey(apiKey: string): ValidationResult$1;
+declare function commandExists$1(command: string): Promise<boolean>;
 /**
- * Format API key for display (mask sensitive parts)
+ * Get command path
  */
-declare function formatApiKeyDisplay(apiKey: string | null | undefined): string;
+declare function getCommandPath(command: string): Promise<string | null>;
 /**
- * Validate configuration object structure
+ * Parse version from command output
  */
-declare function validateConfigStructure(config: unknown, schema: Record<string, 'string' | 'number' | 'boolean' | 'object' | 'array'>): ValidationResult$1;
+declare function parseVersion(output: string): string | null;
 /**
- * Validate array of items
+ * Get command version
  */
-declare function validateArray(array: unknown, validator: (item: unknown) => ValidationResult$1): ValidationResult$1;
+declare function getCommandVersion(command: string, versionFlag?: string): Promise<string | null>;
 /**
- * Validate enum value
+ * Execute multiple commands in sequence
  */
-declare function isValidEnumValue<T extends string | number>(value: unknown, allowedValues: T[]): ValidationResult$1;
+declare function executeCommandSequence(commands: Array<{
+    command: string;
+    args?: string[];
+    options?: CommandOptions;
+}>): Promise<CommandResult[]>;
 /**
- * Validate port number
+ * Execute multiple commands in parallel
  */
-declare function isValidPort(port: unknown): ValidationResult$1;
+declare function executeCommandParallel(commands: Array<{
+    command: string;
+    args?: string[];
+    options?: CommandOptions;
+}>): Promise<CommandResult[]>;
+
 /**
- * Validate hostname
+ * Command Utilities
+ * Command execution and management
  */
-declare function isValidHostname(hostname: string): ValidationResult$1;
 
-declare const validation_formatApiKeyDisplay: typeof formatApiKeyDisplay;
-declare const validation_isValidApiKey: typeof isValidApiKey;
-declare const validation_isValidEnumValue: typeof isValidEnumValue;
-declare const validation_isValidEnvVarName: typeof isValidEnvVarName;
-declare const validation_isValidFilePath: typeof isValidFilePath;
-declare const validation_isValidHostname: typeof isValidHostname;
-declare const validation_isValidPathEntry: typeof isValidPathEntry;
-declare const validation_isValidPort: typeof isValidPort;
-declare const validation_isValidUrl: typeof isValidUrl;
-declare const validation_safeArrayAccess: typeof safeArrayAccess;
-declare const validation_safeObjectAccess: typeof safeObjectAccess;
-declare const validation_sanitizeEnvValue: typeof sanitizeEnvValue;
-declare const validation_sanitizeUserInput: typeof sanitizeUserInput;
-declare const validation_validateArray: typeof validateArray;
-declare const validation_validateArrayAccess: typeof validateArrayAccess;
-declare const validation_validateConfigStructure: typeof validateConfigStructure;
-declare const validation_validateObjectKeyAccess: typeof validateObjectKeyAccess;
-declare const validation_validateUserInput: typeof validateUserInput;
-declare namespace validation {
-  export { validation_formatApiKeyDisplay as formatApiKeyDisplay, validation_isValidApiKey as isValidApiKey, validation_isValidEnumValue as isValidEnumValue, validation_isValidEnvVarName as isValidEnvVarName, validation_isValidFilePath as isValidFilePath, validation_isValidHostname as isValidHostname, validation_isValidPathEntry as isValidPathEntry, validation_isValidPort as isValidPort, validation_isValidUrl as isValidUrl, validation_safeArrayAccess as safeArrayAccess, validation_safeObjectAccess as safeObjectAccess, validation_sanitizeEnvValue as sanitizeEnvValue, validation_sanitizeUserInput as sanitizeUserInput, validation_validateArray as validateArray, validation_validateArrayAccess as validateArrayAccess, validation_validateConfigStructure as validateConfigStructure, validation_validateObjectKeyAccess as validateObjectKeyAccess, validation_validateUserInput as validateUserInput };
-  export type { ValidationResult$1 as ValidationResult };
+type index$4_CommandOptions = CommandOptions;
+type index$4_CommandResult = CommandResult;
+declare const index$4_buildCommand: typeof buildCommand;
+declare const index$4_escapeArgument: typeof escapeArgument;
+declare const index$4_executeCommand: typeof executeCommand;
+declare const index$4_executeCommandParallel: typeof executeCommandParallel;
+declare const index$4_executeCommandSequence: typeof executeCommandSequence;
+declare const index$4_executeCommandStream: typeof executeCommandStream;
+declare const index$4_getCommandPath: typeof getCommandPath;
+declare const index$4_getCommandVersion: typeof getCommandVersion;
+declare const index$4_parseVersion: typeof parseVersion;
+declare namespace index$4 {
+  export { index$4_buildCommand as buildCommand, commandExists$1 as commandExists, index$4_escapeArgument as escapeArgument, index$4_executeCommand as executeCommand, index$4_executeCommandParallel as executeCommandParallel, index$4_executeCommandSequence as executeCommandSequence, index$4_executeCommandStream as executeCommandStream, index$4_getCommandPath as getCommandPath, index$4_getCommandVersion as getCommandVersion, index$4_parseVersion as parseVersion };
+  export type { index$4_CommandOptions as CommandOptions, index$4_CommandResult as CommandResult };
 }
 
+declare const AI_OUTPUT_LANGUAGES: {
+    readonly 'zh-CN': {
+        readonly directive: "Always respond in Chinese-simplified";
+    };
+    readonly en: {
+        readonly directive: "Always respond in English";
+    };
+    readonly custom: {
+        readonly directive: "";
+    };
+};
+type AiOutputLanguage = keyof typeof AI_OUTPUT_LANGUAGES;
+
 /**
- * String Utilities
- * String manipulation and formatting functions
- */
-/**
- * Capitalize first letter of string
- */
-declare function capitalize(str: string): string;
-/**
- * Convert string to camelCase
- */
-declare function camelCase(str: string): string;
-/**
- * Convert string to PascalCase
+ * API configuration for Claude Code
  */
-declare function pascalCase(str: string): string;
+interface ApiConfig {
+    url: string;
+    key: string;
+    authType?: 'auth_token' | 'api_key';
+}
+
+declare function ensureClaudeDir(): void;
+declare function backupExistingConfig(): string | null;
+declare function copyConfigFiles(onlyMd?: boolean): void;
+declare function configureApi(apiConfig: ApiConfig | null): ApiConfig | null;
+declare function mergeConfigs(sourceFile: string, targetFile: string): void;
 /**
- * Convert string to snake_case
+ * Update custom model configuration using environment variables
+ * @param primaryModel - Primary model name for general tasks
+ * @param haikuModel - Default Haiku model (optional)
+ * @param sonnetModel - Default Sonnet model (optional)
+ * @param opusModel - Default Opus model (optional)
  */
-declare function snakeCase(str: string): string;
+declare function updateCustomModel(primaryModel?: string, haikuModel?: string, sonnetModel?: string, opusModel?: string): void;
 /**
- * Convert string to kebab-case
+ * Update the default model configuration in settings.json
+ * @param model - The model type to set: opus, sonnet, sonnet[1m], default, or custom
+ * Note: 'custom' model type is handled differently - it should use environment variables instead
  */
-declare function kebabCase(str: string): string;
+declare function updateDefaultModel(model: 'opus' | 'sonnet' | 'sonnet[1m]' | 'default' | 'custom'): void;
 /**
- * Convert string to CONSTANT_CASE
+ * Merge settings.json intelligently
+ * Preserves user's environment variables and custom configurations
  */
-declare function constantCase(str: string): string;
+declare function mergeSettingsFile(templatePath: string, targetPath: string): void;
 /**
- * Truncate string to specified length
+ * Get existing model configuration from settings.json
  */
-declare function truncate(str: string, length: number, suffix?: string): string;
+declare function getExistingModelConfig(): 'opus' | 'sonnet' | 'sonnet[1m]' | 'default' | 'custom' | null;
 /**
- * Pad string to specified length
+ * Get existing API configuration from settings.json
  */
-declare function pad(str: string, length: number, char?: string, direction?: 'left' | 'right' | 'both'): string;
+declare function getExistingApiConfig(): ApiConfig | null;
+declare function applyAiLanguageDirective(aiOutputLang: AiOutputLanguage | string): void;
 /**
- * Remove whitespace from both ends
+ * Switch to official login mode - remove all third-party API configurations
+ * Removes: ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, ANTHROPIC_API_KEY from settings.json
+ * Removes: primaryApiKey from ~/.claude/config.json
  */
-declare function trim(str: string): string;
+declare function switchToOfficialLogin(): boolean;
 /**
- * Remove whitespace from start
+ * Prompt user for API configuration action when existing config is found
+ * Returns the user's choice for how to handle existing configuration
  */
-declare function trimStart(str: string): string;
+declare function promptApiConfigurationAction(): Promise<'modify-partial' | 'modify-all' | 'keep-existing' | null>;
+
+type config_ApiConfig = ApiConfig;
+declare const config_applyAiLanguageDirective: typeof applyAiLanguageDirective;
+declare const config_backupExistingConfig: typeof backupExistingConfig;
+declare const config_configureApi: typeof configureApi;
+declare const config_copyConfigFiles: typeof copyConfigFiles;
+declare const config_ensureClaudeDir: typeof ensureClaudeDir;
+declare const config_getExistingApiConfig: typeof getExistingApiConfig;
+declare const config_getExistingModelConfig: typeof getExistingModelConfig;
+declare const config_mergeConfigs: typeof mergeConfigs;
+declare const config_mergeSettingsFile: typeof mergeSettingsFile;
+declare const config_promptApiConfigurationAction: typeof promptApiConfigurationAction;
+declare const config_switchToOfficialLogin: typeof switchToOfficialLogin;
+declare const config_updateCustomModel: typeof updateCustomModel;
+declare const config_updateDefaultModel: typeof updateDefaultModel;
+declare namespace config {
+  export { config_applyAiLanguageDirective as applyAiLanguageDirective, config_backupExistingConfig as backupExistingConfig, config_configureApi as configureApi, config_copyConfigFiles as copyConfigFiles, config_ensureClaudeDir as ensureClaudeDir, config_getExistingApiConfig as getExistingApiConfig, config_getExistingModelConfig as getExistingModelConfig, config_mergeConfigs as mergeConfigs, config_mergeSettingsFile as mergeSettingsFile, config_promptApiConfigurationAction as promptApiConfigurationAction, config_switchToOfficialLogin as switchToOfficialLogin, config_updateCustomModel as updateCustomModel, config_updateDefaultModel as updateDefaultModel };
+  export type { config_ApiConfig as ApiConfig };
+}
+
 /**
- * Remove whitespace from end
+ * Configuration Manager
+ * Provides utilities for loading, saving, and managing configuration files
  */
-declare function trimEnd(str: string): string;
+interface ConfigOptions {
+    configDir?: string;
+    fileName?: string;
+    createIfMissing?: boolean;
+    validate?: (config: any) => boolean;
+}
 /**
- * Split string by delimiter
+ * Configuration Manager class
+ * Handles configuration file operations with validation and error handling
  */
-declare function split(str: string, delimiter: string | RegExp): string[];
+declare class ConfigManager<T = any> {
+    private readonly namespace;
+    private configPath;
+    private options;
+    private cache?;
+    constructor(namespace: string, options?: ConfigOptions);
+    /**
+     * Get the default configuration directory
+     */
+    private getDefaultConfigDir;
+    /**
+     * Load configuration from file
+     */
+    load(): Promise<T | null>;
+    /**
+     * Save configuration to file
+     */
+    save(config: T): Promise<void>;
+    /**
+     * Update configuration (merge with existing)
+     */
+    update(updates: Partial<T>): Promise<T>;
+    /**
+     * Delete configuration file
+     */
+    delete(): Promise<void>;
+    /**
+     * Check if configuration file exists
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Get configuration path
+     */
+    getPath(): string;
+    /**
+     * Get cached configuration (without file I/O)
+     */
+    getCached(): T | undefined;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+}
 /**
- * Join array of strings
+ * Create a configuration manager instance
  */
-declare function join(arr: string[], separator?: string): string;
+declare function createConfigManager<T = any>(namespace: string, options?: ConfigOptions): ConfigManager<T>;
+
 /**
- * Replace all occurrences of search with replacement
+ * Configuration Validator
+ * Provides utilities for validating configuration objects
  */
-declare function replaceAll(str: string, search: string | RegExp, replacement: string): string;
+interface ValidationRule<T = any> {
+    field: keyof T;
+    required?: boolean;
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    validator?: (value: any) => boolean;
+    message?: string;
+}
+interface ValidationError$1 {
+    field: string;
+    message: string;
+}
+interface ValidationResult$1 {
+    valid: boolean;
+    errors: ValidationError$1[];
+}
 /**
- * Check if string starts with prefix
+ * Configuration Validator class
  */
-declare function startsWith(str: string, prefix: string): boolean;
+declare class ConfigValidator<T = any> {
+    private rules;
+    constructor(rules: ValidationRule<T>[]);
+    /**
+     * Validate a configuration object
+     */
+    validate(config: Partial<T>): ValidationResult$1;
+    /**
+     * Validate and throw on error
+     */
+    validateOrThrow(config: Partial<T>): void;
+}
 /**
- * Check if string ends with suffix
+ * Create a configuration validator
  */
-declare function endsWith(str: string, suffix: string): boolean;
+declare function createValidator<T = any>(rules: ValidationRule<T>[]): ConfigValidator<T>;
 /**
- * Check if string contains substring
+ * Common validation functions
  */
-declare function contains(str: string, substring: string): boolean;
+declare const validators: {
+    /**
+     * Validate string is not empty
+     */
+    notEmpty: (value: string) => boolean;
+    /**
+     * Validate string matches pattern
+     */
+    pattern: (regex: RegExp) => (value: string) => boolean;
+    /**
+     * Validate number is in range
+     */
+    range: (min: number, max: number) => (value: number) => boolean;
+    /**
+     * Validate string length
+     */
+    length: (min: number, max?: number) => (value: string) => boolean;
+    /**
+     * Validate value is one of allowed values
+     */
+    oneOf: <T>(allowed: T[]) => (value: T) => boolean;
+    /**
+     * Validate email format
+     */
+    email: (value: string) => boolean;
+    /**
+     * Validate URL format
+     */
+    url: (value: string) => boolean;
+    /**
+     * Validate object has required keys
+     */
+    hasKeys: (keys: string[]) => (value: any) => boolean;
+    /**
+     * Validate array is not empty
+     */
+    notEmptyArray: (value: any[]) => boolean;
+};
+
 /**
- * Count occurrences of substring
+ * Error Utilities
+ * Error handling and custom error classes
  */
-declare function countOccurrences(str: string, substring: string): number;
 /**
- * Reverse string
+ * Base custom error class
  */
-declare function reverse(str: string): string;
+declare class BaseError extends Error {
+    readonly code?: string | undefined;
+    readonly statusCode?: number | undefined;
+    readonly details?: any | undefined;
+    constructor(message: string, code?: string | undefined, statusCode?: number | undefined, details?: any | undefined);
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string | undefined;
+        statusCode: number | undefined;
+        details: any;
+        stack: string | undefined;
+    };
+}
 /**
- * Remove all whitespace
+ * Validation error
  */
-declare function removeWhitespace(str: string): string;
+declare class ValidationError extends BaseError {
+    constructor(message: string, details?: any);
+}
 /**
- * Normalize whitespace (replace multiple spaces with single space)
+ * Not found error
  */
-declare function normalizeWhitespace(str: string): string;
+declare class NotFoundError extends BaseError {
+    constructor(message: string, details?: any);
+}
 /**
- * Extract words from string
+ * Unauthorized error
  */
-declare function words(str: string): string[];
+declare class UnauthorizedError extends BaseError {
+    constructor(message: string, details?: any);
+}
 /**
- * Count words in string
+ * Forbidden error
  */
-declare function wordCount(str: string): number;
+declare class ForbiddenError extends BaseError {
+    constructor(message: string, details?: any);
+}
 /**
- * Convert string to title case
+ * Conflict error
  */
-declare function titleCase(str: string): string;
+declare class ConflictError extends BaseError {
+    constructor(message: string, details?: any);
+}
 /**
- * Convert string to sentence case
+ * Timeout error
  */
-declare function sentenceCase(str: string): string;
+declare class TimeoutError extends BaseError {
+    constructor(message: string, details?: any);
+}
 /**
- * Escape HTML special characters
+ * Internal error
  */
-declare function escapeHTML(str: string): string;
+declare class InternalError extends BaseError {
+    constructor(message: string, details?: any);
+}
 /**
- * Unescape HTML special characters
+ * Configuration error
  */
-declare function unescapeHTML(str: string): string;
+declare class ConfigurationError extends BaseError {
+    constructor(message: string, details?: any);
+}
 /**
- * Escape regular expression special characters
+ * Network error
  */
-declare function escapeRegExp(str: string): string;
+declare class NetworkError extends BaseError {
+    constructor(message: string, details?: any);
+}
 /**
- * Generate random string
+ * Check if error is of specific type
  */
-declare function randomString(length: number, charset?: string): string;
+declare function isErrorType<T extends Error>(error: unknown, errorClass: new (...args: any[]) => T): error is T;
 /**
- * Generate UUID v4
+ * Get error message safely
  */
-declare function uuid(): string;
+declare function getErrorMessage(error: unknown): string;
 /**
- * Slugify string (URL-friendly)
+ * Get error stack safely
  */
-declare function slugify(str: string): string;
+declare function getErrorStack(error: unknown): string | undefined;
 /**
- * Extract numbers from string
+ * Format error for logging
  */
-declare function extractNumbers(str: string): number[];
+declare function formatError(error: unknown): {
+    message: string;
+    name?: string;
+    code?: string;
+    statusCode?: number;
+    stack?: string;
+    details?: any;
+};
 /**
- * Format template string with values
+ * Wrap error with additional context
  */
-declare function template(str: string, values: Record<string, any>): string;
+declare function wrapError(error: unknown, message: string, code?: string): BaseError;
 /**
- * Repeat string n times
+ * Try-catch wrapper that returns result or error
  */
-declare function repeat(str: string, count: number): string;
+declare function tryCatch<T>(fn: () => T): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: Error;
+};
 /**
- * Check if string is empty or only whitespace
+ * Async try-catch wrapper
  */
-declare function isBlank(str: string): boolean;
+declare function tryCatchAsync<T>(fn: () => Promise<T>): Promise<{
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: Error;
+}>;
 /**
- * Ensure string ends with suffix
+ * Assert condition or throw error
  */
-declare function ensureSuffix(str: string, suffix: string): string;
+declare function assert$1(condition: boolean, message: string, ErrorClass?: new (message: string) => Error): asserts condition;
 /**
- * Ensure string starts with prefix
+ * Create error handler
  */
-declare function ensurePrefix(str: string, prefix: string): string;
+declare function createErrorHandler(handlers: Record<string, (error: Error) => void>, defaultHandler?: (error: Error) => void): (error: unknown) => void;
 /**
- * Remove prefix from string
+ * Aggregate multiple errors
  */
-declare function removePrefix(str: string, prefix: string): string;
+declare class AggregateError extends BaseError {
+    readonly errors: Error[];
+    constructor(errors: Error[], message?: string);
+    static fromErrors(errors: Error[]): AggregateError;
+}
 /**
- * Remove suffix from string
+ * Retry with error handling
  */
-declare function removeSuffix(str: string, suffix: string): string;
+declare function retryWithErrorHandling<T>(fn: () => Promise<T>, options?: {
+    maxAttempts?: number;
+    delay?: number;
+    shouldRetry?: (error: Error) => boolean;
+    onError?: (error: Error, attempt: number) => void;
+}): Promise<T>;
 
 /**
- * String Utilities
- * String manipulation and formatting
+ * Error Utilities
+ * Error handling and custom error classes
  */
 
-declare const index$4_camelCase: typeof camelCase;
-declare const index$4_capitalize: typeof capitalize;
-declare const index$4_constantCase: typeof constantCase;
-declare const index$4_contains: typeof contains;
-declare const index$4_countOccurrences: typeof countOccurrences;
-declare const index$4_endsWith: typeof endsWith;
-declare const index$4_ensurePrefix: typeof ensurePrefix;
-declare const index$4_ensureSuffix: typeof ensureSuffix;
-declare const index$4_escapeHTML: typeof escapeHTML;
-declare const index$4_escapeRegExp: typeof escapeRegExp;
-declare const index$4_extractNumbers: typeof extractNumbers;
-declare const index$4_isBlank: typeof isBlank;
-declare const index$4_join: typeof join;
-declare const index$4_kebabCase: typeof kebabCase;
-declare const index$4_normalizeWhitespace: typeof normalizeWhitespace;
-declare const index$4_pad: typeof pad;
-declare const index$4_pascalCase: typeof pascalCase;
-declare const index$4_randomString: typeof randomString;
-declare const index$4_removePrefix: typeof removePrefix;
-declare const index$4_removeSuffix: typeof removeSuffix;
-declare const index$4_removeWhitespace: typeof removeWhitespace;
-declare const index$4_repeat: typeof repeat;
-declare const index$4_replaceAll: typeof replaceAll;
-declare const index$4_reverse: typeof reverse;
-declare const index$4_sentenceCase: typeof sentenceCase;
-declare const index$4_slugify: typeof slugify;
-declare const index$4_snakeCase: typeof snakeCase;
-declare const index$4_split: typeof split;
-declare const index$4_startsWith: typeof startsWith;
-declare const index$4_template: typeof template;
-declare const index$4_titleCase: typeof titleCase;
-declare const index$4_trim: typeof trim;
-declare const index$4_trimEnd: typeof trimEnd;
-declare const index$4_trimStart: typeof trimStart;
-declare const index$4_truncate: typeof truncate;
-declare const index$4_unescapeHTML: typeof unescapeHTML;
-declare const index$4_uuid: typeof uuid;
-declare const index$4_wordCount: typeof wordCount;
-declare const index$4_words: typeof words;
-declare namespace index$4 {
+type index$3_AggregateError = AggregateError;
+declare const index$3_AggregateError: typeof AggregateError;
+type index$3_BaseError = BaseError;
+declare const index$3_BaseError: typeof BaseError;
+type index$3_ConfigurationError = ConfigurationError;
+declare const index$3_ConfigurationError: typeof ConfigurationError;
+type index$3_ConflictError = ConflictError;
+declare const index$3_ConflictError: typeof ConflictError;
+type index$3_ForbiddenError = ForbiddenError;
+declare const index$3_ForbiddenError: typeof ForbiddenError;
+type index$3_InternalError = InternalError;
+declare const index$3_InternalError: typeof InternalError;
+type index$3_NetworkError = NetworkError;
+declare const index$3_NetworkError: typeof NetworkError;
+type index$3_NotFoundError = NotFoundError;
+declare const index$3_NotFoundError: typeof NotFoundError;
+type index$3_TimeoutError = TimeoutError;
+declare const index$3_TimeoutError: typeof TimeoutError;
+type index$3_UnauthorizedError = UnauthorizedError;
+declare const index$3_UnauthorizedError: typeof UnauthorizedError;
+type index$3_ValidationError = ValidationError;
+declare const index$3_ValidationError: typeof ValidationError;
+declare const index$3_createErrorHandler: typeof createErrorHandler;
+declare const index$3_formatError: typeof formatError;
+declare const index$3_getErrorMessage: typeof getErrorMessage;
+declare const index$3_getErrorStack: typeof getErrorStack;
+declare const index$3_isErrorType: typeof isErrorType;
+declare const index$3_retryWithErrorHandling: typeof retryWithErrorHandling;
+declare const index$3_tryCatch: typeof tryCatch;
+declare const index$3_tryCatchAsync: typeof tryCatchAsync;
+declare const index$3_wrapError: typeof wrapError;
+declare namespace index$3 {
   export {
-    index$4_camelCase as camelCase,
-    index$4_capitalize as capitalize,
-    index$4_constantCase as constantCase,
-    index$4_contains as contains,
-    index$4_countOccurrences as countOccurrences,
-    index$4_endsWith as endsWith,
-    index$4_ensurePrefix as ensurePrefix,
-    index$4_ensureSuffix as ensureSuffix,
-    index$4_escapeHTML as escapeHTML,
-    index$4_escapeRegExp as escapeRegExp,
-    index$4_extractNumbers as extractNumbers,
-    index$4_isBlank as isBlank,
-    index$4_join as join,
-    index$4_kebabCase as kebabCase,
-    index$4_normalizeWhitespace as normalizeWhitespace,
-    index$4_pad as pad,
-    index$4_pascalCase as pascalCase,
-    index$4_randomString as randomString,
-    index$4_removePrefix as removePrefix,
-    index$4_removeSuffix as removeSuffix,
-    index$4_removeWhitespace as removeWhitespace,
-    index$4_repeat as repeat,
-    index$4_replaceAll as replaceAll,
-    index$4_reverse as reverse,
-    index$4_sentenceCase as sentenceCase,
-    index$4_slugify as slugify,
-    index$4_snakeCase as snakeCase,
-    index$4_split as split,
-    index$4_startsWith as startsWith,
-    index$4_template as template,
-    index$4_titleCase as titleCase,
-    index$4_trim as trim,
-    index$4_trimEnd as trimEnd,
-    index$4_trimStart as trimStart,
-    index$4_truncate as truncate,
-    index$4_unescapeHTML as unescapeHTML,
-    index$4_uuid as uuid,
-    index$4_wordCount as wordCount,
-    index$4_words as words,
+    index$3_AggregateError as AggregateError,
+    index$3_BaseError as BaseError,
+    index$3_ConfigurationError as ConfigurationError,
+    index$3_ConflictError as ConflictError,
+    index$3_ForbiddenError as ForbiddenError,
+    index$3_InternalError as InternalError,
+    index$3_NetworkError as NetworkError,
+    index$3_NotFoundError as NotFoundError,
+    index$3_TimeoutError as TimeoutError,
+    index$3_UnauthorizedError as UnauthorizedError,
+    index$3_ValidationError as ValidationError,
+    assert$1 as assert,
+    index$3_createErrorHandler as createErrorHandler,
+    index$3_formatError as formatError,
+    index$3_getErrorMessage as getErrorMessage,
+    index$3_getErrorStack as getErrorStack,
+    index$3_isErrorType as isErrorType,
+    index$3_retryWithErrorHandling as retryWithErrorHandling,
+    index$3_tryCatch as tryCatch,
+    index$3_tryCatchAsync as tryCatchAsync,
+    index$3_wrapError as wrapError,
   };
 }
 
 /**
- * Object Utilities
- * Object manipulation and transformation functions
+ * File System Utilities
+ * Provides utilities for file system operations
+ */
+/**
+ * Check if a file or directory exists
  */
+declare function exists(filePath: string): Promise<boolean>;
 /**
- * Deep clone an object
+ * Check if path is a file
  */
-declare function deepClone<T>(obj: T): T;
+declare function isFile(filePath: string): Promise<boolean>;
 /**
- * Deep merge two objects
+ * Check if path is a directory
  */
-declare function deepMerge<T extends object>(target: T, source: Partial<T>): T;
+declare function isDirectory(filePath: string): Promise<boolean>;
 /**
- * Get nested property value using dot notation
+ * Create directory recursively
  */
-declare function get<T = any>(obj: any, path: string, defaultValue?: T): T | undefined;
+declare function ensureDir(dirPath: string): Promise<void>;
 /**
- * Set nested property value using dot notation
+ * Read file as string
  */
-declare function set(obj: any, path: string, value: any): void;
+declare function readFile(filePath: string, encoding?: BufferEncoding): Promise<string>;
 /**
- * Check if object has nested property using dot notation
+ * Write file with content
  */
-declare function has(obj: any, path: string): boolean;
+declare function writeFile(filePath: string, content: string, encoding?: BufferEncoding): Promise<void>;
 /**
- * Delete nested property using dot notation
+ * Append content to file
  */
-declare function unset(obj: any, path: string): boolean;
+declare function appendFile(filePath: string, content: string, encoding?: BufferEncoding): Promise<void>;
 /**
- * Get all keys from object (including nested)
+ * Read JSON file
  */
-declare function keys(obj: any, prefix?: string): string[];
+declare function readJSON<T = any>(filePath: string): Promise<T>;
 /**
- * Get all values from object
+ * Write JSON file
  */
-declare function values<T = any>(obj: Record<string, T>): T[];
+declare function writeJSON(filePath: string, data: any, pretty?: boolean): Promise<void>;
 /**
- * Get all entries from object
+ * Copy file
  */
-declare function entries<T = any>(obj: Record<string, T>): [string, T][];
+declare function copyFile(src: string, dest: string): Promise<void>;
 /**
- * Pick specific keys from object
+ * Move/rename file
  */
-declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+declare function moveFile(src: string, dest: string): Promise<void>;
 /**
- * Omit specific keys from object
+ * Delete file
  */
-declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+declare function deleteFile(filePath: string): Promise<void>;
 /**
- * Filter object by predicate
+ * Delete directory recursively
  */
-declare function filter<T>(obj: Record<string, T>, predicate: (value: T, key: string) => boolean): Record<string, T>;
+declare function deleteDir(dirPath: string): Promise<void>;
 /**
- * Map object values
+ * List files in directory
  */
-declare function map<T, U>(obj: Record<string, T>, mapper: (value: T, key: string) => U): Record<string, U>;
+declare function listFiles(dirPath: string, recursive?: boolean): Promise<string[]>;
 /**
- * Check if object is empty
+ * List directories in directory
  */
-declare function isEmpty$1(obj: object): boolean;
+declare function listDirs(dirPath: string): Promise<string[]>;
 /**
- * Flatten nested object
+ * Get file size in bytes
  */
-declare function flatten$1(obj: any, prefix?: string, separator?: string): Record<string, any>;
+declare function getFileSize(filePath: string): Promise<number>;
 /**
- * Unflatten object (reverse of flatten)
+ * Get file modification time
  */
-declare function unflatten(obj: Record<string, any>, separator?: string): any;
+declare function getModifiedTime(filePath: string): Promise<Date>;
 /**
- * Invert object (swap keys and values)
+ * Get file creation time
  */
-declare function invert<T extends string | number>(obj: Record<string, T>): Record<T, string>;
+declare function getCreatedTime(filePath: string): Promise<Date>;
 /**
- * Group array of objects by key
+ * Check if file is readable
  */
-declare function groupBy<T>(arr: T[], key: keyof T | ((item: T) => string)): Record<string, T[]>;
+declare function isReadable(filePath: string): Promise<boolean>;
 /**
- * Convert array to object using key selector
+ * Check if file is writable
  */
-declare function keyBy<T>(arr: T[], key: keyof T | ((item: T) => string)): Record<string, T>;
+declare function isWritable(filePath: string): Promise<boolean>;
 /**
- * Check if two objects are deeply equal
+ * Check if file is executable
  */
-declare function isEqual$1(obj1: any, obj2: any): boolean;
+declare function isExecutable(filePath: string): Promise<boolean>;
 /**
- * Remove null and undefined values from object
+ * Find files matching pattern
  */
-declare function compact$1<T extends object>(obj: T): Partial<T>;
+declare function findFiles(dirPath: string, pattern: RegExp | string, recursive?: boolean): Promise<string[]>;
 /**
- * Freeze object deeply (immutable)
+ * Get directory size (total size of all files)
  */
-declare function deepFreeze<T>(obj: T): Readonly<T>;
+declare function getDirSize(dirPath: string): Promise<number>;
 /**
- * Merge multiple objects
+ * Copy directory recursively
  */
-declare function merge<T extends object>(...objects: Partial<T>[]): T;
+declare function copyDir(src: string, dest: string): Promise<void>;
 /**
- * Get object size (number of keys)
+ * Empty directory (delete all contents but keep directory)
  */
-declare function size(obj: object): number;
+declare function emptyDir(dirPath: string): Promise<void>;
 
 /**
- * Object Utilities
- * Object manipulation and transformation
+ * File System Utilities
+ * File and directory operations
  */
 
-declare const index$3_deepClone: typeof deepClone;
-declare const index$3_deepFreeze: typeof deepFreeze;
-declare const index$3_deepMerge: typeof deepMerge;
-declare const index$3_entries: typeof entries;
-declare const index$3_filter: typeof filter;
-declare const index$3_get: typeof get;
-declare const index$3_groupBy: typeof groupBy;
-declare const index$3_has: typeof has;
-declare const index$3_invert: typeof invert;
-declare const index$3_keyBy: typeof keyBy;
-declare const index$3_keys: typeof keys;
-declare const index$3_map: typeof map;
-declare const index$3_merge: typeof merge;
-declare const index$3_omit: typeof omit;
-declare const index$3_pick: typeof pick;
-declare const index$3_set: typeof set;
-declare const index$3_size: typeof size;
-declare const index$3_unflatten: typeof unflatten;
-declare const index$3_unset: typeof unset;
-declare const index$3_values: typeof values;
-declare namespace index$3 {
+declare const index$2_appendFile: typeof appendFile;
+declare const index$2_copyDir: typeof copyDir;
+declare const index$2_copyFile: typeof copyFile;
+declare const index$2_deleteDir: typeof deleteDir;
+declare const index$2_deleteFile: typeof deleteFile;
+declare const index$2_emptyDir: typeof emptyDir;
+declare const index$2_ensureDir: typeof ensureDir;
+declare const index$2_exists: typeof exists;
+declare const index$2_findFiles: typeof findFiles;
+declare const index$2_getCreatedTime: typeof getCreatedTime;
+declare const index$2_getDirSize: typeof getDirSize;
+declare const index$2_getFileSize: typeof getFileSize;
+declare const index$2_getModifiedTime: typeof getModifiedTime;
+declare const index$2_isDirectory: typeof isDirectory;
+declare const index$2_isExecutable: typeof isExecutable;
+declare const index$2_isFile: typeof isFile;
+declare const index$2_isReadable: typeof isReadable;
+declare const index$2_isWritable: typeof isWritable;
+declare const index$2_listDirs: typeof listDirs;
+declare const index$2_listFiles: typeof listFiles;
+declare const index$2_moveFile: typeof moveFile;
+declare const index$2_readFile: typeof readFile;
+declare const index$2_readJSON: typeof readJSON;
+declare const index$2_writeFile: typeof writeFile;
+declare const index$2_writeJSON: typeof writeJSON;
+declare namespace index$2 {
   export {
-    compact$1 as compact,
-    index$3_deepClone as deepClone,
-    index$3_deepFreeze as deepFreeze,
-    index$3_deepMerge as deepMerge,
-    index$3_entries as entries,
-    index$3_filter as filter,
-    flatten$1 as flatten,
-    index$3_get as get,
-    index$3_groupBy as groupBy,
-    index$3_has as has,
-    index$3_invert as invert,
-    isEmpty$1 as isEmpty,
-    isEqual$1 as isEqual,
-    index$3_keyBy as keyBy,
-    index$3_keys as keys,
-    index$3_map as map,
-    index$3_merge as merge,
-    index$3_omit as omit,
-    index$3_pick as pick,
-    index$3_set as set,
-    index$3_size as size,
-    index$3_unflatten as unflatten,
-    index$3_unset as unset,
-    index$3_values as values,
+    index$2_appendFile as appendFile,
+    index$2_copyDir as copyDir,
+    index$2_copyFile as copyFile,
+    index$2_deleteDir as deleteDir,
+    index$2_deleteFile as deleteFile,
+    index$2_emptyDir as emptyDir,
+    index$2_ensureDir as ensureDir,
+    index$2_exists as exists,
+    index$2_findFiles as findFiles,
+    index$2_getCreatedTime as getCreatedTime,
+    index$2_getDirSize as getDirSize,
+    index$2_getFileSize as getFileSize,
+    index$2_getModifiedTime as getModifiedTime,
+    index$2_isDirectory as isDirectory,
+    index$2_isExecutable as isExecutable,
+    index$2_isFile as isFile,
+    index$2_isReadable as isReadable,
+    index$2_isWritable as isWritable,
+    index$2_listDirs as listDirs,
+    index$2_listFiles as listFiles,
+    index$2_moveFile as moveFile,
+    index$2_readFile as readFile,
+    index$2_readJSON as readJSON,
+    index$2_writeFile as writeFile,
+    index$2_writeJSON as writeJSON,
   };
 }
 
 /**
- * Array Utilities
- * Array manipulation and transformation functions
- */
-/**
- * Remove duplicates from array
- */
-declare function unique<T>(arr: T[]): T[];
-/**
- * Remove duplicates by key
- */
-declare function uniqueBy<T>(arr: T[], key: keyof T | ((item: T) => any)): T[];
-/**
- * Flatten nested array
- */
-declare function flatten<T>(arr: any[], depth?: number): T[];
-/**
- * Chunk array into smaller arrays
- */
-declare function chunk<T>(arr: T[], size: number): T[][];
-/**
- * Shuffle array randomly
- */
-declare function shuffle<T>(arr: T[]): T[];
-/**
- * Get random element from array
- */
-declare function sample<T>(arr: T[]): T | undefined;
-/**
- * Get multiple random elements from array
- */
-declare function sampleSize<T>(arr: T[], size: number): T[];
-/**
- * Partition array into two arrays based on predicate
+ * CCJK Logger - MUD Style
+ *
+ * Structured logging with terminal green aesthetics
  */
-declare function partition<T>(arr: T[], predicate: (item: T) => boolean): [T[], T[]];
+type LogLevel$1 = 'debug' | 'info' | 'warn' | 'error';
+interface LoggerOptions$1 {
+    level?: LogLevel$1;
+    silent?: boolean;
+}
+declare class Logger$1 {
+    private level;
+    private silent;
+    private levels;
+    constructor(options?: LoggerOptions$1);
+    private shouldLog;
+    private format;
+    /** MUD-style color scheme for log levels */
+    private colorize;
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    setLevel(level: LogLevel$1): void;
+    setSilent(silent: boolean): void;
+}
+declare const logger$1: Logger$1;
+
+declare namespace logger$2 {
+  export { Logger$1 as Logger, logger$1 as logger };
+  export type { LogLevel$1 as LogLevel, LoggerOptions$1 as LoggerOptions };
+}
+
 /**
- * Get intersection of arrays
+ * Logger Utilities
+ * Simple logging utilities
  */
-declare function intersection<T>(...arrays: T[][]): T[];
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LoggerOptions {
+    level?: LogLevel;
+    prefix?: string;
+    timestamp?: boolean;
+    colors?: boolean;
+}
 /**
- * Get union of arrays
+ * Simple logger class
  */
-declare function union<T>(...arrays: T[][]): T[];
+declare class Logger {
+    private level;
+    private prefix;
+    private timestamp;
+    private colors;
+    constructor(options?: LoggerOptions);
+    private shouldLog;
+    private formatMessage;
+    private stringify;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+}
 /**
- * Get difference between arrays (items in first but not in others)
+ * Create a logger instance
  */
-declare function difference<T>(arr: T[], ...others: T[][]): T[];
+declare function createLogger(options?: LoggerOptions): Logger;
 /**
- * Zip arrays together
+ * Default logger instance
  */
-declare function zip<T>(...arrays: T[][]): T[][];
+declare const logger: Logger;
+
 /**
- * Unzip array of arrays
+ * Object Utilities
+ * Object manipulation and transformation functions
  */
-declare function unzip<T>(arr: T[][]): T[][];
 /**
- * Group consecutive elements
+ * Deep clone an object
  */
-declare function groupConsecutive<T>(arr: T[], predicate: (a: T, b: T) => boolean): T[][];
+declare function deepClone<T>(obj: T): T;
 /**
- * Take first n elements
+ * Deep merge two objects
  */
-declare function take<T>(arr: T[], n: number): T[];
+declare function deepMerge<T extends object>(target: T, source: Partial<T>): T;
 /**
- * Take last n elements
+ * Get nested property value using dot notation
  */
-declare function takeLast<T>(arr: T[], n: number): T[];
+declare function get<T = any>(obj: any, path: string, defaultValue?: T): T | undefined;
 /**
- * Drop first n elements
+ * Set nested property value using dot notation
  */
-declare function drop<T>(arr: T[], n: number): T[];
+declare function set(obj: any, path: string, value: any): void;
 /**
- * Drop last n elements
+ * Check if object has nested property using dot notation
  */
-declare function dropLast<T>(arr: T[], n: number): T[];
+declare function has(obj: any, path: string): boolean;
 /**
- * Take elements while predicate is true
+ * Delete nested property using dot notation
  */
-declare function takeWhile<T>(arr: T[], predicate: (item: T) => boolean): T[];
+declare function unset(obj: any, path: string): boolean;
 /**
- * Drop elements while predicate is true
+ * Get all keys from object (including nested)
  */
-declare function dropWhile<T>(arr: T[], predicate: (item: T) => boolean): T[];
+declare function keys(obj: any, prefix?: string): string[];
 /**
- * Find index of element
+ * Get all values from object
  */
-declare function findIndex<T>(arr: T[], predicate: (item: T) => boolean): number;
+declare function values<T = any>(obj: Record<string, T>): T[];
 /**
- * Find last index of element
+ * Get all entries from object
  */
-declare function findLastIndex<T>(arr: T[], predicate: (item: T) => boolean): number;
+declare function entries<T = any>(obj: Record<string, T>): [string, T][];
 /**
- * Count occurrences of element
+ * Pick specific keys from object
  */
-declare function count<T>(arr: T[], item: T): number;
+declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
 /**
- * Count elements matching predicate
+ * Omit specific keys from object
  */
-declare function countBy<T>(arr: T[], predicate: (item: T) => boolean): number;
+declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
 /**
- * Sum array of numbers
+ * Filter object by predicate
  */
-declare function sum(arr: number[]): number;
+declare function filter<T>(obj: Record<string, T>, predicate: (value: T, key: string) => boolean): Record<string, T>;
 /**
- * Sum by property or function
+ * Map object values
  */
-declare function sumBy<T>(arr: T[], selector: keyof T | ((item: T) => number)): number;
+declare function map<T, U>(obj: Record<string, T>, mapper: (value: T, key: string) => U): Record<string, U>;
 /**
- * Get average of numbers
+ * Check if object is empty
  */
-declare function average(arr: number[]): number;
+declare function isEmpty(obj: object): boolean;
 /**
- * Get minimum value
+ * Flatten nested object
  */
-declare function min(arr: number[]): number | undefined;
+declare function flatten(obj: any, prefix?: string, separator?: string): Record<string, any>;
 /**
- * Get maximum value
+ * Unflatten object (reverse of flatten)
  */
-declare function max(arr: number[]): number | undefined;
+declare function unflatten(obj: Record<string, any>, separator?: string): any;
 /**
- * Get minimum by property or function
+ * Invert object (swap keys and values)
  */
-declare function minBy<T>(arr: T[], selector: keyof T | ((item: T) => number)): T | undefined;
+declare function invert<T extends string | number>(obj: Record<string, T>): Record<T, string>;
 /**
- * Get maximum by property or function
+ * Group array of objects by key
  */
-declare function maxBy<T>(arr: T[], selector: keyof T | ((item: T) => number)): T | undefined;
+declare function groupBy<T>(arr: T[], key: keyof T | ((item: T) => string)): Record<string, T[]>;
 /**
- * Sort array by property or function
+ * Convert array to object using key selector
  */
-declare function sortBy<T>(arr: T[], selector: keyof T | ((item: T) => any), order?: 'asc' | 'desc'): T[];
+declare function keyBy<T>(arr: T[], key: keyof T | ((item: T) => string)): Record<string, T>;
 /**
- * Check if array is empty
+ * Check if two objects are deeply equal
  */
-declare function isEmpty<T>(arr: T[]): boolean;
+declare function isEqual(obj1: any, obj2: any): boolean;
 /**
- * Compact array (remove falsy values)
+ * Remove null and undefined values from object
  */
-declare function compact<T>(arr: T[]): NonNullable<T>[];
+declare function compact<T extends object>(obj: T): Partial<T>;
 /**
- * Range of numbers
+ * Freeze object deeply (immutable)
  */
-declare function range(start: number, end?: number, step?: number): number[];
+declare function deepFreeze<T>(obj: T): Readonly<T>;
 /**
- * Rotate array by n positions
+ * Merge multiple objects
  */
-declare function rotate<T>(arr: T[], n: number): T[];
+declare function merge<T extends object>(...objects: Partial<T>[]): T;
 /**
- * Check if arrays are equal
+ * Get object size (number of keys)
  */
-declare function isEqual<T>(arr1: T[], arr2: T[]): boolean;
+declare function size(obj: object): number;
 
 /**
- * Array Utilities
- * Array manipulation and transformation
+ * Object Utilities
+ * Object manipulation and transformation
  */
 
-declare const index$2_average: typeof average;
-declare const index$2_chunk: typeof chunk;
-declare const index$2_compact: typeof compact;
-declare const index$2_count: typeof count;
-declare const index$2_countBy: typeof countBy;
-declare const index$2_difference: typeof difference;
-declare const index$2_drop: typeof drop;
-declare const index$2_dropLast: typeof dropLast;
-declare const index$2_dropWhile: typeof dropWhile;
-declare const index$2_findIndex: typeof findIndex;
-declare const index$2_findLastIndex: typeof findLastIndex;
-declare const index$2_flatten: typeof flatten;
-declare const index$2_groupConsecutive: typeof groupConsecutive;
-declare const index$2_intersection: typeof intersection;
-declare const index$2_isEmpty: typeof isEmpty;
-declare const index$2_isEqual: typeof isEqual;
-declare const index$2_max: typeof max;
-declare const index$2_maxBy: typeof maxBy;
-declare const index$2_min: typeof min;
-declare const index$2_minBy: typeof minBy;
-declare const index$2_partition: typeof partition;
-declare const index$2_range: typeof range;
-declare const index$2_rotate: typeof rotate;
-declare const index$2_sample: typeof sample;
-declare const index$2_sampleSize: typeof sampleSize;
-declare const index$2_shuffle: typeof shuffle;
-declare const index$2_sortBy: typeof sortBy;
-declare const index$2_sum: typeof sum;
-declare const index$2_sumBy: typeof sumBy;
-declare const index$2_take: typeof take;
-declare const index$2_takeLast: typeof takeLast;
-declare const index$2_takeWhile: typeof takeWhile;
-declare const index$2_union: typeof union;
-declare const index$2_unique: typeof unique;
-declare const index$2_uniqueBy: typeof uniqueBy;
-declare const index$2_unzip: typeof unzip;
-declare const index$2_zip: typeof zip;
-declare namespace index$2 {
+declare const index$1_compact: typeof compact;
+declare const index$1_deepClone: typeof deepClone;
+declare const index$1_deepFreeze: typeof deepFreeze;
+declare const index$1_deepMerge: typeof deepMerge;
+declare const index$1_entries: typeof entries;
+declare const index$1_filter: typeof filter;
+declare const index$1_flatten: typeof flatten;
+declare const index$1_get: typeof get;
+declare const index$1_groupBy: typeof groupBy;
+declare const index$1_has: typeof has;
+declare const index$1_invert: typeof invert;
+declare const index$1_isEmpty: typeof isEmpty;
+declare const index$1_isEqual: typeof isEqual;
+declare const index$1_keyBy: typeof keyBy;
+declare const index$1_keys: typeof keys;
+declare const index$1_map: typeof map;
+declare const index$1_merge: typeof merge;
+declare const index$1_omit: typeof omit;
+declare const index$1_pick: typeof pick;
+declare const index$1_set: typeof set;
+declare const index$1_size: typeof size;
+declare const index$1_unflatten: typeof unflatten;
+declare const index$1_unset: typeof unset;
+declare const index$1_values: typeof values;
+declare namespace index$1 {
   export {
-    index$2_average as average,
-    index$2_chunk as chunk,
-    index$2_compact as compact,
-    index$2_count as count,
-    index$2_countBy as countBy,
-    index$2_difference as difference,
-    index$2_drop as drop,
-    index$2_dropLast as dropLast,
-    index$2_dropWhile as dropWhile,
-    index$2_findIndex as findIndex,
-    index$2_findLastIndex as findLastIndex,
-    index$2_flatten as flatten,
-    index$2_groupConsecutive as groupConsecutive,
-    index$2_intersection as intersection,
-    index$2_isEmpty as isEmpty,
-    index$2_isEqual as isEqual,
-    index$2_max as max,
-    index$2_maxBy as maxBy,
-    index$2_min as min,
-    index$2_minBy as minBy,
-    index$2_partition as partition,
-    index$2_range as range,
-    index$2_rotate as rotate,
-    index$2_sample as sample,
-    index$2_sampleSize as sampleSize,
-    index$2_shuffle as shuffle,
-    index$2_sortBy as sortBy,
-    index$2_sum as sum,
-    index$2_sumBy as sumBy,
-    index$2_take as take,
-    index$2_takeLast as takeLast,
-    index$2_takeWhile as takeWhile,
-    index$2_union as union,
-    index$2_unique as unique,
-    index$2_uniqueBy as uniqueBy,
-    index$2_unzip as unzip,
-    index$2_zip as zip,
+    index$1_compact as compact,
+    index$1_deepClone as deepClone,
+    index$1_deepFreeze as deepFreeze,
+    index$1_deepMerge as deepMerge,
+    index$1_entries as entries,
+    index$1_filter as filter,
+    index$1_flatten as flatten,
+    index$1_get as get,
+    index$1_groupBy as groupBy,
+    index$1_has as has,
+    index$1_invert as invert,
+    index$1_isEmpty as isEmpty,
+    index$1_isEqual as isEqual,
+    index$1_keyBy as keyBy,
+    index$1_keys as keys,
+    index$1_map as map,
+    index$1_merge as merge,
+    index$1_omit as omit,
+    index$1_pick as pick,
+    index$1_set as set,
+    index$1_size as size,
+    index$1_unflatten as unflatten,
+    index$1_unset as unset,
+    index$1_values as values,
   };
 }
 
+declare function getPlatform$1(): 'windows' | 'macos' | 'linux';
+declare function isTermux(): boolean;
+declare function getTermuxPrefix(): string;
+declare function isWindows$1(): boolean;
+interface WSLInfo {
+    isWSL: true;
+    distro: string | null;
+    version: string | null;
+}
+declare function isWSL(): boolean;
+declare function getWSLDistro(): string | null;
+declare function getWSLInfo(): WSLInfo | null;
 /**
- * Async Utilities
- * Asynchronous operation helpers
+ * Get MCP command with platform-specific wrapper if needed
+ * @param command - The base command to execute (default: 'npx')
+ * @returns Command array with Windows wrapper if applicable
  */
+declare function getMcpCommand(command?: string): string[];
 /**
- * Sleep for specified milliseconds
+ * Normalize Windows paths by converting backslashes to forward slashes
+ * This ensures Windows paths like "C:\Program Files\nodejs\npx.cmd" are correctly
+ * written as "C:/Program Files/nodejs/npx.cmd" in TOML format, avoiding escape issues
+ * Unified function used by getSystemRoot() and normalizePath() to avoid code duplication
+ * @param str - The string to normalize (typically a Windows path)
+ * @returns The normalized string with backslashes replaced by forward slashes
  */
-declare function sleep(ms: number): Promise<void>;
+declare function normalizeTomlPath(str: string): string;
+declare function getSystemRoot(): string | null;
+declare function shouldUseSudoForGlobalInstall(): boolean;
+declare function wrapCommandWithSudo(command: string, args: string[]): {
+    command: string;
+    args: string[];
+    usedSudo: boolean;
+};
+declare function commandExists(command: string): Promise<boolean>;
 /**
- * Retry async function with exponential backoff
+ * Get possible Homebrew paths for a command on macOS
+ * Handles both Apple Silicon (/opt/homebrew) and Intel (/usr/local) installations
+ * Also checks npm global paths within Homebrew's node installation
+ * and Homebrew cask installations in Caskroom
  */
-declare function retry<T>(fn: () => Promise<T>, options?: {
-    maxAttempts?: number;
-    delay?: number;
-    backoff?: number;
-    onRetry?: (error: Error, attempt: number) => void;
-}): Promise<T>;
+declare function getHomebrewCommandPaths(command: string): Promise<string[]>;
 /**
- * Timeout a promise
+ * Find the actual path of a command, checking standard PATH and Homebrew locations
+ * Returns null if command is not found
  */
-declare function timeout<T>(promise: Promise<T>, ms: number, errorMessage?: string): Promise<T>;
+declare function findCommandPath(command: string): Promise<string | null>;
 /**
- * Debounce async function
+ * Find the real binary path of a command, bypassing shell functions/aliases
+ * This is useful when a shell function wraps a command and we need the actual binary
+ * Returns null if command is not found
  */
-declare function debounce<T extends (...args: any[]) => Promise<any>>(fn: T, delay: number): (...args: Parameters<T>) => Promise<ReturnType<T>>;
+declare function findRealCommandPath(command: string): Promise<string | null>;
 /**
- * Throttle async function
+ * Get recommended install methods for a code tool based on current platform
+ * Returns methods in priority order (most recommended first)
  */
-declare function throttle<T extends (...args: any[]) => Promise<any>>(fn: T, delay: number): (...args: Parameters<T>) => Promise<ReturnType<T>>;
+type CodeType = 'claude-code' | 'codex';
+type InstallMethod = 'npm' | 'homebrew' | 'curl' | 'powershell' | 'cmd' | 'npm-global' | 'native';
+declare function getRecommendedInstallMethods(codeType: CodeType): InstallMethod[];
+
+type platform_CodeType = CodeType;
+type platform_InstallMethod = InstallMethod;
+type platform_WSLInfo = WSLInfo;
+declare const platform_commandExists: typeof commandExists;
+declare const platform_findCommandPath: typeof findCommandPath;
+declare const platform_findRealCommandPath: typeof findRealCommandPath;
+declare const platform_getHomebrewCommandPaths: typeof getHomebrewCommandPaths;
+declare const platform_getMcpCommand: typeof getMcpCommand;
+declare const platform_getRecommendedInstallMethods: typeof getRecommendedInstallMethods;
+declare const platform_getSystemRoot: typeof getSystemRoot;
+declare const platform_getTermuxPrefix: typeof getTermuxPrefix;
+declare const platform_getWSLDistro: typeof getWSLDistro;
+declare const platform_getWSLInfo: typeof getWSLInfo;
+declare const platform_isTermux: typeof isTermux;
+declare const platform_isWSL: typeof isWSL;
+declare const platform_normalizeTomlPath: typeof normalizeTomlPath;
+declare const platform_shouldUseSudoForGlobalInstall: typeof shouldUseSudoForGlobalInstall;
+declare const platform_wrapCommandWithSudo: typeof wrapCommandWithSudo;
+declare namespace platform {
+  export { platform_commandExists as commandExists, platform_findCommandPath as findCommandPath, platform_findRealCommandPath as findRealCommandPath, platform_getHomebrewCommandPaths as getHomebrewCommandPaths, platform_getMcpCommand as getMcpCommand, getPlatform$1 as getPlatform, platform_getRecommendedInstallMethods as getRecommendedInstallMethods, platform_getSystemRoot as getSystemRoot, platform_getTermuxPrefix as getTermuxPrefix, platform_getWSLDistro as getWSLDistro, platform_getWSLInfo as getWSLInfo, platform_isTermux as isTermux, platform_isWSL as isWSL, isWindows$1 as isWindows, platform_normalizeTomlPath as normalizeTomlPath, platform_shouldUseSudoForGlobalInstall as shouldUseSudoForGlobalInstall, platform_wrapCommandWithSudo as wrapCommandWithSudo };
+  export type { platform_CodeType as CodeType, platform_InstallMethod as InstallMethod, platform_WSLInfo as WSLInfo };
+}
+
 /**
- * Execute promises in parallel with concurrency limit
+ * Platform Detection Utilities
+ * Provides utilities for detecting and working with different platforms
  */
-declare function parallelLimit<T>(tasks: (() => Promise<T>)[], limit: number): Promise<T[]>;
+type Platform = 'darwin' | 'linux' | 'win32' | 'unknown';
+type Architecture = 'x64' | 'arm64' | 'ia32' | 'unknown';
 /**
- * Execute promises in sequence
+ * Get current platform
  */
-declare function sequence<T>(tasks: (() => Promise<T>)[]): Promise<T[]>;
+declare function getPlatform(): Platform;
 /**
- * Execute promises with all settled (no rejection)
+ * Get current architecture
  */
-declare function allSettled<T>(promises: Promise<T>[]): Promise<Array<{
-    status: 'fulfilled';
-    value: T;
-} | {
-    status: 'rejected';
-    reason: any;
-}>>;
+declare function getArchitecture(): Architecture;
 /**
- * Race promises with timeout
+ * Check if running on macOS
  */
-declare function raceWithTimeout<T>(promises: Promise<T>[], ms: number): Promise<T>;
+declare function isMacOS(): boolean;
 /**
- * Memoize async function
+ * Check if running on Linux
  */
-declare function memoize<T extends (...args: any[]) => Promise<any>>(fn: T, options?: {
-    keyGenerator?: (...args: Parameters<T>) => string;
-    ttl?: number;
-}): T;
+declare function isLinux(): boolean;
 /**
- * Create a deferred promise
+ * Check if running on Windows
  */
-interface Deferred<T> {
-    promise: Promise<T>;
-    resolve: (value: T) => void;
-    reject: (reason?: any) => void;
-}
-declare function defer<T>(): Deferred<T>;
+declare function isWindows(): boolean;
 /**
- * Wait for condition to be true
+ * Check if running on Unix-like system (macOS or Linux)
  */
-declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
-    timeout?: number;
-    interval?: number;
-    timeoutMessage?: string;
-}): Promise<void>;
+declare function isUnix(): boolean;
 /**
- * Execute function with mutex lock
+ * Get platform-specific information
  */
-declare class Mutex {
-    private locked;
-    private queue;
-    acquire(): Promise<void>;
-    release(): void;
-    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+interface PlatformInfo {
+    platform: Platform;
+    architecture: Architecture;
+    release: string;
+    hostname: string;
+    homedir: string;
+    tmpdir: string;
+    cpus: number;
+    totalMemory: number;
+    freeMemory: number;
 }
 /**
- * Create a semaphore for limiting concurrent operations
+ * Get comprehensive platform information
  */
-declare class Semaphore {
-    private permits;
-    private queue;
-    constructor(permits: number);
-    acquire(): Promise<void>;
-    release(): void;
-    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
-}
+declare function getPlatformInfo(): PlatformInfo;
+
 /**
- * Batch async operations
+ * Platform Path Utilities
+ * Provides utilities for working with platform-specific paths
  */
-declare function batch<T, R>(items: T[], batchSize: number, processor: (batch: T[]) => Promise<R[]>): Promise<R[]>;
+
 /**
- * Poll for result
+ * Get user's home directory
  */
-declare function poll<T>(fn: () => Promise<T>, options?: {
-    interval?: number;
-    timeout?: number;
-    validate?: (result: T) => boolean;
-}): Promise<T>;
+declare function getHomeDir(): string;
+/**
+ * Get user's config directory
+ */
+declare function getConfigDir(appName?: string): string;
+/**
+ * Get user's data directory
+ */
+declare function getDataDir(appName?: string): string;
+/**
+ * Get user's cache directory
+ */
+declare function getCacheDir(appName?: string): string;
+/**
+ * Get user's temporary directory
+ */
+declare function getTempDir(appName?: string): string;
 
 /**
- * Async Utilities
- * Asynchronous operation helpers
+ * String Utilities
+ * String manipulation and formatting functions
+ */
+/**
+ * Capitalize first letter of string
+ */
+declare function capitalize(str: string): string;
+/**
+ * Convert string to camelCase
  */
-
-type index$1_Deferred<T> = Deferred<T>;
-type index$1_Mutex = Mutex;
-declare const index$1_Mutex: typeof Mutex;
-type index$1_Semaphore = Semaphore;
-declare const index$1_Semaphore: typeof Semaphore;
-declare const index$1_allSettled: typeof allSettled;
-declare const index$1_batch: typeof batch;
-declare const index$1_debounce: typeof debounce;
-declare const index$1_defer: typeof defer;
-declare const index$1_memoize: typeof memoize;
-declare const index$1_parallelLimit: typeof parallelLimit;
-declare const index$1_poll: typeof poll;
-declare const index$1_raceWithTimeout: typeof raceWithTimeout;
-declare const index$1_retry: typeof retry;
-declare const index$1_sequence: typeof sequence;
-declare const index$1_sleep: typeof sleep;
-declare const index$1_throttle: typeof throttle;
-declare const index$1_timeout: typeof timeout;
-declare const index$1_waitFor: typeof waitFor;
-declare namespace index$1 {
-  export { index$1_Mutex as Mutex, index$1_Semaphore as Semaphore, index$1_allSettled as allSettled, index$1_batch as batch, index$1_debounce as debounce, index$1_defer as defer, index$1_memoize as memoize, index$1_parallelLimit as parallelLimit, index$1_poll as poll, index$1_raceWithTimeout as raceWithTimeout, index$1_retry as retry, index$1_sequence as sequence, index$1_sleep as sleep, index$1_throttle as throttle, index$1_timeout as timeout, index$1_waitFor as waitFor };
-  export type { index$1_Deferred as Deferred };
-}
-
+declare function camelCase(str: string): string;
 /**
- * Error Utilities
- * Error handling and custom error classes
+ * Convert string to PascalCase
  */
+declare function pascalCase(str: string): string;
 /**
- * Base custom error class
+ * Convert string to snake_case
  */
-declare class BaseError extends Error {
-    readonly code?: string | undefined;
-    readonly statusCode?: number | undefined;
-    readonly details?: any | undefined;
-    constructor(message: string, code?: string | undefined, statusCode?: number | undefined, details?: any | undefined);
-    toJSON(): {
-        name: string;
-        message: string;
-        code: string | undefined;
-        statusCode: number | undefined;
-        details: any;
-        stack: string | undefined;
-    };
-}
+declare function snakeCase(str: string): string;
 /**
- * Validation error
+ * Convert string to kebab-case
  */
-declare class ValidationError$1 extends BaseError {
-    constructor(message: string, details?: any);
-}
+declare function kebabCase(str: string): string;
 /**
- * Not found error
+ * Convert string to CONSTANT_CASE
  */
-declare class NotFoundError extends BaseError {
-    constructor(message: string, details?: any);
-}
+declare function constantCase(str: string): string;
 /**
- * Unauthorized error
+ * Truncate string to specified length
  */
-declare class UnauthorizedError extends BaseError {
-    constructor(message: string, details?: any);
-}
+declare function truncate(str: string, length: number, suffix?: string): string;
 /**
- * Forbidden error
+ * Pad string to specified length
  */
-declare class ForbiddenError extends BaseError {
-    constructor(message: string, details?: any);
-}
+declare function pad(str: string, length: number, char?: string, direction?: 'left' | 'right' | 'both'): string;
 /**
- * Conflict error
+ * Remove whitespace from both ends
  */
-declare class ConflictError extends BaseError {
-    constructor(message: string, details?: any);
-}
+declare function trim(str: string): string;
 /**
- * Timeout error
+ * Remove whitespace from start
  */
-declare class TimeoutError extends BaseError {
-    constructor(message: string, details?: any);
-}
+declare function trimStart(str: string): string;
 /**
- * Internal error
+ * Remove whitespace from end
  */
-declare class InternalError extends BaseError {
-    constructor(message: string, details?: any);
-}
+declare function trimEnd(str: string): string;
 /**
- * Configuration error
+ * Split string by delimiter
  */
-declare class ConfigurationError extends BaseError {
-    constructor(message: string, details?: any);
-}
+declare function split(str: string, delimiter: string | RegExp): string[];
 /**
- * Network error
+ * Join array of strings
  */
-declare class NetworkError extends BaseError {
-    constructor(message: string, details?: any);
-}
+declare function join(arr: string[], separator?: string): string;
 /**
- * Check if error is of specific type
+ * Replace all occurrences of search with replacement
  */
-declare function isErrorType<T extends Error>(error: unknown, errorClass: new (...args: any[]) => T): error is T;
+declare function replaceAll(str: string, search: string | RegExp, replacement: string): string;
 /**
- * Get error message safely
+ * Check if string starts with prefix
  */
-declare function getErrorMessage(error: unknown): string;
+declare function startsWith(str: string, prefix: string): boolean;
 /**
- * Get error stack safely
+ * Check if string ends with suffix
  */
-declare function getErrorStack(error: unknown): string | undefined;
+declare function endsWith(str: string, suffix: string): boolean;
 /**
- * Format error for logging
+ * Check if string contains substring
  */
-declare function formatError(error: unknown): {
-    message: string;
-    name?: string;
-    code?: string;
-    statusCode?: number;
-    stack?: string;
-    details?: any;
-};
+declare function contains(str: string, substring: string): boolean;
 /**
- * Wrap error with additional context
+ * Count occurrences of substring
  */
-declare function wrapError(error: unknown, message: string, code?: string): BaseError;
+declare function countOccurrences(str: string, substring: string): number;
 /**
- * Try-catch wrapper that returns result or error
+ * Reverse string
  */
-declare function tryCatch<T>(fn: () => T): {
-    success: true;
-    data: T;
-} | {
-    success: false;
-    error: Error;
-};
+declare function reverse(str: string): string;
 /**
- * Async try-catch wrapper
+ * Remove all whitespace
  */
-declare function tryCatchAsync<T>(fn: () => Promise<T>): Promise<{
-    success: true;
-    data: T;
-} | {
-    success: false;
-    error: Error;
-}>;
+declare function removeWhitespace(str: string): string;
 /**
- * Assert condition or throw error
+ * Normalize whitespace (replace multiple spaces with single space)
  */
-declare function assert$1(condition: boolean, message: string, ErrorClass?: new (message: string) => Error): asserts condition;
+declare function normalizeWhitespace(str: string): string;
 /**
- * Create error handler
+ * Extract words from string
  */
-declare function createErrorHandler(handlers: Record<string, (error: Error) => void>, defaultHandler?: (error: Error) => void): (error: unknown) => void;
+declare function words(str: string): string[];
 /**
- * Aggregate multiple errors
+ * Count words in string
  */
-declare class AggregateError extends BaseError {
-    readonly errors: Error[];
-    constructor(errors: Error[], message?: string);
-    static fromErrors(errors: Error[]): AggregateError;
-}
+declare function wordCount(str: string): number;
 /**
- * Retry with error handling
+ * Convert string to title case
  */
-declare function retryWithErrorHandling<T>(fn: () => Promise<T>, options?: {
-    maxAttempts?: number;
-    delay?: number;
-    shouldRetry?: (error: Error) => boolean;
-    onError?: (error: Error, attempt: number) => void;
-}): Promise<T>;
-
+declare function titleCase(str: string): string;
 /**
- * Error Utilities
- * Error handling and custom error classes
+ * Convert string to sentence case
  */
-
-type index_AggregateError = AggregateError;
-declare const index_AggregateError: typeof AggregateError;
-type index_BaseError = BaseError;
-declare const index_BaseError: typeof BaseError;
-type index_ConfigurationError = ConfigurationError;
-declare const index_ConfigurationError: typeof ConfigurationError;
-type index_ConflictError = ConflictError;
-declare const index_ConflictError: typeof ConflictError;
-type index_ForbiddenError = ForbiddenError;
-declare const index_ForbiddenError: typeof ForbiddenError;
-type index_InternalError = InternalError;
-declare const index_InternalError: typeof InternalError;
-type index_NetworkError = NetworkError;
-declare const index_NetworkError: typeof NetworkError;
-type index_NotFoundError = NotFoundError;
-declare const index_NotFoundError: typeof NotFoundError;
-type index_TimeoutError = TimeoutError;
-declare const index_TimeoutError: typeof TimeoutError;
-type index_UnauthorizedError = UnauthorizedError;
-declare const index_UnauthorizedError: typeof UnauthorizedError;
-declare const index_createErrorHandler: typeof createErrorHandler;
-declare const index_formatError: typeof formatError;
-declare const index_getErrorMessage: typeof getErrorMessage;
-declare const index_getErrorStack: typeof getErrorStack;
-declare const index_isErrorType: typeof isErrorType;
-declare const index_retryWithErrorHandling: typeof retryWithErrorHandling;
-declare const index_tryCatch: typeof tryCatch;
-declare const index_tryCatchAsync: typeof tryCatchAsync;
-declare const index_wrapError: typeof wrapError;
-declare namespace index {
-  export {
-    index_AggregateError as AggregateError,
-    index_BaseError as BaseError,
-    index_ConfigurationError as ConfigurationError,
-    index_ConflictError as ConflictError,
-    index_ForbiddenError as ForbiddenError,
-    index_InternalError as InternalError,
-    index_NetworkError as NetworkError,
-    index_NotFoundError as NotFoundError,
-    index_TimeoutError as TimeoutError,
-    index_UnauthorizedError as UnauthorizedError,
-    ValidationError$1 as ValidationError,
-    assert$1 as assert,
-    index_createErrorHandler as createErrorHandler,
-    index_formatError as formatError,
-    index_getErrorMessage as getErrorMessage,
-    index_getErrorStack as getErrorStack,
-    index_isErrorType as isErrorType,
-    index_retryWithErrorHandling as retryWithErrorHandling,
-    index_tryCatch as tryCatch,
-    index_tryCatchAsync as tryCatchAsync,
-    index_wrapError as wrapError,
-  };
-}
-
+declare function sentenceCase(str: string): string;
 /**
- * CCJK Logger - MUD Style
- *
- * Structured logging with terminal green aesthetics
+ * Escape HTML special characters
  */
-type LogLevel$1 = 'debug' | 'info' | 'warn' | 'error';
-interface LoggerOptions$1 {
-    level?: LogLevel$1;
-    silent?: boolean;
-}
-declare class Logger$1 {
-    private level;
-    private silent;
-    private levels;
-    constructor(options?: LoggerOptions$1);
-    private shouldLog;
-    private format;
-    /** MUD-style color scheme for log levels */
-    private colorize;
-    debug(message: string, data?: unknown): void;
-    info(message: string, data?: unknown): void;
-    warn(message: string, data?: unknown): void;
-    error(message: string, data?: unknown): void;
-    setLevel(level: LogLevel$1): void;
-    setSilent(silent: boolean): void;
-}
-declare const logger$1: Logger$1;
-
-declare namespace logger$2 {
-  export { Logger$1 as Logger, logger$1 as logger };
-  export type { LogLevel$1 as LogLevel, LoggerOptions$1 as LoggerOptions };
-}
-
+declare function escapeHTML(str: string): string;
 /**
- * Configuration Manager
- * Provides utilities for loading, saving, and managing configuration files
+ * Unescape HTML special characters
  */
-interface ConfigOptions {
-    configDir?: string;
-    fileName?: string;
-    createIfMissing?: boolean;
-    validate?: (config: any) => boolean;
-}
+declare function unescapeHTML(str: string): string;
 /**
- * Configuration Manager class
- * Handles configuration file operations with validation and error handling
+ * Escape regular expression special characters
  */
-declare class ConfigManager<T = any> {
-    private readonly namespace;
-    private configPath;
-    private options;
-    private cache?;
-    constructor(namespace: string, options?: ConfigOptions);
-    /**
-     * Get the default configuration directory
-     */
-    private getDefaultConfigDir;
-    /**
-     * Load configuration from file
-     */
-    load(): Promise<T | null>;
-    /**
-     * Save configuration to file
-     */
-    save(config: T): Promise<void>;
-    /**
-     * Update configuration (merge with existing)
-     */
-    update(updates: Partial<T>): Promise<T>;
-    /**
-     * Delete configuration file
-     */
-    delete(): Promise<void>;
-    /**
-     * Check if configuration file exists
-     */
-    exists(): Promise<boolean>;
-    /**
-     * Get configuration path
-     */
-    getPath(): string;
-    /**
-     * Get cached configuration (without file I/O)
-     */
-    getCached(): T | undefined;
-    /**
-     * Clear cache
-     */
-    clearCache(): void;
-}
+declare function escapeRegExp(str: string): string;
+/**
+ * Generate random string
+ */
+declare function randomString(length: number, charset?: string): string;
 /**
- * Create a configuration manager instance
+ * Generate UUID v4
  */
-declare function createConfigManager<T = any>(namespace: string, options?: ConfigOptions): ConfigManager<T>;
+declare function uuid(): string;
+/**
+ * Slugify string (URL-friendly)
+ */
+declare function slugify(str: string): string;
+/**
+ * Extract numbers from string
+ */
+declare function extractNumbers(str: string): number[];
+/**
+ * Format template string with values
+ */
+declare function template(str: string, values: Record<string, any>): string;
+/**
+ * Repeat string n times
+ */
+declare function repeat(str: string, count: number): string;
+/**
+ * Check if string is empty or only whitespace
+ */
+declare function isBlank(str: string): boolean;
+/**
+ * Ensure string ends with suffix
+ */
+declare function ensureSuffix(str: string, suffix: string): string;
+/**
+ * Ensure string starts with prefix
+ */
+declare function ensurePrefix(str: string, prefix: string): string;
+/**
+ * Remove prefix from string
+ */
+declare function removePrefix(str: string, prefix: string): string;
+/**
+ * Remove suffix from string
+ */
+declare function removeSuffix(str: string, suffix: string): string;
 
 /**
- * Configuration Validator
- * Provides utilities for validating configuration objects
+ * String Utilities
+ * String manipulation and formatting
  */
-interface ValidationRule<T = any> {
-    field: keyof T;
-    required?: boolean;
-    type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
-    validator?: (value: any) => boolean;
-    message?: string;
-}
-interface ValidationError {
-    field: string;
-    message: string;
+
+declare const index_camelCase: typeof camelCase;
+declare const index_capitalize: typeof capitalize;
+declare const index_constantCase: typeof constantCase;
+declare const index_contains: typeof contains;
+declare const index_countOccurrences: typeof countOccurrences;
+declare const index_endsWith: typeof endsWith;
+declare const index_ensurePrefix: typeof ensurePrefix;
+declare const index_ensureSuffix: typeof ensureSuffix;
+declare const index_escapeHTML: typeof escapeHTML;
+declare const index_escapeRegExp: typeof escapeRegExp;
+declare const index_extractNumbers: typeof extractNumbers;
+declare const index_isBlank: typeof isBlank;
+declare const index_join: typeof join;
+declare const index_kebabCase: typeof kebabCase;
+declare const index_normalizeWhitespace: typeof normalizeWhitespace;
+declare const index_pad: typeof pad;
+declare const index_pascalCase: typeof pascalCase;
+declare const index_randomString: typeof randomString;
+declare const index_removePrefix: typeof removePrefix;
+declare const index_removeSuffix: typeof removeSuffix;
+declare const index_removeWhitespace: typeof removeWhitespace;
+declare const index_repeat: typeof repeat;
+declare const index_replaceAll: typeof replaceAll;
+declare const index_reverse: typeof reverse;
+declare const index_sentenceCase: typeof sentenceCase;
+declare const index_slugify: typeof slugify;
+declare const index_snakeCase: typeof snakeCase;
+declare const index_split: typeof split;
+declare const index_startsWith: typeof startsWith;
+declare const index_template: typeof template;
+declare const index_titleCase: typeof titleCase;
+declare const index_trim: typeof trim;
+declare const index_trimEnd: typeof trimEnd;
+declare const index_trimStart: typeof trimStart;
+declare const index_truncate: typeof truncate;
+declare const index_unescapeHTML: typeof unescapeHTML;
+declare const index_uuid: typeof uuid;
+declare const index_wordCount: typeof wordCount;
+declare const index_words: typeof words;
+declare namespace index {
+  export {
+    index_camelCase as camelCase,
+    index_capitalize as capitalize,
+    index_constantCase as constantCase,
+    index_contains as contains,
+    index_countOccurrences as countOccurrences,
+    index_endsWith as endsWith,
+    index_ensurePrefix as ensurePrefix,
+    index_ensureSuffix as ensureSuffix,
+    index_escapeHTML as escapeHTML,
+    index_escapeRegExp as escapeRegExp,
+    index_extractNumbers as extractNumbers,
+    index_isBlank as isBlank,
+    index_join as join,
+    index_kebabCase as kebabCase,
+    index_normalizeWhitespace as normalizeWhitespace,
+    index_pad as pad,
+    index_pascalCase as pascalCase,
+    index_randomString as randomString,
+    index_removePrefix as removePrefix,
+    index_removeSuffix as removeSuffix,
+    index_removeWhitespace as removeWhitespace,
+    index_repeat as repeat,
+    index_replaceAll as replaceAll,
+    index_reverse as reverse,
+    index_sentenceCase as sentenceCase,
+    index_slugify as slugify,
+    index_snakeCase as snakeCase,
+    index_split as split,
+    index_startsWith as startsWith,
+    index_template as template,
+    index_titleCase as titleCase,
+    index_trim as trim,
+    index_trimEnd as trimEnd,
+    index_trimStart as trimStart,
+    index_truncate as truncate,
+    index_unescapeHTML as unescapeHTML,
+    index_uuid as uuid,
+    index_wordCount as wordCount,
+    index_words as words,
+  };
 }
+
+/**
+ * Unified Input Validation Library
+ * Provides reusable validation functions for common input types
+ */
+/**
+ * Validation result interface
+ */
 interface ValidationResult {
     valid: boolean;
-    errors: ValidationError[];
+    error?: string;
 }
 /**
- * Configuration Validator class
+ * Validate array access safety
  */
-declare class ConfigValidator<T = any> {
-    private rules;
-    constructor(rules: ValidationRule<T>[]);
-    /**
-     * Validate a configuration object
-     */
-    validate(config: Partial<T>): ValidationResult;
-    /**
-     * Validate and throw on error
-     */
-    validateOrThrow(config: Partial<T>): void;
-}
+declare function validateArrayAccess<T>(array: T[] | null | undefined, index: number): ValidationResult;
 /**
- * Create a configuration validator
+ * Safely access array element
  */
-declare function createValidator<T = any>(rules: ValidationRule<T>[]): ConfigValidator<T>;
+declare function safeArrayAccess<T>(array: T[] | null | undefined, index: number, defaultValue?: T): T | undefined;
 /**
- * Common validation functions
+ * Validate object key access
  */
-declare const validators: {
-    /**
-     * Validate string is not empty
-     */
-    notEmpty: (value: string) => boolean;
-    /**
-     * Validate string matches pattern
-     */
-    pattern: (regex: RegExp) => (value: string) => boolean;
-    /**
-     * Validate number is in range
-     */
-    range: (min: number, max: number) => (value: number) => boolean;
-    /**
-     * Validate string length
-     */
-    length: (min: number, max?: number) => (value: string) => boolean;
-    /**
-     * Validate value is one of allowed values
-     */
-    oneOf: <T>(allowed: T[]) => (value: T) => boolean;
-    /**
-     * Validate email format
-     */
-    email: (value: string) => boolean;
-    /**
-     * Validate URL format
-     */
-    url: (value: string) => boolean;
-    /**
-     * Validate object has required keys
-     */
-    hasKeys: (keys: string[]) => (value: any) => boolean;
-    /**
-     * Validate array is not empty
-     */
-    notEmptyArray: (value: any[]) => boolean;
-};
-
+declare function validateObjectKeyAccess<T extends Record<string, unknown>>(obj: T | null | undefined, key: string): ValidationResult;
 /**
- * Platform Detection Utilities
- * Provides utilities for detecting and working with different platforms
+ * Safely access object property
  */
-type Platform = 'darwin' | 'linux' | 'win32' | 'unknown';
-type Architecture = 'x64' | 'arm64' | 'ia32' | 'unknown';
+declare function safeObjectAccess<T extends Record<string, unknown>, K extends keyof T>(obj: T | null | undefined, key: K, defaultValue?: T[K]): T[K] | undefined;
 /**
- * Get current platform
+ * Validate environment variable name
  */
-declare function getPlatform(): Platform;
+declare function isValidEnvVarName(name: string): ValidationResult;
 /**
- * Get current architecture
+ * Sanitize environment variable value
  */
-declare function getArchitecture(): Architecture;
+declare function sanitizeEnvValue(value: string): string;
 /**
- * Check if running on macOS
+ * Validate URL format
  */
-declare function isMacOS(): boolean;
+declare function isValidUrl(url: string): ValidationResult;
 /**
- * Check if running on Linux
+ * Validate file path safety (no directory traversal)
  */
-declare function isLinux(): boolean;
+declare function isValidFilePath(path: string): ValidationResult;
 /**
- * Check if running on Windows
+ * Validate path entry (filename or directory name)
  */
-declare function isWindows(): boolean;
+declare function isValidPathEntry(entry: string): ValidationResult;
 /**
- * Check if running on Unix-like system (macOS or Linux)
+ * Validate user input string
  */
-declare function isUnix(): boolean;
+declare function validateUserInput(input: string, options?: {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    allowedChars?: string;
+}): ValidationResult;
 /**
- * Get platform-specific information
+ * Sanitize user input
  */
-interface PlatformInfo {
-    platform: Platform;
-    architecture: Architecture;
-    release: string;
-    hostname: string;
-    homedir: string;
-    tmpdir: string;
-    cpus: number;
-    totalMemory: number;
-    freeMemory: number;
-}
+declare function sanitizeUserInput(input: string, maxLength?: number): string;
 /**
- * Get comprehensive platform information
+ * Validate API key format
  */
-declare function getPlatformInfo(): PlatformInfo;
-
+declare function isValidApiKey(apiKey: string): ValidationResult;
 /**
- * Platform Path Utilities
- * Provides utilities for working with platform-specific paths
+ * Format API key for display (mask sensitive parts)
  */
-
+declare function formatApiKeyDisplay(apiKey: string | null | undefined): string;
 /**
- * Get user's home directory
+ * Validate configuration object structure
  */
-declare function getHomeDir(): string;
+declare function validateConfigStructure(config: unknown, schema: Record<string, 'string' | 'number' | 'boolean' | 'object' | 'array'>): ValidationResult;
 /**
- * Get user's config directory
+ * Validate array of items
  */
-declare function getConfigDir(appName?: string): string;
+declare function validateArray(array: unknown, validator: (item: unknown) => ValidationResult): ValidationResult;
 /**
- * Get user's data directory
+ * Validate enum value
  */
-declare function getDataDir(appName?: string): string;
+declare function isValidEnumValue<T extends string | number>(value: unknown, allowedValues: T[]): ValidationResult;
 /**
- * Get user's cache directory
+ * Validate port number
  */
-declare function getCacheDir(appName?: string): string;
+declare function isValidPort(port: unknown): ValidationResult;
 /**
- * Get user's temporary directory
+ * Validate hostname
  */
-declare function getTempDir(appName?: string): string;
+declare function isValidHostname(hostname: string): ValidationResult;
+
+type validation_ValidationResult = ValidationResult;
+declare const validation_formatApiKeyDisplay: typeof formatApiKeyDisplay;
+declare const validation_isValidApiKey: typeof isValidApiKey;
+declare const validation_isValidEnumValue: typeof isValidEnumValue;
+declare const validation_isValidEnvVarName: typeof isValidEnvVarName;
+declare const validation_isValidFilePath: typeof isValidFilePath;
+declare const validation_isValidHostname: typeof isValidHostname;
+declare const validation_isValidPathEntry: typeof isValidPathEntry;
+declare const validation_isValidPort: typeof isValidPort;
+declare const validation_isValidUrl: typeof isValidUrl;
+declare const validation_safeArrayAccess: typeof safeArrayAccess;
+declare const validation_safeObjectAccess: typeof safeObjectAccess;
+declare const validation_sanitizeEnvValue: typeof sanitizeEnvValue;
+declare const validation_sanitizeUserInput: typeof sanitizeUserInput;
+declare const validation_validateArray: typeof validateArray;
+declare const validation_validateArrayAccess: typeof validateArrayAccess;
+declare const validation_validateConfigStructure: typeof validateConfigStructure;
+declare const validation_validateObjectKeyAccess: typeof validateObjectKeyAccess;
+declare const validation_validateUserInput: typeof validateUserInput;
+declare namespace validation {
+  export { validation_formatApiKeyDisplay as formatApiKeyDisplay, validation_isValidApiKey as isValidApiKey, validation_isValidEnumValue as isValidEnumValue, validation_isValidEnvVarName as isValidEnvVarName, validation_isValidFilePath as isValidFilePath, validation_isValidHostname as isValidHostname, validation_isValidPathEntry as isValidPathEntry, validation_isValidPort as isValidPort, validation_isValidUrl as isValidUrl, validation_safeArrayAccess as safeArrayAccess, validation_safeObjectAccess as safeObjectAccess, validation_sanitizeEnvValue as sanitizeEnvValue, validation_sanitizeUserInput as sanitizeUserInput, validation_validateArray as validateArray, validation_validateArrayAccess as validateArrayAccess, validation_validateConfigStructure as validateConfigStructure, validation_validateObjectKeyAccess as validateObjectKeyAccess, validation_validateUserInput as validateUserInput };
+  export type { validation_ValidationResult as ValidationResult };
+}
 
 /**
  * Validation Utilities
@@ -2404,44 +2446,5 @@ declare function assertDefined<T>(value: T | null | undefined, message?: string)
  */
 declare function assert(condition: boolean, message?: string): asserts condition;
 
-/**
- * Logger Utilities
- * Simple logging utilities
- */
-type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-interface LoggerOptions {
-    level?: LogLevel;
-    prefix?: string;
-    timestamp?: boolean;
-    colors?: boolean;
-}
-/**
- * Simple logger class
- */
-declare class Logger {
-    private level;
-    private prefix;
-    private timestamp;
-    private colors;
-    constructor(options?: LoggerOptions);
-    private shouldLog;
-    private formatMessage;
-    private stringify;
-    debug(message: string, ...args: any[]): void;
-    info(message: string, ...args: any[]): void;
-    warn(message: string, ...args: any[]): void;
-    error(message: string, ...args: any[]): void;
-    setLevel(level: LogLevel): void;
-    getLevel(): LogLevel;
-}
-/**
- * Create a logger instance
- */
-declare function createLogger(options?: LoggerOptions): Logger;
-/**
- * Default logger instance
- */
-declare const logger: Logger;
-
-export { AiderTool, BaseCodeTool, BaseError, ClaudeCodeTool, ClineTool, CodexTool, ConfigManager, ConfigValidator, ConfigurationError, ContinueTool, CursorTool, InternalError, Logger, Mutex, NotFoundError, Semaphore, TimeoutError, ToolFactory, ToolRegistry, UnauthorizedError, ValidationError$1 as ValidationError, index$2 as array, assert, assertDefined, index$1 as async, camelCase, capitalize, chunk, index$6 as command, commandExists, config, copyFile, createConfigManager, createLogger, createTool, createValidator, debounce, deepClone, deepMerge, deleteDir, deleteFile, difference, ensureDir, index as error, executeCommand, executeCommandStream, exists, flatten$1 as flatten, flatten as flattenArray, formatError, index$5 as fs, get, getArchitecture, getCacheDir, getCommandPath, getCommandVersion, getConfigDir, getDataDir, getErrorMessage, getHomeDir, getPlatform, getPlatformInfo, getRegistry, getTempDir, has, intersection, isArray, isBoolean, isDefined, isDirectory, isEmail, isFile, isLinux, isMacOS, isNumber, isObject, isString, isURL, isUnix, isWindows, kebabCase, listDirs, listFiles, logger, logger$2 as loggerUtils, moveFile, index$3 as object, omit, parallelLimit, partition, pascalCase, pick, platform, readFile, readJSON, retry, sequence, set, shuffle, sleep, slugify, snakeCase, index$4 as string, template, throttle, timeout, truncate, tryCatch, tryCatchAsync, unflatten, union, unique, validation, validators, waitFor, wrapError, writeFile, writeJSON };
+export { AiderTool, BaseCodeTool, BaseError, ClaudeCodeTool, ClineTool, CodexTool, ConfigManager, ConfigValidator, ConfigurationError, ContinueTool, CursorTool, InternalError, Logger, Mutex, NotFoundError, Semaphore, TimeoutError, ToolFactory, ToolRegistry, UnauthorizedError, ValidationError, index$6 as array, assert, assertDefined, index$5 as async, camelCase, capitalize, chunk, index$4 as command, commandExists$1 as commandExists, config, copyFile, createConfigManager, createLogger, createTool, createValidator, debounce, deepClone, deepMerge, deleteDir, deleteFile, difference, ensureDir, index$3 as error, executeCommand, executeCommandStream, exists, flatten, flatten$1 as flattenArray, formatError, index$2 as fs, get, getArchitecture, getCacheDir, getCommandPath, getCommandVersion, getConfigDir, getDataDir, getErrorMessage, getHomeDir, getPlatform, getPlatformInfo, getRegistry, getTempDir, has, intersection, isArray, isBoolean, isDefined, isDirectory, isEmail, isFile, isLinux, isMacOS, isNumber, isObject, isString, isURL, isUnix, isWindows, kebabCase, listDirs, listFiles, logger, logger$2 as loggerUtils, moveFile, index$1 as object, omit, parallelLimit, partition, pascalCase, pick, platform, readFile, readJSON, retry, sequence, set, shuffle, sleep, slugify, snakeCase, index as string, template, throttle, timeout, truncate, tryCatch, tryCatchAsync, unflatten, union, unique, validation, validators, waitFor, wrapError, writeFile, writeJSON };
 export type { ExecutionResult, IChatTool, ICodeGenTool, ICodeTool, IFileEditTool, InstallStatus, ToolCapabilities, ToolConfig, ToolMetadata };