overai 1.4.0

package/dist/cli/index.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * OverAI TypeScript CLI
+ * Implements CLI Spec v1.0.0
+ *
+ * Binary: overai-ts
+ * Package: overai (npm)
+ */
+import { CLI_SPEC_VERSION } from './spec/cli-spec';
+export interface ParsedArgs {
+    command: string;
+    subcommand?: string;
+    args: string[];
+    options: Record<string, unknown>;
+}
+/**
+ * Parse command line arguments according to CLI spec
+ */
+declare function parseArgs(argv: string[]): ParsedArgs;
+/**
+ * Load and execute a command (lazy loading)
+ */
+declare function executeCommand(parsed: ParsedArgs): Promise<void>;
+export { parseArgs, executeCommand, CLI_SPEC_VERSION };

package/dist/cli/index.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * OverAI TypeScript CLI
+ * Implements CLI Spec v1.0.0
+ *
+ * Binary: overai-ts
+ * Package: overai (npm)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_SPEC_VERSION = void 0;
+exports.parseArgs = parseArgs;
+exports.executeCommand = executeCommand;
+const cli_spec_1 = require("./spec/cli-spec");
+Object.defineProperty(exports, "CLI_SPEC_VERSION", { enumerable: true, get: function () { return cli_spec_1.CLI_SPEC_VERSION; } });
+function outputJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+function formatError(code, message, details) {
+    return details !== undefined
+        ? { success: false, error: { code, message }, details }
+        : { success: false, error: { code, message } };
+}
+const ERROR_CODES = {
+    INVALID_ARGS: 'INVALID_ARGS',
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+};
+function normalizeError(error) {
+    if (error && typeof error === 'object') {
+        const anyErr = error;
+        const code = anyErr.code || ERROR_CODES.UNKNOWN_ERROR;
+        const message = anyErr.message || String(error);
+        const exitCode = typeof anyErr.exitCode === 'number' ? anyErr.exitCode : cli_spec_1.EXIT_CODES.RUNTIME_ERROR;
+        const details = anyErr.details;
+        return { code, message, exitCode, details };
+    }
+    if (error instanceof Error) {
+        return { code: ERROR_CODES.UNKNOWN_ERROR, message: error.message, exitCode: cli_spec_1.EXIT_CODES.RUNTIME_ERROR, details: { stack: error.stack } };
+    }
+    return { code: ERROR_CODES.UNKNOWN_ERROR, message: String(error), exitCode: cli_spec_1.EXIT_CODES.RUNTIME_ERROR };
+}
+/**
+ * Parse command line arguments according to CLI spec
+ */
+function parseArgs(argv) {
+    const result = {
+        command: 'help',
+        args: [],
+        options: {}
+    };
+    let i = 0;
+    let foundCommand = false;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg.startsWith('--')) {
+            // Long flag
+            const flagName = arg.slice(2);
+            const nextArg = argv[i + 1];
+            // Check if it's a boolean flag or has a value
+            if (!nextArg || nextArg.startsWith('-')) {
+                result.options[flagName] = true;
+            }
+            else {
+                result.options[flagName] = nextArg;
+                i++;
+            }
+        }
+        else if (arg.startsWith('-') && arg.length === 2) {
+            // Short flag
+            const shortFlag = arg.slice(1);
+            const nextArg = argv[i + 1];
+            // Find the corresponding long flag name from global flags and command-specific flags
+            const globalFlag = cli_spec_1.GLOBAL_FLAGS.find(f => f.short === shortFlag);
+            // Also check command-specific flags (e.g., -m for model in chat command)
+            const commandShortFlags = {
+                'm': 'model',
+                's': 'stream',
+                'a': 'agent',
+                't': 'tools'
+            };
+            const flagName = globalFlag?.name || commandShortFlags[shortFlag] || shortFlag;
+            if (!nextArg || nextArg.startsWith('-')) {
+                result.options[flagName] = true;
+            }
+            else {
+                result.options[flagName] = nextArg;
+                i++;
+            }
+        }
+        else if (!foundCommand) {
+            // First non-flag argument is the command
+            result.command = arg;
+            foundCommand = true;
+        }
+        else if (!result.subcommand && cli_spec_1.COMMANDS[result.command]?.subcommands) {
+            // Check if this is a subcommand
+            const cmdSpec = cli_spec_1.COMMANDS[result.command];
+            if (cmdSpec.subcommands && arg in cmdSpec.subcommands) {
+                result.subcommand = arg;
+            }
+            else {
+                result.args.push(arg);
+            }
+        }
+        else {
+            // Positional argument
+            result.args.push(arg);
+        }
+        i++;
+    }
+    // Handle --json shorthand
+    if (result.options.json) {
+        result.options.output = 'json';
+    }
+    return result;
+}
+/**
+ * Load and execute a command (lazy loading)
+ */
+async function executeCommand(parsed) {
+    const { command, subcommand, args, options } = parsed;
+    // Validate command exists
+    if (!(0, cli_spec_1.validateCommand)(command)) {
+        const isJson = options.output === 'json' || options.json;
+        if (isJson) {
+            outputJson(formatError(ERROR_CODES.INVALID_ARGS, `Unknown command: ${command}`));
+        }
+        else {
+            console.error(`Error: Unknown command '${command}'`);
+            console.error('Run "praisonai-ts help" for available commands');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    // Lazy load the command module
+    try {
+        const commandModule = await Promise.resolve(`${`./commands/${command}`}`).then(s => __importStar(require(s)));
+        // Pass subcommand as first arg if present
+        const commandArgs = subcommand ? [subcommand, ...args] : args;
+        await commandModule.execute(commandArgs, options);
+    }
+    catch (error) {
+        const cliError = normalizeError(error);
+        const isJson = options.output === 'json' || options.json;
+        if (isJson) {
+            outputJson(formatError(cliError.code, cliError.message, cliError.details));
+        }
+        else {
+            console.error(`Error: ${cliError.message}`);
+            if (options.verbose && error instanceof Error && error.stack) {
+                console.error(error.stack);
+            }
+        }
+        process.exit(cliError.exitCode);
+    }
+}
+/**
+ * Main CLI entry point
+ */
+async function main() {
+    const argv = process.argv.slice(2);
+    // Fast path for version
+    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
+        const helpModule = await Promise.resolve().then(() => __importStar(require('./commands/help')));
+        await helpModule.execute([], {});
+        return;
+    }
+    if (argv[0] === '--version') {
+        const versionModule = await Promise.resolve().then(() => __importStar(require('./commands/version')));
+        await versionModule.execute([], {});
+        return;
+    }
+    const parsed = parseArgs(argv);
+    await executeCommand(parsed);
+}
+// Run CLI if executed directly
+if (require.main === module) {
+    main().catch((error) => {
+        console.error('Fatal error:', error.message);
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    });
+}

package/dist/cli/output/errors.d.ts

@@ -0,0 +1,23 @@
+export declare const ERROR_CODES: {
+    INVALID_ARGS: string;
+    MISSING_ARG: string;
+    UNKNOWN_ERROR: string;
+    RUNTIME_ERROR: string;
+    CONFIG_ERROR: string;
+    NOT_FOUND: string;
+    UNAUTHORIZED: string;
+    RATE_LIMIT: string;
+    SERVER_ERROR: string;
+    TIMEOUT: string;
+    ABORTED: string;
+    PROVIDER_ERROR: string;
+    MODEL_ERROR: string;
+    TOOL_ERROR: string;
+    UNKNOWN: string;
+};
+export declare function normalizeError(error: unknown): {
+    code: string;
+    message: string;
+    exitCode: number;
+    details?: any;
+};

package/dist/cli/output/errors.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_CODES = void 0;
+exports.normalizeError = normalizeError;
+const cli_spec_1 = require("../spec/cli-spec");
+exports.ERROR_CODES = {
+    INVALID_ARGS: 'INVALID_ARGS',
+    MISSING_ARG: 'MISSING_ARG',
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+    RUNTIME_ERROR: 'RUNTIME_ERROR',
+    CONFIG_ERROR: 'CONFIG_ERROR',
+    NOT_FOUND: 'NOT_FOUND',
+    UNAUTHORIZED: 'UNAUTHORIZED',
+    RATE_LIMIT: 'RATE_LIMIT',
+    SERVER_ERROR: 'SERVER_ERROR',
+    TIMEOUT: 'TIMEOUT',
+    ABORTED: 'ABORTED',
+    PROVIDER_ERROR: 'PROVIDER_ERROR',
+    MODEL_ERROR: 'MODEL_ERROR',
+    TOOL_ERROR: 'TOOL_ERROR',
+    UNKNOWN: 'UNKNOWN_ERROR', // Alias for UNKNOWN_ERROR
+};
+function normalizeError(error) {
+    if (error && typeof error === 'object') {
+        const anyErr = error;
+        const code = anyErr.code || exports.ERROR_CODES.UNKNOWN_ERROR;
+        const message = anyErr.message || String(error);
+        const exitCode = typeof anyErr.exitCode === 'number' ? anyErr.exitCode : cli_spec_1.EXIT_CODES.RUNTIME_ERROR;
+        const details = anyErr.details;
+        return { code, message, exitCode, details };
+    }
+    if (error instanceof Error) {
+        return { code: exports.ERROR_CODES.UNKNOWN_ERROR, message: error.message, exitCode: cli_spec_1.EXIT_CODES.RUNTIME_ERROR, details: { stack: error.stack } };
+    }
+    return { code: exports.ERROR_CODES.UNKNOWN_ERROR, message: String(error), exitCode: cli_spec_1.EXIT_CODES.RUNTIME_ERROR };
+}

package/dist/cli/output/json.d.ts

@@ -0,0 +1,27 @@
+export declare function outputJson(data: any): void;
+export declare function formatSuccess(data: any, meta?: any): {
+    success: boolean;
+    data: any;
+    meta: any;
+} | {
+    success: boolean;
+    data: any;
+    meta?: undefined;
+};
+export declare function formatError(code: string, message: string, details?: any): {
+    success: boolean;
+    error: {
+        code: string;
+        message: string;
+    };
+    details: any;
+} | {
+    success: boolean;
+    error: {
+        code: string;
+        message: string;
+    };
+    details?: undefined;
+};
+export declare function printSuccess(message: string): void;
+export declare function printError(message: string, details?: string): void;

package/dist/cli/output/json.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputJson = outputJson;
+exports.formatSuccess = formatSuccess;
+exports.formatError = formatError;
+exports.printSuccess = printSuccess;
+exports.printError = printError;
+function outputJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+function formatSuccess(data, meta) {
+    return meta
+        ? { success: true, data, meta }
+        : { success: true, data };
+}
+function formatError(code, message, details) {
+    return details !== undefined
+        ? { success: false, error: { code, message }, details }
+        : { success: false, error: { code, message } };
+}
+function printSuccess(message) {
+    console.log(JSON.stringify({ success: true, message }));
+}
+function printError(message, details) {
+    if (details) {
+        console.error(JSON.stringify({ success: false, error: message, details }));
+    }
+    else {
+        console.error(JSON.stringify({ success: false, error: message }));
+    }
+}

package/dist/cli/output/pretty.d.ts

@@ -0,0 +1,13 @@
+import { PrettyLogger } from '../../utils/pretty-logger';
+export declare const success: typeof PrettyLogger.success;
+export declare const error: typeof PrettyLogger.error;
+export declare const info: typeof PrettyLogger.info;
+export declare const warn: typeof PrettyLogger.warning;
+export declare const warning: typeof PrettyLogger.warning;
+export declare const dim: (s: string) => Promise<void>;
+export declare const plain: (s: string) => Promise<void>;
+export declare const heading: (s: string) => Promise<void>;
+export declare const newline: () => Promise<void>;
+export declare const table: (data: any[]) => Promise<void>;
+export declare const box: (title: string, content: string) => Promise<void>;
+export declare const keyValue: (obj: Record<string, any>) => Promise<void>;

package/dist/cli/output/pretty.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyValue = exports.box = exports.table = exports.newline = exports.heading = exports.plain = exports.dim = exports.warning = exports.warn = exports.info = exports.error = exports.success = void 0;
+const pretty_logger_1 = require("../../utils/pretty-logger");
+exports.success = pretty_logger_1.PrettyLogger.success;
+exports.error = pretty_logger_1.PrettyLogger.error;
+exports.info = pretty_logger_1.PrettyLogger.info;
+exports.warn = pretty_logger_1.PrettyLogger.warning;
+exports.warning = pretty_logger_1.PrettyLogger.warning;
+const dim = async (s) => console.log(s);
+exports.dim = dim;
+const plain = async (s) => console.log(s);
+exports.plain = plain;
+const heading = async (s) => console.log(s);
+exports.heading = heading;
+const newline = async () => console.log();
+exports.newline = newline;
+const table = async (data) => console.table(data);
+exports.table = table;
+const box = async (title, content) => {
+    console.log(`┌─ ${title} ${'─'.repeat(50 - title.length)}┐`);
+    console.log(`│ ${content}`);
+    console.log(`└${'─'.repeat(53)}┘`);
+};
+exports.box = box;
+const keyValue = async (obj) => {
+    for (const [key, value] of Object.entries(obj)) {
+        console.log(`${key}: ${value}`);
+    }
+};
+exports.keyValue = keyValue;

package/dist/cli/runtime/env.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Environment variable handling for CLI
+ */
+export interface EnvConfig {
+    model?: string;
+    profile?: string;
+    verbose?: boolean;
+    configPath?: string;
+}
+export declare function loadEnvConfig(): EnvConfig;
+export declare function hasApiKey(provider: string): boolean;
+export declare function getApiKey(provider: 'openai' | 'anthropic' | 'google'): string | undefined;

package/dist/cli/runtime/env.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Environment variable handling for CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnvConfig = loadEnvConfig;
+exports.hasApiKey = hasApiKey;
+exports.getApiKey = getApiKey;
+const cli_spec_1 = require("../spec/cli-spec");
+function loadEnvConfig() {
+    const config = {};
+    const model = process.env[cli_spec_1.ENV_VARS.PRAISONAI_MODEL];
+    if (model)
+        config.model = model;
+    const profile = process.env[cli_spec_1.ENV_VARS.PRAISONAI_PROFILE];
+    if (profile)
+        config.profile = profile;
+    const verbose = process.env[cli_spec_1.ENV_VARS.PRAISONAI_VERBOSE];
+    if (verbose)
+        config.verbose = verbose.toLowerCase() === 'true';
+    const configPath = process.env[cli_spec_1.ENV_VARS.PRAISONAI_CONFIG];
+    if (configPath)
+        config.configPath = configPath;
+    return config;
+}
+function hasApiKey(provider) {
+    const normalizedProvider = provider.toLowerCase();
+    switch (normalizedProvider) {
+        case 'openai':
+        case 'oai':
+            return !!process.env[cli_spec_1.ENV_VARS.OPENAI_API_KEY];
+        case 'anthropic':
+        case 'claude':
+            return !!process.env[cli_spec_1.ENV_VARS.ANTHROPIC_API_KEY];
+        case 'google':
+        case 'gemini':
+            return !!process.env[cli_spec_1.ENV_VARS.GOOGLE_API_KEY];
+        default:
+            // For custom providers, check for provider-specific env var
+            const envVarName = `${normalizedProvider.toUpperCase()}_API_KEY`;
+            return !!process.env[envVarName];
+    }
+}
+function getApiKey(provider) {
+    switch (provider) {
+        case 'openai':
+            return process.env[cli_spec_1.ENV_VARS.OPENAI_API_KEY];
+        case 'anthropic':
+            return process.env[cli_spec_1.ENV_VARS.ANTHROPIC_API_KEY];
+        case 'google':
+            return process.env[cli_spec_1.ENV_VARS.GOOGLE_API_KEY];
+        default:
+            return undefined;
+    }
+}

package/dist/cli/runtime/exit.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Exit code handling for CLI
+ */
+import { ExitCode } from '../spec/cli-spec';
+export declare function exit(code: ExitCode): never;
+export declare function exitSuccess(): never;
+export declare function exitError(message?: string): never;
+export declare function exitInvalidArgs(message?: string): never;
+export declare function exitConfigError(message?: string): never;
+export declare function exitNetworkError(message?: string): never;
+export declare function exitAuthError(message?: string): never;

package/dist/cli/runtime/exit.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Exit code handling for CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exit = exit;
+exports.exitSuccess = exitSuccess;
+exports.exitError = exitError;
+exports.exitInvalidArgs = exitInvalidArgs;
+exports.exitConfigError = exitConfigError;
+exports.exitNetworkError = exitNetworkError;
+exports.exitAuthError = exitAuthError;
+const cli_spec_1 = require("../spec/cli-spec");
+function exit(code) {
+    process.exit(code);
+}
+function exitSuccess() {
+    exit(cli_spec_1.EXIT_CODES.SUCCESS);
+}
+function exitError(message) {
+    if (message) {
+        console.error(message);
+    }
+    exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+}
+function exitInvalidArgs(message) {
+    if (message) {
+        console.error(`Error: ${message}`);
+    }
+    exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+}
+function exitConfigError(message) {
+    if (message) {
+        console.error(`Config Error: ${message}`);
+    }
+    exit(cli_spec_1.EXIT_CODES.CONFIG_ERROR);
+}
+function exitNetworkError(message) {
+    if (message) {
+        console.error(`Network Error: ${message}`);
+    }
+    exit(cli_spec_1.EXIT_CODES.NETWORK_ERROR);
+}
+function exitAuthError(message) {
+    if (message) {
+        console.error(`Auth Error: ${message}`);
+    }
+    exit(cli_spec_1.EXIT_CODES.AUTH_ERROR);
+}

package/dist/cli/runtime/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runtime utilities index
+ */
+export * from './env';
+export * from './exit';
+export * from './lazy';

package/dist/cli/runtime/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Runtime utilities index
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./env"), exports);
+__exportStar(require("./exit"), exports);
+__exportStar(require("./lazy"), exports);

package/dist/cli/runtime/lazy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lazy loading utilities for CLI commands
+ * Ensures startup time stays <100ms by only loading command code when invoked
+ */
+export type CommandModule = {
+    execute: (args: string[], options: Record<string, unknown>) => Promise<void>;
+};
+export declare function loadCommand(command: string): Promise<CommandModule>;
+export declare function clearCommandCache(): void;
+/**
+ * Lazy load optional dependencies
+ * Returns undefined if not available
+ */
+export declare function tryLoadOptional<T>(moduleName: string): Promise<T | undefined>;
+/**
+ * Check if an optional dependency is available
+ */
+export declare function hasOptionalDep(moduleName: string): Promise<boolean>;

package/dist/cli/runtime/lazy.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Lazy loading utilities for CLI commands
+ * Ensures startup time stays <100ms by only loading command code when invoked
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCommand = loadCommand;
+exports.clearCommandCache = clearCommandCache;
+exports.tryLoadOptional = tryLoadOptional;
+exports.hasOptionalDep = hasOptionalDep;
+const cli_spec_1 = require("../spec/cli-spec");
+const commandCache = new Map();
+async function loadCommand(command) {
+    if (!(0, cli_spec_1.validateCommand)(command)) {
+        throw new Error(`Unknown command: ${command}`);
+    }
+    // Check cache first
+    if (commandCache.has(command)) {
+        return commandCache.get(command);
+    }
+    // Lazy import the command module
+    const module = await Promise.resolve(`${`../commands/${command}`}`).then(s => __importStar(require(s)));
+    commandCache.set(command, module);
+    return module;
+}
+function clearCommandCache() {
+    commandCache.clear();
+}
+/**
+ * Lazy load optional dependencies
+ * Returns undefined if not available
+ */
+async function tryLoadOptional(moduleName) {
+    try {
+        return await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Check if an optional dependency is available
+ */
+async function hasOptionalDep(moduleName) {
+    try {
+        await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}