praisonai 1.2.2 → 1.2.3

package/dist/cli/index.d.ts

@@ -1,20 +1,24 @@
 #!/usr/bin/env node
 /**
  * PraisonAI TypeScript CLI
+ * Implements CLI Spec v1.0.0
+ *
+ * Binary: praisonai-ts
+ * Package: praisonai (npm)
  */
-interface CLIOptions {
-    model?: string;
-    stream?: boolean;
-    verbose?: boolean;
-    sessionId?: string;
-}
-declare function chat(prompt: string, options?: CLIOptions): Promise<string>;
-declare function listProviders(): Promise<void>;
-declare function version(): Promise<void>;
-declare function help(): Promise<void>;
-declare function parseArgs(args: string[]): {
+import { CLI_SPEC_VERSION } from './spec/cli-spec';
+export interface ParsedArgs {
     command: string;
-    prompt: string;
-    options: CLIOptions;
-};
-export { chat, listProviders, version, help, parseArgs };
+    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

@@ -2,149 +2,189 @@
 "use strict";
 /**
  * PraisonAI TypeScript CLI
+ * Implements CLI Spec v1.0.0
+ *
+ * Binary: praisonai-ts
+ * Package: praisonai (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.chat = chat;
-exports.listProviders = listProviders;
-exports.version = version;
-exports.help = help;
+exports.CLI_SPEC_VERSION = void 0;
 exports.parseArgs = parseArgs;
-const providers_1 = require("../llm/providers");
-const session_1 = require("../session");
-async function chat(prompt, options = {}) {
-    const model = options.model || process.env.PRAISONAI_MODEL || 'openai/gpt-4o-mini';
-    const provider = (0, providers_1.createProvider)(model);
-    const session = new session_1.Session({ id: options.sessionId });
-    session.addMessage({ role: 'user', content: prompt });
-    if (options.stream) {
-        let fullText = '';
-        const stream = await provider.streamText({
-            messages: [{ role: 'user', content: prompt }],
-            onToken: (token) => {
-                process.stdout.write(token);
-                fullText += token;
-            }
-        });
-        for await (const chunk of stream) {
-            // Stream is consumed by onToken
-        }
-        console.log(); // New line after streaming
-        return fullText;
-    }
-    else {
-        const result = await provider.generateText({
-            messages: [{ role: 'user', content: prompt }]
-        });
-        console.log(result.text);
-        return result.text;
-    }
-}
-async function listProviders() {
-    console.log('Available Providers:');
-    const available = (0, providers_1.getAvailableProviders)();
-    const providers = ['openai', 'anthropic', 'google'];
-    for (const p of providers) {
-        const status = available.includes(p) ? '✅' : '❌';
-        console.log(`  ${status} ${p}`);
-    }
-}
-async function version() {
-    const pkg = require('../../package.json');
-    console.log(`praisonai v${pkg.version}`);
-}
-async function help() {
-    console.log(`
-PraisonAI TypeScript CLI
-
-Usage:
-  praisonai-ts chat <prompt>     Chat with an AI agent
-  praisonai-ts providers         List available providers
-  praisonai-ts version           Show version
-  praisonai-ts help              Show this help
-
-Options:
-  --model, -m <model>     Model to use (e.g., openai/gpt-4o-mini)
-  --stream, -s            Enable streaming output
-  --verbose, -v           Verbose output
-  --session <id>          Session ID for conversation continuity
-
-Environment Variables:
-  OPENAI_API_KEY          OpenAI API key
-  ANTHROPIC_API_KEY       Anthropic API key
-  GOOGLE_API_KEY          Google API key
-  PRAISONAI_MODEL         Default model
-
-Examples:
-  praisonai-ts chat "Hello, how are you?"
-  praisonai-ts chat "Write a poem" --stream
-  praisonai-ts chat "Explain AI" -m anthropic/claude-sonnet-4-20250514
-  praisonai-ts providers
-`);
-}
-function parseArgs(args) {
-    const options = {};
-    let command = 'help';
-    let prompt = '';
+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; } });
+const json_1 = require("./output/json");
+const errors_1 = require("./output/errors");
+/**
+ * Parse command line arguments according to CLI spec
+ */
+function parseArgs(argv) {
+    const result = {
+        command: 'help',
+        args: [],
+        options: {}
+    };
     let i = 0;
-    while (i < args.length) {
-        const arg = args[i];
-        if (arg === '--model' || arg === '-m') {
-            options.model = args[++i];
-        }
-        else if (arg === '--stream' || arg === '-s') {
-            options.stream = true;
+    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 === '--verbose' || arg === '-v') {
-            options.verbose = true;
+        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 (arg === '--session') {
-            options.sessionId = args[++i];
+        else if (!foundCommand) {
+            // First non-flag argument is the command
+            result.command = arg;
+            foundCommand = true;
         }
-        else if (!arg.startsWith('-')) {
-            if (!command || command === 'help') {
-                command = arg;
+        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 {
-                prompt = arg;
+                result.args.push(arg);
             }
         }
+        else {
+            // Positional argument
+            result.args.push(arg);
+        }
         i++;
     }
-    return { command, prompt, options };
+    // Handle --json shorthand
+    if (result.options.json) {
+        result.options.output = 'json';
+    }
+    return result;
 }
-async function main() {
-    const args = process.argv.slice(2);
-    const { command, prompt, options } = parseArgs(args);
-    try {
-        switch (command) {
-            case 'chat':
-                if (!prompt) {
-                    console.error('Error: Please provide a prompt');
-                    process.exit(1);
-                }
-                await chat(prompt, options);
-                break;
-            case 'providers':
-                await listProviders();
-                break;
-            case 'version':
-                await version();
-                break;
-            case 'help':
-            default:
-                await help();
-                break;
+/**
+ * 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) {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.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) {
-        console.error('Error:', error.message);
-        if (options.verbose) {
-            console.error(error.stack);
+        const cliError = (0, errors_1.normalizeError)(error);
+        const isJson = options.output === 'json' || options.json;
+        if (isJson) {
+            (0, json_1.outputJson)((0, json_1.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(1);
+        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();
+    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,32 @@
+/**
+ * Error normalization for CLI
+ * Ensures consistent error codes and messages across implementations
+ */
+export declare const ERROR_CODES: {
+    readonly UNKNOWN: "UNKNOWN_ERROR";
+    readonly INVALID_ARGS: "INVALID_ARGUMENTS";
+    readonly MISSING_ARG: "MISSING_ARGUMENT";
+    readonly INVALID_FLAG: "INVALID_FLAG";
+    readonly CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND";
+    readonly CONFIG_PARSE_ERROR: "CONFIG_PARSE_ERROR";
+    readonly INVALID_PROFILE: "INVALID_PROFILE";
+    readonly MISSING_API_KEY: "MISSING_API_KEY";
+    readonly INVALID_API_KEY: "INVALID_API_KEY";
+    readonly NETWORK_TIMEOUT: "NETWORK_TIMEOUT";
+    readonly NETWORK_UNREACHABLE: "NETWORK_UNREACHABLE";
+    readonly PROVIDER_ERROR: "PROVIDER_ERROR";
+    readonly MODEL_NOT_FOUND: "MODEL_NOT_FOUND";
+    readonly TOOL_NOT_FOUND: "TOOL_NOT_FOUND";
+    readonly WORKFLOW_ERROR: "WORKFLOW_ERROR";
+    readonly AGENT_ERROR: "AGENT_ERROR";
+};
+export type ErrorCode = typeof ERROR_CODES[keyof typeof ERROR_CODES];
+export interface CLIError extends Error {
+    code: ErrorCode;
+    exitCode: number;
+    details?: Record<string, unknown>;
+}
+export declare function createError(code: ErrorCode, message: string, exitCode?: number, details?: Record<string, unknown>): CLIError;
+export declare function isCLIError(error: unknown): error is CLIError;
+export declare function normalizeError(error: unknown): CLIError;
+export declare function formatCLIError(error: CLIError): import("../spec/cli-spec").ErrorOutput;

package/dist/cli/output/errors.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Error normalization for CLI
+ * Ensures consistent error codes and messages across implementations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_CODES = void 0;
+exports.createError = createError;
+exports.isCLIError = isCLIError;
+exports.normalizeError = normalizeError;
+exports.formatCLIError = formatCLIError;
+const cli_spec_1 = require("../spec/cli-spec");
+const json_1 = require("./json");
+exports.ERROR_CODES = {
+    // General errors
+    UNKNOWN: 'UNKNOWN_ERROR',
+    INVALID_ARGS: 'INVALID_ARGUMENTS',
+    MISSING_ARG: 'MISSING_ARGUMENT',
+    INVALID_FLAG: 'INVALID_FLAG',
+    // Config errors
+    CONFIG_NOT_FOUND: 'CONFIG_NOT_FOUND',
+    CONFIG_PARSE_ERROR: 'CONFIG_PARSE_ERROR',
+    INVALID_PROFILE: 'INVALID_PROFILE',
+    // Auth errors
+    MISSING_API_KEY: 'MISSING_API_KEY',
+    INVALID_API_KEY: 'INVALID_API_KEY',
+    // Network errors
+    NETWORK_TIMEOUT: 'NETWORK_TIMEOUT',
+    NETWORK_UNREACHABLE: 'NETWORK_UNREACHABLE',
+    // Runtime errors
+    PROVIDER_ERROR: 'PROVIDER_ERROR',
+    MODEL_NOT_FOUND: 'MODEL_NOT_FOUND',
+    TOOL_NOT_FOUND: 'TOOL_NOT_FOUND',
+    WORKFLOW_ERROR: 'WORKFLOW_ERROR',
+    AGENT_ERROR: 'AGENT_ERROR'
+};
+function createError(code, message, exitCode = cli_spec_1.EXIT_CODES.RUNTIME_ERROR, details) {
+    const error = new Error(message);
+    error.code = code;
+    error.exitCode = exitCode;
+    error.details = details;
+    return error;
+}
+function isCLIError(error) {
+    return error instanceof Error && 'code' in error && 'exitCode' in error;
+}
+function normalizeError(error) {
+    if (isCLIError(error)) {
+        return error;
+    }
+    if (error instanceof Error) {
+        // Try to categorize common errors
+        const message = error.message.toLowerCase();
+        if (message.includes('api key') || message.includes('unauthorized') || message.includes('401')) {
+            return createError(exports.ERROR_CODES.MISSING_API_KEY, error.message, cli_spec_1.EXIT_CODES.AUTH_ERROR);
+        }
+        if (message.includes('timeout') || message.includes('timed out')) {
+            return createError(exports.ERROR_CODES.NETWORK_TIMEOUT, error.message, cli_spec_1.EXIT_CODES.NETWORK_ERROR);
+        }
+        if (message.includes('network') || message.includes('econnrefused') || message.includes('enotfound')) {
+            return createError(exports.ERROR_CODES.NETWORK_UNREACHABLE, error.message, cli_spec_1.EXIT_CODES.NETWORK_ERROR);
+        }
+        if (message.includes('config') || message.includes('configuration')) {
+            return createError(exports.ERROR_CODES.CONFIG_PARSE_ERROR, error.message, cli_spec_1.EXIT_CODES.CONFIG_ERROR);
+        }
+        return createError(exports.ERROR_CODES.UNKNOWN, error.message);
+    }
+    return createError(exports.ERROR_CODES.UNKNOWN, String(error));
+}
+function formatCLIError(error) {
+    return (0, json_1.formatError)(error.code, error.message, error.details);
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Output utilities index
+ */
+export * from './json';
+export * from './pretty';
+export * from './errors';

package/dist/cli/output/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Output 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("./json"), exports);
+__exportStar(require("./pretty"), exports);
+__exportStar(require("./errors"), exports);

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

@@ -0,0 +1,17 @@
+/**
+ * JSON output formatting for CLI
+ * Ensures byte-compatible output with Python CLI
+ */
+import { CLIOutput, SuccessOutput, ErrorOutput } from '../spec/cli-spec';
+export declare function formatSuccess<T>(data: T, meta?: SuccessOutput<T>['meta']): SuccessOutput<T>;
+export declare function formatError(code: string, message: string, details?: Record<string, unknown>): ErrorOutput;
+export declare function outputJson<T>(output: CLIOutput<T>): void;
+export declare function outputJsonCompact<T>(output: CLIOutput<T>): void;
+/**
+ * Create a success response and output it
+ */
+export declare function printSuccess<T>(data: T, meta?: SuccessOutput<T>['meta']): void;
+/**
+ * Create an error response and output it
+ */
+export declare function printError(code: string, message: string, details?: Record<string, unknown>): void;

package/dist/cli/output/json.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * JSON output formatting for CLI
+ * Ensures byte-compatible output with Python CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSuccess = formatSuccess;
+exports.formatError = formatError;
+exports.outputJson = outputJson;
+exports.outputJsonCompact = outputJsonCompact;
+exports.printSuccess = printSuccess;
+exports.printError = printError;
+function formatSuccess(data, meta) {
+    const output = {
+        success: true,
+        data
+    };
+    if (meta) {
+        output.meta = meta;
+    }
+    return output;
+}
+function formatError(code, message, details) {
+    const output = {
+        success: false,
+        error: {
+            code,
+            message
+        }
+    };
+    if (details) {
+        output.error.details = details;
+    }
+    return output;
+}
+function outputJson(output) {
+    // Use 2-space indentation for readability (matches Python json.dumps default)
+    console.log(JSON.stringify(output, null, 2));
+}
+function outputJsonCompact(output) {
+    console.log(JSON.stringify(output));
+}
+/**
+ * Create a success response and output it
+ */
+function printSuccess(data, meta) {
+    outputJson(formatSuccess(data, meta));
+}
+/**
+ * Create an error response and output it
+ */
+function printError(code, message, details) {
+    outputJson(formatError(code, message, details));
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Pretty output formatting for CLI
+ * Uses optional dependencies (chalk, boxen, ora) with fallbacks
+ */
+export declare function success(message: string): Promise<void>;
+export declare function error(message: string): Promise<void>;
+export declare function warn(message: string): Promise<void>;
+export declare function info(message: string): Promise<void>;
+export declare function heading(message: string): Promise<void>;
+export declare function dim(message: string): Promise<void>;
+export declare function highlight(message: string): Promise<void>;
+export declare function plain(message: string): void;
+export declare function newline(): void;
+/**
+ * Print a table (simple ASCII fallback)
+ */
+export declare function table(headers: string[], rows: string[][]): void;
+/**
+ * Print a key-value list
+ */
+export declare function keyValue(items: Record<string, string | number | boolean>): Promise<void>;