overai 1.4.0

package/dist/cli/commands/graph-rag.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Graph RAG command - Graph-based retrieval augmented generation
+ */
+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 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");
+async function execute(args, options) {
+    const action = args[0] || 'help';
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        switch (action) {
+            case 'info':
+                await showInfo(outputFormat);
+                break;
+            case 'help':
+            default:
+                await showHelp(outputFormat);
+                break;
+        }
+    }
+    catch (error) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, error instanceof Error ? error.message : String(error)));
+        }
+        else {
+            await pretty.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+}
+async function showInfo(outputFormat) {
+    const info = {
+        feature: 'Graph RAG',
+        description: 'Graph-based retrieval augmented generation for complex knowledge queries',
+        capabilities: [
+            'Build knowledge graphs from documents',
+            'Query relationships between entities',
+            'Combine graph traversal with vector search',
+            'Extract entities and relationships',
+            'Support for complex multi-hop queries'
+        ],
+        sdkUsage: `
+import { createGraphRAG, GraphStore } from 'praisonai';
+
+// Create a graph RAG instance
+const graphRag = createGraphRAG({
+  llm: 'openai/gpt-4o-mini',
+  graphStore: new GraphStore()
+});
+
+// Add documents
+await graphRag.addDocument('Document content...');
+
+// Query with graph context
+const result = await graphRag.query('What is the relationship between X and Y?');
+`
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(info));
+    }
+    else {
+        await pretty.heading('Graph RAG');
+        await pretty.plain(info.description);
+        await pretty.newline();
+        await pretty.plain('Capabilities:');
+        for (const cap of info.capabilities) {
+            await pretty.plain(`  • ${cap}`);
+        }
+        await pretty.newline();
+        await pretty.dim('Use the SDK for full Graph RAG functionality');
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'graph-rag',
+        description: 'Graph-based retrieval augmented generation',
+        subcommands: [
+            { name: 'info', description: 'Show Graph RAG feature information' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Graph RAG Command');
+        await pretty.plain(help.description);
+        await pretty.newline();
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(20)} ${cmd.description}`);
+        }
+    }
+}

package/dist/cli/commands/guardrail.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Guardrail command - Content validation and safety
+ */
+export interface GuardrailOptions {
+    model?: string;
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    criteria?: string;
+}
+export declare function execute(args: string[], options: GuardrailOptions): Promise<void>;

package/dist/cli/commands/guardrail.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Guardrail command - Content validation and safety
+ */
+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 llm_guardrail_1 = require("../../guardrails/llm-guardrail");
+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");
+async function execute(args, options) {
+    const action = args[0] || 'help';
+    const actionArgs = args.slice(1);
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    const config = (0, resolve_1.resolveConfig)(options);
+    try {
+        switch (action) {
+            case 'check':
+                await checkContent(actionArgs, options, config, outputFormat);
+                break;
+            case 'help':
+            default:
+                await showHelp(outputFormat);
+                break;
+        }
+    }
+    catch (error) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, error instanceof Error ? error.message : String(error)));
+        }
+        else {
+            await pretty.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+}
+async function checkContent(args, options, config, outputFormat) {
+    const content = args.join(' ');
+    if (!content) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide content to check'));
+        }
+        else {
+            await pretty.error('Please provide content to check');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const startTime = Date.now();
+    if (outputFormat !== 'json') {
+        await pretty.info('Checking content...');
+    }
+    const guardrail = (0, llm_guardrail_1.createLLMGuardrail)({
+        name: 'cli-guardrail',
+        llm: config.model,
+        criteria: options.criteria || 'Content should be safe, appropriate, and helpful',
+        verbose: options.verbose
+    });
+    const result = await guardrail.check(content);
+    const duration = Date.now() - startTime;
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            content: content.substring(0, 100) + (content.length > 100 ? '...' : ''),
+            status: result.status,
+            score: result.score,
+            message: result.message,
+            reasoning: result.reasoning
+        }, {
+            duration_ms: duration,
+            model: config.model
+        }));
+    }
+    else {
+        await pretty.heading('Guardrail Check');
+        if (result.status === 'passed') {
+            await pretty.success('Content passed guardrail check');
+        }
+        else if (result.status === 'warning') {
+            await pretty.warn('Content has warnings');
+        }
+        else {
+            await pretty.error('Content failed guardrail check');
+        }
+        await pretty.plain(`Score: ${(result.score * 10).toFixed(1)}/10`);
+        if (result.message) {
+            await pretty.plain(`Message: ${result.message}`);
+        }
+        if (result.reasoning) {
+            await pretty.dim(`Reasoning: ${result.reasoning}`);
+        }
+        await pretty.newline();
+        await pretty.dim(`Checked in ${duration}ms`);
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'guardrail',
+        subcommands: [
+            { name: 'check <content>', description: 'Check content against guardrails' },
+            { name: 'help', description: 'Show this help' }
+        ],
+        flags: [
+            { name: '--criteria', description: 'Custom criteria for validation' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Guardrail Command');
+        await pretty.plain('Content validation and safety checks\n');
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(25)} ${cmd.description}`);
+        }
+        await pretty.newline();
+        await pretty.plain('Flags:');
+        for (const flag of help.flags) {
+            await pretty.plain(`  ${flag.name.padEnd(20)} ${flag.description}`);
+        }
+    }
+}

package/dist/cli/commands/handoff.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Handoff command - Agent handoff management
+ */
+export interface HandoffOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: HandoffOptions): Promise<void>;

package/dist/cli/commands/handoff.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Handoff command - Agent handoff management
+ */
+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 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");
+async function execute(args, options) {
+    const action = args[0] || 'help';
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        switch (action) {
+            case 'info':
+                await showInfo(outputFormat);
+                break;
+            case 'help':
+            default:
+                await showHelp(outputFormat);
+                break;
+        }
+    }
+    catch (error) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, error instanceof Error ? error.message : String(error)));
+        }
+        else {
+            await pretty.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+}
+async function showInfo(outputFormat) {
+    const info = {
+        feature: 'Handoff',
+        description: 'Agent handoff allows seamless transfer of conversation context between agents',
+        capabilities: [
+            'Transfer conversation to specialized agents',
+            'Preserve context during handoff',
+            'Filter handoffs based on conditions',
+            'Chain multiple agent handoffs'
+        ],
+        sdkUsage: `
+import { Handoff, handoff, handoffFilters } from 'praisonai';
+
+// Create a handoff
+const myHandoff = handoff({
+  target: specialistAgent,
+  condition: (ctx) => ctx.input.includes('technical'),
+  onHandoff: (ctx) => console.log('Handing off...')
+});
+
+// Use with an agent
+const agent = new Agent({
+  handoffs: [myHandoff]
+});
+`
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(info));
+    }
+    else {
+        await pretty.heading('Handoff Feature');
+        await pretty.plain(info.description);
+        await pretty.newline();
+        await pretty.plain('Capabilities:');
+        for (const cap of info.capabilities) {
+            await pretty.plain(`  • ${cap}`);
+        }
+        await pretty.newline();
+        await pretty.dim('Use the SDK for programmatic handoff configuration');
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'handoff',
+        description: 'Agent handoff management - transfer conversations between agents',
+        subcommands: [
+            { name: 'info', description: 'Show handoff feature information' },
+            { name: 'help', description: 'Show this help' }
+        ],
+        note: 'Handoff is primarily a programmatic SDK feature. Use the SDK for full functionality.'
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Handoff Command');
+        await pretty.plain(help.description);
+        await pretty.newline();
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(20)} ${cmd.description}`);
+        }
+        await pretty.newline();
+        await pretty.dim(help.note);
+    }
+}

package/dist/cli/commands/help.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Help command - Show help information
+ */
+export interface HelpOptions {
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: HelpOptions): Promise<void>;

package/dist/cli/commands/help.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Help command - Show help information
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const cli_spec_1 = require("../spec/cli-spec");
+const pretty_logger_1 = require("../../utils/pretty-logger");
+function outputJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+function formatSuccess(data) {
+    return { success: true, data };
+}
+async function execute(args, options) {
+    const command = args[0];
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    if (command) {
+        await showCommandHelp(command, outputFormat);
+    }
+    else {
+        await showGeneralHelp(outputFormat);
+    }
+}
+async function showGeneralHelp(outputFormat) {
+    const commands = Object.entries(cli_spec_1.COMMANDS).map(([name, spec]) => ({
+        name,
+        description: spec.description
+    }));
+    const flags = cli_spec_1.GLOBAL_FLAGS.map(f => ({
+        name: f.short ? `-${f.short}, --${f.name}` : `--${f.name}`,
+        description: f.description,
+        default: f.default
+    }));
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({
+            cli_spec_version: cli_spec_1.CLI_SPEC_VERSION,
+            commands,
+            global_flags: flags
+        }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.plain(`
+OverAI TypeScript CLI v${cli_spec_1.CLI_SPEC_VERSION}
+
+Usage:
+  overai <command> [options]
+
+Commands:`);
+        for (const cmd of commands) {
+            await pretty_logger_1.PrettyLogger.plain(`  ${cmd.name.padEnd(12)} ${cmd.description}`);
+        }
+        await pretty_logger_1.PrettyLogger.plain(`
+Global Options:`);
+        for (const flag of flags) {
+            const defaultStr = flag.default !== undefined ? ` (default: ${flag.default})` : '';
+            await pretty_logger_1.PrettyLogger.plain(`  ${flag.name.padEnd(20)} ${flag.description}${defaultStr}`);
+        }
+        await pretty_logger_1.PrettyLogger.plain(`
+Environment Variables:
+  OPENAI_API_KEY       OpenAI API key
+  ANTHROPIC_API_KEY    Anthropic API key
+  GOOGLE_API_KEY       Google API key
+  OVERAI_MODEL         Default model
+
+Examples:
+  overai chat "Hello, how are you?"
+  overai chat "Write a poem" --stream
+  overai run "Analyze this data" --agent my-agent.yaml
+  overai providers
+  overai help chat
+`);
+    }
+}
+async function showCommandHelp(command, outputFormat) {
+    const spec = (0, cli_spec_1.getCommandSpec)(command);
+    if (!spec) {
+        await pretty_logger_1.PrettyLogger.error(`Unknown command: ${command}`);
+        await pretty_logger_1.PrettyLogger.info('Run "overai help" to see available commands');
+        return;
+    }
+    const args = spec.args || [];
+    const flags = [...cli_spec_1.GLOBAL_FLAGS, ...(spec.flags || [])];
+    const subcommands = spec.subcommands ? Object.entries(spec.subcommands) : [];
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({
+            command,
+            description: spec.description,
+            args: args.map(a => ({
+                name: a.name,
+                type: a.type,
+                required: a.required,
+                description: a.description
+            })),
+            flags: flags.map(f => ({
+                name: f.name,
+                short: f.short,
+                type: f.type,
+                default: f.default,
+                description: f.description
+            })),
+            subcommands: subcommands.map(([name, sub]) => ({
+                name,
+                description: sub.description
+            }))
+        }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.plain(`
+Command: ${command}
+${spec.description}
+
+Usage:
+  overai ${command}${args.length ? ' ' + args.map(a => a.required ? `<${a.name}>` : `[${a.name}]`).join(' ') : ''} [options]`);
+        if (args.length > 0) {
+            await pretty_logger_1.PrettyLogger.plain(`
+Arguments:`);
+            for (const arg of args) {
+                const reqStr = arg.required ? ' (required)' : '';
+                await pretty_logger_1.PrettyLogger.plain(`  ${arg.name.padEnd(15)} ${arg.description || arg.type}${reqStr}`);
+            }
+        }
+        if (subcommands.length > 0) {
+            await pretty_logger_1.PrettyLogger.plain(`
+Subcommands:`);
+            for (const [name, sub] of subcommands) {
+                await pretty_logger_1.PrettyLogger.plain(`  ${name.padEnd(15)} ${sub.description}`);
+            }
+        }
+        await pretty_logger_1.PrettyLogger.plain(`
+Options:`);
+        for (const flag of flags) {
+            const shortStr = flag.short ? `-${flag.short}, ` : '    ';
+            const defaultStr = flag.default !== undefined ? ` (default: ${flag.default})` : '';
+            await pretty_logger_1.PrettyLogger.plain(`  ${shortStr}--${flag.name.padEnd(14)} ${flag.description || ''}${defaultStr}`);
+        }
+        await pretty_logger_1.PrettyLogger.plain('');
+    }
+}

package/dist/cli/commands/image.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Image command - Image generation and analysis
+ */
+export interface ImageOptions {
+    model?: string;
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    size?: string;
+    quality?: string;
+    style?: string;
+}
+export declare function execute(args: string[], options: ImageOptions): Promise<void>;