overai 1.4.0

package/dist/cli/commands/agents.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Agents command - Run multi-agent orchestration
+ *
+ * Usage:
+ *   overai agents run --agents "researcher,writer" "Research AI trends"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeRun = executeRun;
+exports.execute = execute;
+const agent_1 = require("../../agent");
+const resolve_1 = require("../config/resolve");
+const cli_spec_1 = require("../spec/cli-spec");
+const pretty_logger_1 = require("../../utils/pretty-logger");
+const outputJson = (obj) => console.log(JSON.stringify(obj));
+const formatSuccess = (data, meta) => meta ? { success: true, data, meta } : { success: true, data };
+const formatError = (code, message, details) => details
+    ? { success: false, error: { code, message, details } }
+    : { success: false, error: { code, message } };
+const ERROR_CODES = {
+    INVALID_ARGS: 'INVALID_ARGUMENTS',
+    MISSING_ARG: 'MISSING_ARGUMENT',
+    UNKNOWN: 'UNKNOWN_ERROR',
+};
+function normalizeError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const details = error instanceof Error && error.stack ? { stack: error.stack } : undefined;
+    return { code: ERROR_CODES.UNKNOWN, message, details, exitCode: cli_spec_1.EXIT_CODES.RUNTIME_ERROR };
+}
+const pretty = {
+    success: pretty_logger_1.PrettyLogger.success,
+    error: pretty_logger_1.PrettyLogger.error,
+    info: pretty_logger_1.PrettyLogger.info,
+    dim: async (s) => console.log(s),
+    plain: async (s) => console.log(s),
+    heading: async (s) => console.log(s),
+    newline: async () => console.log(),
+};
+/**
+ * Parse agent definitions from comma-separated string
+ */
+function parseAgentDefinitions(agentsStr) {
+    return agentsStr.split(',').map(s => s.trim()).filter(s => s.length > 0);
+}
+/**
+ * Execute agents run subcommand
+ */
+async function executeRun(args, options) {
+    const prompt = args[0];
+    if (!prompt) {
+        if (options.json || options.output === 'json') {
+            outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Please provide a prompt/task'));
+        }
+        else {
+            await pretty.error('Please provide a prompt/task');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    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 {
+        // Create agents from definitions or use defaults
+        let agentList;
+        if (options.agents) {
+            const definitions = parseAgentDefinitions(options.agents);
+            agentList = definitions.map((instructions, i) => new agent_1.Agent({
+                instructions,
+                name: `Agent_${i + 1}`,
+                llm: config.model,
+                verbose: config.verbose
+            }));
+        }
+        else {
+            // Default: create a researcher and writer
+            agentList = [
+                new agent_1.Agent({
+                    instructions: `Research the following topic thoroughly: ${prompt}`,
+                    name: 'Researcher',
+                    llm: config.model,
+                    verbose: config.verbose
+                }),
+                new agent_1.Agent({
+                    instructions: 'Summarize and write a clear report based on the research provided.',
+                    name: 'Writer',
+                    llm: config.model,
+                    verbose: config.verbose
+                })
+            ];
+        }
+        if (outputFormat !== 'json') {
+            await pretty.heading(`Running ${agentList.length} agents (${options.process || 'sequential'})`);
+        }
+        const agents = new agent_1.Agents({
+            agents: agentList,
+            process: options.process || 'sequential',
+            verbose: config.verbose
+        });
+        const results = await agents.start();
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                results,
+                agentCount: agentList.length,
+                process: options.process || 'sequential'
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else if (outputFormat === 'text') {
+            results.forEach((result, i) => {
+                console.log(`\n--- Agent ${i + 1} ---\n${result}`);
+            });
+        }
+        else {
+            // Pretty output
+            console.log();
+            await pretty.success(`Completed ${agentList.length} agents in ${duration}ms`);
+        }
+    }
+    catch (error) {
+        const cliError = normalizeError(error);
+        if (outputFormat === 'json') {
+            outputJson(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);
+    }
+}
+/**
+ * Main execute function - routes to subcommands
+ */
+async function execute(args, options) {
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    switch (subcommand) {
+        case 'run':
+            return executeRun(subArgs, options);
+        default:
+            // If no subcommand, treat as run
+            if (subcommand) {
+                return executeRun(args, options);
+            }
+            if (options.json || options.output === 'json') {
+                outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Please provide a task/prompt'));
+            }
+            else {
+                await pretty.error('Usage: overai agents [run] <task>');
+                await pretty.info('  agents run "Research AI"     - Run with default agents');
+                await pretty.info('  agents run --agents "..." "Research AI" - Run with custom agents');
+                await pretty.info('  agents run --process parallel "Research AI" - Run in parallel');
+            }
+            process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Approval command - Tool approval management for AI SDK v6 parity
+ */
+export interface ApprovalOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    timeout?: number;
+}
+export declare function execute(args: string[], options: ApprovalOptions): Promise<void>;

package/dist/cli/commands/approval.js

@@ -0,0 +1,253 @@
+"use strict";
+/**
+ * Approval command - Tool approval management for AI SDK v6 parity
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const tool_approval_1 = require("../../ai/tool-approval");
+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 };
+}
+function formatError(code, message) {
+    return { success: false, error: { code, message } };
+}
+const ERROR_CODES = {
+    INVALID_ARGS: 'INVALID_ARGS',
+    MISSING_ARG: 'MISSING_ARG',
+    UNKNOWN: 'UNKNOWN_ERROR',
+};
+async function execute(args, options) {
+    const action = args[0] || 'status';
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        switch (action) {
+            case 'status':
+                await showStatus(outputFormat);
+                break;
+            case 'pending':
+                await showPending(outputFormat);
+                break;
+            case 'approve':
+                await approveRequest(args[1], outputFormat);
+                break;
+            case 'deny':
+                await denyRequest(args[1], outputFormat);
+                break;
+            case 'cancel':
+                await cancelRequest(args[1], outputFormat);
+                break;
+            case 'cancel-all':
+                await cancelAll(outputFormat);
+                break;
+            case 'auto-approve':
+                await addAutoApprove(args.slice(1), outputFormat);
+                break;
+            case 'auto-deny':
+                await addAutoDeny(args.slice(1), outputFormat);
+                break;
+            case 'interactive':
+                await startInteractive(options);
+                break;
+            case 'help':
+            default:
+                await showHelp(outputFormat);
+                break;
+        }
+    }
+    catch (error) {
+        if (outputFormat === 'json') {
+            outputJson(formatError(ERROR_CODES.UNKNOWN, error instanceof Error ? error.message : String(error)));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+}
+async function showStatus(outputFormat) {
+    const manager = (0, tool_approval_1.getApprovalManager)();
+    const pending = manager.getPendingRequests();
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({
+            pendingCount: pending.length,
+            pending: pending.map(r => ({
+                requestId: r.requestId,
+                toolName: r.toolName,
+                timestamp: r.timestamp,
+            })),
+        }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.heading('Approval Status');
+        await pretty_logger_1.PrettyLogger.plain(`Pending requests: ${pending.length}`);
+        if (pending.length > 0) {
+            await pretty_logger_1.PrettyLogger.plain('\nPending:');
+            for (const req of pending) {
+                await pretty_logger_1.PrettyLogger.plain(`  - ${req.toolName} (${req.requestId})`);
+            }
+        }
+    }
+}
+async function showPending(outputFormat) {
+    const manager = (0, tool_approval_1.getApprovalManager)();
+    const pending = manager.getPendingRequests();
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({ pending }));
+    }
+    else {
+        if (pending.length === 0) {
+            await pretty_logger_1.PrettyLogger.plain('No pending approval requests');
+            return;
+        }
+        await pretty_logger_1.PrettyLogger.heading('Pending Approval Requests');
+        for (const req of pending) {
+            await pretty_logger_1.PrettyLogger.plain(`\n🔐 ${req.toolName}`);
+            await pretty_logger_1.PrettyLogger.plain(`   ID: ${req.requestId}`);
+            await pretty_logger_1.PrettyLogger.plain(`   Input: ${JSON.stringify(req.input)}`);
+            await pretty_logger_1.PrettyLogger.plain(`   Time: ${new Date(req.timestamp).toISOString()}`);
+            if (req.reason) {
+                await pretty_logger_1.PrettyLogger.plain(`   Reason: ${req.reason}`);
+            }
+        }
+    }
+}
+async function approveRequest(requestId, outputFormat) {
+    if (!requestId) {
+        throw new Error('Request ID required. Usage: praisonai approval approve <requestId>');
+    }
+    const manager = (0, tool_approval_1.getApprovalManager)();
+    manager.respond({
+        requestId,
+        approved: true,
+        timestamp: Date.now(),
+    });
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({ requestId, approved: true }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.success(`Approved request: ${requestId}`);
+    }
+}
+async function denyRequest(requestId, outputFormat) {
+    if (!requestId) {
+        throw new Error('Request ID required. Usage: praisonai approval deny <requestId>');
+    }
+    const manager = (0, tool_approval_1.getApprovalManager)();
+    manager.respond({
+        requestId,
+        approved: false,
+        timestamp: Date.now(),
+    });
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({ requestId, approved: false }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.success(`Denied request: ${requestId}`);
+    }
+}
+async function cancelRequest(requestId, outputFormat) {
+    if (!requestId) {
+        throw new Error('Request ID required. Usage: praisonai approval cancel <requestId>');
+    }
+    const manager = (0, tool_approval_1.getApprovalManager)();
+    manager.cancel(requestId);
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({ requestId, cancelled: true }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.success(`Cancelled request: ${requestId}`);
+    }
+}
+async function cancelAll(outputFormat) {
+    const manager = (0, tool_approval_1.getApprovalManager)();
+    const pending = manager.getPendingRequests();
+    const count = pending.length;
+    manager.cancelAll();
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({ cancelled: count }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.success(`Cancelled ${count} pending requests`);
+    }
+}
+async function addAutoApprove(args, outputFormat) {
+    const toolName = args[0];
+    if (!toolName) {
+        throw new Error('Tool name required. Usage: praisonai approval auto-approve <toolName>');
+    }
+    const manager = (0, tool_approval_1.getApprovalManager)();
+    manager.addAutoApprove(toolName);
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({ toolName, autoApprove: true }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.success(`Added auto-approve for: ${toolName}`);
+    }
+}
+async function addAutoDeny(args, outputFormat) {
+    const toolName = args[0];
+    if (!toolName) {
+        throw new Error('Tool name required. Usage: praisonai approval auto-deny <toolName>');
+    }
+    const manager = (0, tool_approval_1.getApprovalManager)();
+    manager.addAutoDeny(toolName);
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({ toolName, autoDeny: true }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.success(`Added auto-deny for: ${toolName}`);
+    }
+}
+async function startInteractive(options) {
+    await pretty_logger_1.PrettyLogger.heading('Interactive Approval Mode');
+    await pretty_logger_1.PrettyLogger.plain('Waiting for approval requests... (Ctrl+C to exit)\n');
+    const manager = (0, tool_approval_1.getApprovalManager)();
+    const handler = (0, tool_approval_1.createCLIApprovalPrompt)();
+    manager.onApprovalRequest(handler);
+    // Keep process alive
+    await new Promise(() => { });
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'approval',
+        description: 'Manage tool approval requests (AI SDK v6 parity)',
+        subcommands: [
+            { name: 'status', description: 'Show approval status' },
+            { name: 'pending', description: 'List pending approval requests' },
+            { name: 'approve <id>', description: 'Approve a pending request' },
+            { name: 'deny <id>', description: 'Deny a pending request' },
+            { name: 'cancel <id>', description: 'Cancel a pending request' },
+            { name: 'cancel-all', description: 'Cancel all pending requests' },
+            { name: 'auto-approve <tool>', description: 'Auto-approve a tool' },
+            { name: 'auto-deny <tool>', description: 'Auto-deny a tool' },
+            { name: 'interactive', description: 'Start interactive approval mode' },
+        ],
+        examples: [
+            'overai approval status',
+            'overai approval pending',
+            'overai approval approve abc123',
+            'overai approval auto-approve readFile',
+            'overai approval interactive',
+        ],
+    };
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess(help));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.heading('Approval Command');
+        await pretty_logger_1.PrettyLogger.plain('Manage tool approval requests for safe AI agent execution.\n');
+        await pretty_logger_1.PrettyLogger.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty_logger_1.PrettyLogger.plain(`  ${cmd.name.padEnd(20)} ${cmd.description}`);
+        }
+        await pretty_logger_1.PrettyLogger.plain('\nExamples:');
+        for (const ex of help.examples) {
+            await pretty_logger_1.PrettyLogger.plain(`  ${ex}`);
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Auto command - AutoAgents for automatic agent generation
+ */
+export interface AutoOptions {
+    model?: string;
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    pattern?: string;
+    agents?: number;
+}
+export declare function execute(args: string[], options: AutoOptions): Promise<void>;

package/dist/cli/commands/auto.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Auto command - AutoAgents for automatic agent 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 auto_1 = require("../../auto");
+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 topic = args.join(' ');
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    const config = (0, resolve_1.resolveConfig)(options);
+    if (!topic) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a topic for auto-generation'));
+        }
+        else {
+            await pretty.error('Please provide a topic for auto-generation');
+            await pretty.dim('Usage: praisonai-ts auto "Create a research team"');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const startTime = Date.now();
+    try {
+        if (outputFormat !== 'json') {
+            await pretty.info(`Generating agents for: "${topic}"`);
+        }
+        const autoAgents = (0, auto_1.createAutoAgents)({
+            llm: config.model,
+            pattern: options.pattern,
+            verbose: options.verbose
+        });
+        const result = await autoAgents.generate(topic);
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                topic,
+                agents: result.agents,
+                tasks: result.tasks,
+                pattern: result.pattern
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else {
+            await pretty.heading('Generated Team');
+            await pretty.plain(`Pattern: ${result.pattern}`);
+            await pretty.newline();
+            await pretty.plain('Agents:');
+            for (const agent of result.agents) {
+                await pretty.plain(`  • ${agent.name}: ${agent.role}`);
+            }
+            await pretty.newline();
+            await pretty.plain('Tasks:');
+            for (const task of result.tasks) {
+                await pretty.plain(`  • ${task.description?.substring(0, 60)}...`);
+            }
+            await pretty.newline();
+            await pretty.success(`Generated in ${duration}ms`);
+        }
+    }
+    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);
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * CLI command: autonomy
+ * Autonomy mode management for agent actions
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;