praisonai 1.2.2 → 1.2.4

package/dist/cli/output/pretty.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Pretty output formatting for CLI
+ * Uses optional dependencies (chalk, boxen, ora) with fallbacks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.success = success;
+exports.error = error;
+exports.warn = warn;
+exports.info = info;
+exports.heading = heading;
+exports.dim = dim;
+exports.highlight = highlight;
+exports.plain = plain;
+exports.newline = newline;
+exports.table = table;
+exports.keyValue = keyValue;
+const lazy_1 = require("../runtime/lazy");
+let chalkInstance = null;
+let chalkLoaded = false;
+async function getChalk() {
+    if (chalkLoaded)
+        return chalkInstance;
+    chalkLoaded = true;
+    try {
+        const chalk = await (0, lazy_1.tryLoadOptional)('chalk');
+        chalkInstance = chalk?.default || null;
+    }
+    catch {
+        chalkInstance = null;
+    }
+    return chalkInstance;
+}
+// Fallback functions when chalk is not available
+const noColor = (s) => s;
+async function success(message) {
+    const chalk = await getChalk();
+    const prefix = chalk ? chalk.green('✓') : '✓';
+    console.log(`${prefix} ${message}`);
+}
+async function error(message) {
+    const chalk = await getChalk();
+    const prefix = chalk ? chalk.red('✗') : '✗';
+    console.error(`${prefix} ${message}`);
+}
+async function warn(message) {
+    const chalk = await getChalk();
+    const prefix = chalk ? chalk.yellow('⚠') : '⚠';
+    console.warn(`${prefix} ${message}`);
+}
+async function info(message) {
+    const chalk = await getChalk();
+    const prefix = chalk ? chalk.blue('ℹ') : 'ℹ';
+    console.log(`${prefix} ${message}`);
+}
+async function heading(message) {
+    const chalk = await getChalk();
+    const text = chalk ? chalk.bold(message) : message;
+    console.log(`\n${text}\n`);
+}
+async function dim(message) {
+    const chalk = await getChalk();
+    const text = chalk ? chalk.gray(message) : message;
+    console.log(text);
+}
+async function highlight(message) {
+    const chalk = await getChalk();
+    const text = chalk ? chalk.cyan(message) : message;
+    console.log(text);
+}
+function plain(message) {
+    console.log(message);
+}
+function newline() {
+    console.log();
+}
+/**
+ * Print a table (simple ASCII fallback)
+ */
+function table(headers, rows) {
+    // Calculate column widths
+    const widths = headers.map((h, i) => {
+        const maxRowWidth = Math.max(...rows.map(r => (r[i] || '').length));
+        return Math.max(h.length, maxRowWidth);
+    });
+    // Print header
+    const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join('  ');
+    console.log(headerLine);
+    console.log('-'.repeat(headerLine.length));
+    // Print rows
+    for (const row of rows) {
+        const line = row.map((cell, i) => (cell || '').padEnd(widths[i])).join('  ');
+        console.log(line);
+    }
+}
+/**
+ * Print a key-value list
+ */
+async function keyValue(items) {
+    const chalk = await getChalk();
+    const maxKeyLen = Math.max(...Object.keys(items).map(k => k.length));
+    for (const [key, value] of Object.entries(items)) {
+        const keyStr = chalk ? chalk.cyan(key.padEnd(maxKeyLen)) : key.padEnd(maxKeyLen);
+        console.log(`  ${keyStr}  ${value}`);
+    }
+}

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: 'openai' | 'anthropic' | 'google'): boolean;
+export declare function getApiKey(provider: 'openai' | 'anthropic' | 'google'): string | undefined;

package/dist/cli/runtime/env.js

@@ -0,0 +1,49 @@
+"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) {
+    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 false;
+    }
+}
+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;
+    }
+}

package/dist/cli/spec/cli-spec.d.ts

@@ -0,0 +1,87 @@
+/**
+ * PraisonAI CLI Specification - TypeScript Runtime
+ * Parsed and validated spec from cli-spec.v1.yaml
+ */
+export declare const CLI_SPEC_VERSION = "1.0.0";
+export interface CommandArg {
+    name: string;
+    type: 'string' | 'integer' | 'boolean';
+    required: boolean;
+    position?: number;
+    description?: string;
+}
+export interface CommandFlag {
+    name: string;
+    short?: string;
+    type: 'string' | 'integer' | 'boolean';
+    default?: string | number | boolean;
+    enum?: string[];
+    description?: string;
+    required?: boolean;
+}
+export interface Subcommand {
+    description: string;
+    args?: CommandArg[];
+    flags?: CommandFlag[];
+}
+export interface Command {
+    description: string;
+    args?: CommandArg[];
+    flags?: CommandFlag[];
+    subcommands?: Record<string, Subcommand>;
+}
+export declare const COMMANDS: Record<string, Command>;
+export declare const GLOBAL_FLAGS: CommandFlag[];
+export declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly RUNTIME_ERROR: 1;
+    readonly INVALID_ARGUMENTS: 2;
+    readonly CONFIG_ERROR: 3;
+    readonly NETWORK_ERROR: 4;
+    readonly AUTH_ERROR: 5;
+};
+export type ExitCode = typeof EXIT_CODES[keyof typeof EXIT_CODES];
+export interface SuccessOutput<T = unknown> {
+    success: true;
+    data: T;
+    meta?: {
+        duration_ms?: number;
+        model?: string;
+        tokens?: {
+            input?: number;
+            output?: number;
+        };
+    };
+}
+export interface ErrorOutput {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+export type CLIOutput<T = unknown> = SuccessOutput<T> | ErrorOutput;
+export declare const ENV_VARS: {
+    readonly PRAISONAI_MODEL: "PRAISONAI_MODEL";
+    readonly PRAISONAI_PROFILE: "PRAISONAI_PROFILE";
+    readonly PRAISONAI_VERBOSE: "PRAISONAI_VERBOSE";
+    readonly PRAISONAI_CONFIG: "PRAISONAI_CONFIG";
+    readonly OPENAI_API_KEY: "OPENAI_API_KEY";
+    readonly ANTHROPIC_API_KEY: "ANTHROPIC_API_KEY";
+    readonly GOOGLE_API_KEY: "GOOGLE_API_KEY";
+};
+export declare const CONFIG_FILES: readonly [".praisonai.yaml", ".praisonai.json"];
+export interface ConfigSchema {
+    model?: string;
+    verbose?: boolean;
+    stream?: boolean;
+    profiles?: Record<string, {
+        model?: string;
+        verbose?: boolean;
+        stream?: boolean;
+    }>;
+}
+export declare function validateCommand(command: string): command is keyof typeof COMMANDS;
+export declare function getCommandSpec(command: string): Command | undefined;
+export declare function getAllFlags(command: string): CommandFlag[];