overai 1.4.0

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

@@ -0,0 +1,5 @@
+/**
+ * CLI command: scheduler
+ * Agent task scheduling with cron-like patterns
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/scheduler.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * CLI command: scheduler
+ * Agent task scheduling with cron-like patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const scheduler_1 = require("../features/scheduler");
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'create':
+            await handleCreate(args.slice(1), options, isJson);
+            break;
+        case 'list':
+            await handleList(options, isJson);
+            break;
+        case 'run':
+            await handleRun(args.slice(1), options, isJson);
+            break;
+        case 'remove':
+            await handleRemove(args.slice(1), options, isJson);
+            break;
+        case 'enable':
+            await handleEnable(args.slice(1), options, isJson);
+            break;
+        case 'disable':
+            await handleDisable(args.slice(1), options, isJson);
+            break;
+        case 'patterns':
+            await handlePatterns(isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleCreate(args, options, isJson) {
+    const name = args[0];
+    const cron = options.cron;
+    const interval = options.interval;
+    if (!name) {
+        const error = { error: 'Task name is required' };
+        if (isJson) {
+            console.log(JSON.stringify(error));
+        }
+        else {
+            console.error('Error: Task name is required');
+            console.log('Usage: praisonai-ts scheduler create <name> --cron "* * * * *"');
+        }
+        process.exit(1);
+    }
+    if (!cron && !interval) {
+        const error = { error: 'Either --cron or --interval is required' };
+        if (isJson) {
+            console.log(JSON.stringify(error));
+        }
+        else {
+            console.error('Error: Either --cron or --interval is required');
+        }
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const id = scheduler.add({
+        name,
+        cron,
+        interval: interval ? interval * 1000 : undefined,
+        task: async () => {
+            console.log(`Task ${name} executed at ${new Date().toISOString()}`);
+            return { executed: true };
+        }
+    });
+    const result = {
+        success: true,
+        id,
+        name,
+        cron,
+        interval,
+        message: `Task '${name}' created with ID: ${id}`
+    };
+    if (isJson) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(`✓ Task '${name}' created`);
+        console.log(`  ID: ${id}`);
+        if (cron)
+            console.log(`  Cron: ${cron}`);
+        if (interval)
+            console.log(`  Interval: ${interval}s`);
+    }
+}
+async function handleList(options, isJson) {
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const tasks = scheduler.getAllTasks();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, tasks }, null, 2));
+    }
+    else {
+        if (tasks.length === 0) {
+            console.log('No scheduled tasks');
+        }
+        else {
+            console.log('Scheduled Tasks:');
+            for (const task of tasks) {
+                console.log(`  ${task.name} (${task.id})`);
+                console.log(`    Status: ${task.status}`);
+                console.log(`    Enabled: ${task.enabled}`);
+                console.log(`    Run count: ${task.runCount}`);
+                if (task.nextRun)
+                    console.log(`    Next run: ${task.nextRun.toISOString()}`);
+            }
+        }
+    }
+}
+async function handleRun(args, options, isJson) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Task ID is required');
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    try {
+        const result = await scheduler.runNow(id);
+        if (isJson) {
+            console.log(JSON.stringify({ success: true, result }, null, 2));
+        }
+        else {
+            console.log(`✓ Task ${id} executed successfully`);
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+async function handleRemove(args, options, isJson) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Task ID is required');
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const removed = scheduler.remove(id);
+    if (isJson) {
+        console.log(JSON.stringify({ success: removed, id }));
+    }
+    else {
+        if (removed) {
+            console.log(`✓ Task ${id} removed`);
+        }
+        else {
+            console.error(`Task ${id} not found`);
+            process.exit(1);
+        }
+    }
+}
+async function handleEnable(args, options, isJson) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Task ID is required');
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const enabled = scheduler.enable(id);
+    if (isJson) {
+        console.log(JSON.stringify({ success: enabled, id }));
+    }
+    else {
+        console.log(enabled ? `✓ Task ${id} enabled` : `Task ${id} not found`);
+    }
+}
+async function handleDisable(args, options, isJson) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Task ID is required');
+        process.exit(1);
+    }
+    const scheduler = (0, scheduler_1.createScheduler)();
+    const disabled = scheduler.disable(id);
+    if (isJson) {
+        console.log(JSON.stringify({ success: disabled, id }));
+    }
+    else {
+        console.log(disabled ? `✓ Task ${id} disabled` : `Task ${id} not found`);
+    }
+}
+async function handlePatterns(isJson) {
+    const patterns = {
+        everyMinute: scheduler_1.cronExpressions.everyMinute,
+        every5Minutes: scheduler_1.cronExpressions.every5Minutes,
+        every15Minutes: scheduler_1.cronExpressions.every15Minutes,
+        everyHour: scheduler_1.cronExpressions.everyHour,
+        everyDay: scheduler_1.cronExpressions.everyDay,
+        everyWeek: scheduler_1.cronExpressions.everyWeek,
+        everyMonth: scheduler_1.cronExpressions.everyMonth,
+        weekdays: scheduler_1.cronExpressions.weekdays,
+        weekends: scheduler_1.cronExpressions.weekends
+    };
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, patterns }, null, 2));
+    }
+    else {
+        console.log('Common Cron Patterns:');
+        for (const [name, pattern] of Object.entries(patterns)) {
+            console.log(`  ${name}: ${pattern}`);
+        }
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'scheduler',
+        description: 'Agent task scheduling with cron-like patterns',
+        subcommands: {
+            create: 'Create a scheduled task',
+            list: 'List all scheduled tasks',
+            run: 'Run a task immediately',
+            remove: 'Remove a scheduled task',
+            enable: 'Enable a task',
+            disable: 'Disable a task',
+            patterns: 'Show common cron patterns'
+        },
+        flags: {
+            '--cron': 'Cron expression (e.g., "*/5 * * * *")',
+            '--interval': 'Interval in seconds',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts scheduler create my-task --cron "*/5 * * * *"',
+            'praisonai-ts scheduler create backup --interval 3600',
+            'praisonai-ts scheduler list',
+            'praisonai-ts scheduler run <task-id>',
+            'praisonai-ts scheduler patterns'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Scheduler - Agent task scheduling\n');
+        console.log('Subcommands:');
+        for (const [cmd, desc] of Object.entries(help.subcommands)) {
+            console.log(`  ${cmd.padEnd(12)} ${desc}`);
+        }
+        console.log('\nFlags:');
+        for (const [flag, desc] of Object.entries(help.flags)) {
+            console.log(`  ${flag.padEnd(12)} ${desc}`);
+        }
+        console.log('\nExamples:');
+        for (const ex of help.examples) {
+            console.log(`  ${ex}`);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Session command - Manage agent sessions
+ */
+export interface SessionOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: SessionOptions): Promise<void>;

package/dist/cli/commands/session.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * Session command - Manage agent sessions
+ */
+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 session_1 = require("../../session");
+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] || 'list';
+    const actionArgs = args.slice(1);
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        const manager = (0, session_1.getSessionManager)();
+        switch (action) {
+            case 'list':
+                await listSessions(manager, outputFormat);
+                break;
+            case 'create':
+                await createSession(manager, actionArgs, outputFormat);
+                break;
+            case 'get':
+                await getSession(manager, actionArgs, outputFormat);
+                break;
+            case 'delete':
+                await deleteSession(manager, actionArgs, outputFormat);
+                break;
+            case 'export':
+                await exportSession(manager, actionArgs, 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 listSessions(manager, outputFormat) {
+    const sessions = manager.list();
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            sessions: sessions.map((s) => ({
+                id: s.id,
+                messageCount: s.messages.length,
+                createdAt: s.createdAt
+            })),
+            count: sessions.length
+        }));
+    }
+    else {
+        await pretty.heading('Sessions');
+        if (sessions.length === 0) {
+            await pretty.info('No sessions found');
+        }
+        else {
+            for (const session of sessions) {
+                await pretty.plain(`  • ${session.id}`);
+                await pretty.dim(`    Messages: ${session.messages.length}`);
+            }
+        }
+        await pretty.newline();
+        await pretty.info(`Total: ${sessions.length} sessions`);
+    }
+}
+async function createSession(manager, args, outputFormat) {
+    const sessionId = args[0];
+    const session = manager.create({ id: sessionId });
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            created: true,
+            sessionId: session.id
+        }));
+    }
+    else {
+        await pretty.success(`Session created: ${session.id}`);
+    }
+}
+async function getSession(manager, args, outputFormat) {
+    const sessionId = args[0];
+    if (!sessionId) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a session ID'));
+        }
+        else {
+            await pretty.error('Please provide a session ID');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const session = manager.get(sessionId);
+    if (!session) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, `Session not found: ${sessionId}`));
+        }
+        else {
+            await pretty.error(`Session not found: ${sessionId}`);
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+    const messages = session.messages;
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            id: session.id,
+            messages,
+            messageCount: messages.length
+        }));
+    }
+    else {
+        await pretty.heading(`Session: ${session.id}`);
+        await pretty.plain(`Messages: ${messages.length}`);
+        await pretty.newline();
+        for (const msg of messages.slice(-10)) {
+            const content = msg.content || '';
+            await pretty.plain(`  [${msg.role}] ${content.substring(0, 80)}${content.length > 80 ? '...' : ''}`);
+        }
+    }
+}
+async function deleteSession(manager, args, outputFormat) {
+    const sessionId = args[0];
+    if (!sessionId) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a session ID'));
+        }
+        else {
+            await pretty.error('Please provide a session ID');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const deleted = manager.delete(sessionId);
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ deleted, sessionId }));
+    }
+    else {
+        if (deleted) {
+            await pretty.success(`Session deleted: ${sessionId}`);
+        }
+        else {
+            await pretty.warn(`Session not found: ${sessionId}`);
+        }
+    }
+}
+async function exportSession(manager, args, outputFormat) {
+    const sessionId = args[0];
+    if (!sessionId) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a session ID'));
+        }
+        else {
+            await pretty.error('Please provide a session ID');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const session = manager.get(sessionId);
+    if (!session) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, `Session not found: ${sessionId}`));
+        }
+        else {
+            await pretty.error(`Session not found: ${sessionId}`);
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+    const exported = session.toJSON();
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(exported));
+    }
+    else {
+        console.log(JSON.stringify(exported, null, 2));
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'session',
+        subcommands: [
+            { name: 'list', description: 'List all sessions' },
+            { name: 'create [id]', description: 'Create a new session' },
+            { name: 'get <id>', description: 'Get session details' },
+            { name: 'delete <id>', description: 'Delete a session' },
+            { name: 'export <id>', description: 'Export session data' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Session Command');
+        await pretty.plain('Manage agent sessions\n');
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(20)} ${cmd.description}`);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Skills command - Manage agent skills
+ */
+export interface SkillsOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: SkillsOptions): Promise<void>;