praisonai 1.2.2 → 1.2.3

package/dist/cli/commands/workflow.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Workflow command - Execute a multi-agent workflow
+ */
+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.execute = execute;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const resolve_1 = require("../config/resolve");
+const json_1 = require("../output/json");
+const pretty = __importStar(require("../output/pretty"));
+const cli_spec_1 = require("../spec/cli-spec");
+const errors_1 = require("../output/errors");
+/**
+ * Simple YAML parser for workflow files
+ */
+function parseWorkflowYaml(content) {
+    const result = {};
+    const lines = content.split('\n');
+    let currentSection = null;
+    let currentItem = null;
+    let currentKey = null;
+    for (const line of lines) {
+        if (!line.trim() || line.trim().startsWith('#'))
+            continue;
+        const indent = line.search(/\S/);
+        const trimmed = line.trim();
+        // Top-level keys
+        if (indent === 0 && trimmed.includes(':')) {
+            const colonIdx = trimmed.indexOf(':');
+            const key = trimmed.slice(0, colonIdx).trim();
+            const value = trimmed.slice(colonIdx + 1).trim();
+            if (value) {
+                result[key] = value;
+            }
+            else {
+                currentSection = key;
+                if (key === 'agents')
+                    result.agents = {};
+                if (key === 'steps')
+                    result.steps = [];
+            }
+        }
+        else if (indent > 0 && currentSection) {
+            // Handle list items (steps)
+            if (trimmed.startsWith('- ')) {
+                if (currentSection === 'steps') {
+                    currentItem = {};
+                    result.steps.push(currentItem);
+                    // Parse inline values after -
+                    const afterDash = trimmed.slice(2).trim();
+                    if (afterDash.includes(':')) {
+                        const colonIdx = afterDash.indexOf(':');
+                        const key = afterDash.slice(0, colonIdx).trim();
+                        const value = afterDash.slice(colonIdx + 1).trim();
+                        currentItem[key] = value;
+                    }
+                }
+            }
+            else if (trimmed.includes(':') && currentItem) {
+                const colonIdx = trimmed.indexOf(':');
+                const key = trimmed.slice(0, colonIdx).trim();
+                const value = trimmed.slice(colonIdx + 1).trim();
+                currentItem[key] = value || [];
+            }
+        }
+    }
+    return result;
+}
+async function execute(args, options) {
+    const workflowFile = args[0];
+    if (!workflowFile) {
+        if (options.json || options.output === 'json') {
+            (0, json_1.printError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a workflow file path');
+        }
+        else {
+            await pretty.error('Please provide a workflow file path');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    // Resolve config
+    const config = (0, resolve_1.resolveConfig)({
+        configPath: options.config,
+        profile: options.profile,
+        model: options.model,
+        verbose: options.verbose
+    });
+    const startTime = Date.now();
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        // Read and parse workflow file
+        const filePath = path.resolve(workflowFile);
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`Workflow file not found: ${filePath}`);
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const workflow = parseWorkflowYaml(content);
+        if (outputFormat !== 'json') {
+            await pretty.heading(`Executing workflow: ${workflow.name || 'Unnamed'}`);
+            if (workflow.description) {
+                await pretty.info(workflow.description);
+            }
+        }
+        // Execute workflow steps
+        const results = {};
+        const steps = workflow.steps || [];
+        for (const step of steps) {
+            if (outputFormat !== 'json') {
+                await pretty.info(`Running step: ${step.name}`);
+            }
+            // For now, we'll simulate step execution
+            // In a full implementation, this would create agents and execute tasks
+            results[step.name] = {
+                status: 'completed',
+                output: `Step ${step.name} completed`
+            };
+        }
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                workflow: workflow.name || 'Unnamed',
+                steps: steps.length,
+                results
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else {
+            await pretty.success(`Workflow completed in ${duration}ms`);
+            await pretty.newline();
+            await pretty.keyValue({
+                'Steps executed': steps.length,
+                'Duration': `${duration}ms`
+            });
+        }
+    }
+    catch (error) {
+        const cliError = (0, errors_1.normalizeError)(error);
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(cliError.code, cliError.message, cliError.details));
+        }
+        else {
+            await pretty.error(cliError.message);
+            if (config.verbose && error instanceof Error && error.stack) {
+                await pretty.dim(error.stack);
+            }
+        }
+        process.exit(cliError.exitCode);
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Config utilities index
+ */
+export * from './schema';
+export * from './load';
+export * from './resolve';

package/dist/cli/config/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Config 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("./schema"), exports);
+__exportStar(require("./load"), exports);
+__exportStar(require("./resolve"), exports);

package/dist/cli/config/load.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Config file loading
+ */
+import { FullConfig } from './schema';
+export interface LoadConfigOptions {
+    configPath?: string;
+    cwd?: string;
+}
+/**
+ * Load config from file
+ */
+export declare function loadConfigFile(filePath: string): FullConfig;
+/**
+ * Load config with resolution order:
+ * 1. Explicit config path
+ * 2. Project config (current dir and parents)
+ * 3. User config (~/.praisonai.yaml)
+ * 4. Defaults
+ */
+export declare function loadConfig(options?: LoadConfigOptions): FullConfig;

package/dist/cli/config/load.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * Config file loading
+ */
+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.loadConfigFile = loadConfigFile;
+exports.loadConfig = loadConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cli_spec_1 = require("../spec/cli-spec");
+const schema_1 = require("./schema");
+/**
+ * Find config file in directory hierarchy
+ */
+function findConfigFile(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        for (const filename of cli_spec_1.CONFIG_FILES) {
+            const filePath = path.join(currentDir, filename);
+            if (fs.existsSync(filePath)) {
+                return filePath;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break; // Reached root
+        }
+        currentDir = parentDir;
+    }
+    return null;
+}
+/**
+ * Find user config file
+ */
+function findUserConfigFile() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (!homeDir)
+        return null;
+    for (const filename of cli_spec_1.CONFIG_FILES) {
+        const filePath = path.join(homeDir, filename);
+        if (fs.existsSync(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
+}
+/**
+ * Parse config file content
+ */
+function parseConfigFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.json') {
+        return JSON.parse(content);
+    }
+    if (ext === '.yaml' || ext === '.yml') {
+        // Simple YAML parsing for basic config
+        // For complex YAML, we'd need a proper parser
+        return parseSimpleYaml(content);
+    }
+    throw new Error(`Unsupported config file format: ${ext}`);
+}
+/**
+ * Simple YAML parser for basic key-value configs
+ * Handles: strings, booleans, numbers, simple objects
+ */
+function parseSimpleYaml(content) {
+    const result = {};
+    const lines = content.split('\n');
+    let currentObject = null;
+    let currentKey = null;
+    let baseIndent = 0;
+    for (const line of lines) {
+        // Skip empty lines and comments
+        if (!line.trim() || line.trim().startsWith('#')) {
+            continue;
+        }
+        const indent = line.search(/\S/);
+        const trimmed = line.trim();
+        // Check for key: value pattern
+        const colonIndex = trimmed.indexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const key = trimmed.slice(0, colonIndex).trim();
+        const value = trimmed.slice(colonIndex + 1).trim();
+        if (indent === 0) {
+            // Top-level key
+            if (value === '' || value === '{}') {
+                // Start of nested object
+                currentObject = {};
+                currentKey = key;
+                baseIndent = indent;
+                result[key] = currentObject;
+            }
+            else {
+                result[key] = parseYamlValue(value);
+                currentObject = null;
+                currentKey = null;
+            }
+        }
+        else if (currentObject !== null && indent > baseIndent) {
+            // Nested key
+            if (value === '' || value === '{}') {
+                // Nested object within nested object
+                const nestedObj = {};
+                currentObject[key] = nestedObj;
+                // For simplicity, we only support one level of nesting in profiles
+            }
+            else {
+                currentObject[key] = parseYamlValue(value);
+            }
+        }
+    }
+    return result;
+}
+function parseYamlValue(value) {
+    // Remove quotes
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    // Boolean
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    // Number
+    const num = Number(value);
+    if (!isNaN(num) && value !== '')
+        return num;
+    return value;
+}
+/**
+ * Load config from file
+ */
+function loadConfigFile(filePath) {
+    try {
+        const parsed = parseConfigFile(filePath);
+        if (!(0, schema_1.validateConfig)(parsed)) {
+            throw new Error('Invalid config format');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Failed to load config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Load config with resolution order:
+ * 1. Explicit config path
+ * 2. Project config (current dir and parents)
+ * 3. User config (~/.praisonai.yaml)
+ * 4. Defaults
+ */
+function loadConfig(options = {}) {
+    const configs = [schema_1.DEFAULT_CONFIG];
+    // User config
+    const userConfigPath = findUserConfigFile();
+    if (userConfigPath) {
+        try {
+            configs.push(loadConfigFile(userConfigPath));
+        }
+        catch {
+            // Ignore user config errors
+        }
+    }
+    // Project config
+    const cwd = options.cwd || process.cwd();
+    const projectConfigPath = findConfigFile(cwd);
+    if (projectConfigPath) {
+        try {
+            configs.push(loadConfigFile(projectConfigPath));
+        }
+        catch {
+            // Ignore project config errors
+        }
+    }
+    // Explicit config path
+    if (options.configPath) {
+        configs.push(loadConfigFile(options.configPath));
+    }
+    // Merge all configs
+    const result = { ...schema_1.DEFAULT_CONFIG };
+    for (const config of configs) {
+        if (config.model !== undefined)
+            result.model = config.model;
+        if (config.verbose !== undefined)
+            result.verbose = config.verbose;
+        if (config.stream !== undefined)
+            result.stream = config.stream;
+        if (config.profiles !== undefined) {
+            result.profiles = { ...result.profiles, ...config.profiles };
+        }
+    }
+    return result;
+}

package/dist/cli/config/resolve.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Config resolution with profiles and CLI overrides
+ */
+export interface ResolvedConfig {
+    model: string;
+    verbose: boolean;
+    stream: boolean;
+}
+export interface ResolveOptions {
+    configPath?: string;
+    profile?: string;
+    model?: string;
+    verbose?: boolean;
+    stream?: boolean;
+}
+/**
+ * Resolve final config with precedence:
+ * 1. CLI flags (highest)
+ * 2. Environment variables
+ * 3. Profile settings
+ * 4. Config file
+ * 5. Defaults (lowest)
+ */
+export declare function resolveConfig(options?: ResolveOptions): ResolvedConfig;
+/**
+ * Get available profile names
+ */
+export declare function getAvailableProfiles(configPath?: string): string[];

package/dist/cli/config/resolve.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Config resolution with profiles and CLI overrides
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+exports.getAvailableProfiles = getAvailableProfiles;
+const load_1 = require("./load");
+const env_1 = require("../runtime/env");
+const schema_1 = require("./schema");
+/**
+ * Resolve final config with precedence:
+ * 1. CLI flags (highest)
+ * 2. Environment variables
+ * 3. Profile settings
+ * 4. Config file
+ * 5. Defaults (lowest)
+ */
+function resolveConfig(options = {}) {
+    // Load base config from files
+    const fileConfig = (0, load_1.loadConfig)({ configPath: options.configPath });
+    // Load env config
+    const envConfig = (0, env_1.loadEnvConfig)();
+    // Get profile config if specified
+    let profileConfig = {};
+    const profileName = options.profile || envConfig.profile;
+    if (profileName && fileConfig.profiles?.[profileName]) {
+        profileConfig = fileConfig.profiles[profileName];
+    }
+    // Resolve with precedence
+    const resolved = {
+        model: schema_1.DEFAULT_CONFIG.model,
+        verbose: schema_1.DEFAULT_CONFIG.verbose,
+        stream: schema_1.DEFAULT_CONFIG.stream
+    };
+    // Apply file config
+    if (fileConfig.model !== undefined)
+        resolved.model = fileConfig.model;
+    if (fileConfig.verbose !== undefined)
+        resolved.verbose = fileConfig.verbose;
+    if (fileConfig.stream !== undefined)
+        resolved.stream = fileConfig.stream;
+    // Apply profile config
+    if (profileConfig.model !== undefined)
+        resolved.model = profileConfig.model;
+    if (profileConfig.verbose !== undefined)
+        resolved.verbose = profileConfig.verbose;
+    if (profileConfig.stream !== undefined)
+        resolved.stream = profileConfig.stream;
+    // Apply env config
+    if (envConfig.model !== undefined)
+        resolved.model = envConfig.model;
+    if (envConfig.verbose !== undefined)
+        resolved.verbose = envConfig.verbose;
+    // Apply CLI flags (highest precedence)
+    if (options.model !== undefined)
+        resolved.model = options.model;
+    if (options.verbose !== undefined)
+        resolved.verbose = options.verbose;
+    if (options.stream !== undefined)
+        resolved.stream = options.stream;
+    return resolved;
+}
+/**
+ * Get available profile names
+ */
+function getAvailableProfiles(configPath) {
+    const config = (0, load_1.loadConfig)({ configPath });
+    return Object.keys(config.profiles || {});
+}

package/dist/cli/config/schema.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Config schema definitions
+ */
+import { ConfigSchema } from '../spec/cli-spec';
+export interface ProfileConfig {
+    model?: string;
+    verbose?: boolean;
+    stream?: boolean;
+}
+export interface FullConfig extends ConfigSchema {
+    profiles?: Record<string, ProfileConfig>;
+}
+export declare const DEFAULT_CONFIG: FullConfig;
+export declare function validateConfig(config: unknown): config is FullConfig;
+export declare function mergeConfigs(...configs: Partial<FullConfig>[]): FullConfig;

package/dist/cli/config/schema.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Config schema definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.validateConfig = validateConfig;
+exports.mergeConfigs = mergeConfigs;
+exports.DEFAULT_CONFIG = {
+    model: 'openai/gpt-4o-mini',
+    verbose: false,
+    stream: false,
+    profiles: {}
+};
+function validateConfig(config) {
+    if (typeof config !== 'object' || config === null) {
+        return false;
+    }
+    const c = config;
+    if (c.model !== undefined && typeof c.model !== 'string') {
+        return false;
+    }
+    if (c.verbose !== undefined && typeof c.verbose !== 'boolean') {
+        return false;
+    }
+    if (c.stream !== undefined && typeof c.stream !== 'boolean') {
+        return false;
+    }
+    if (c.profiles !== undefined) {
+        if (typeof c.profiles !== 'object' || c.profiles === null) {
+            return false;
+        }
+        for (const profile of Object.values(c.profiles)) {
+            if (typeof profile !== 'object' || profile === null) {
+                return false;
+            }
+            const p = profile;
+            if (p.model !== undefined && typeof p.model !== 'string') {
+                return false;
+            }
+            if (p.verbose !== undefined && typeof p.verbose !== 'boolean') {
+                return false;
+            }
+            if (p.stream !== undefined && typeof p.stream !== 'boolean') {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function mergeConfigs(...configs) {
+    const result = { ...exports.DEFAULT_CONFIG };
+    for (const config of configs) {
+        if (config.model !== undefined)
+            result.model = config.model;
+        if (config.verbose !== undefined)
+            result.verbose = config.verbose;
+        if (config.stream !== undefined)
+            result.stream = config.stream;
+        if (config.profiles !== undefined) {
+            result.profiles = { ...result.profiles, ...config.profiles };
+        }
+    }
+    return result;
+}