overai 1.4.0

package/dist/cli/commands/skills.js

@@ -0,0 +1,256 @@
+"use strict";
+/**
+ * Skills command - Manage agent skills
+ */
+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 skills_1 = require("../../skills");
+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 searchPath = actionArgs[0] || '.';
+        const manager = (0, skills_1.createSkillManager)({ paths: [searchPath] });
+        switch (action) {
+            case 'list':
+                await listSkills(manager, outputFormat);
+                break;
+            case 'discover':
+                await discoverSkills(manager, actionArgs, outputFormat);
+                break;
+            case 'validate':
+                await validateSkill(manager, actionArgs, outputFormat);
+                break;
+            case 'info':
+                await skillInfo(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 listSkills(manager, outputFormat) {
+    const skills = manager.list();
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            skills: skills.map((s) => ({
+                name: s.metadata.name,
+                description: s.metadata.description,
+                path: s.path
+            })),
+            count: skills.length
+        }));
+    }
+    else {
+        await pretty.heading('Available Skills');
+        if (skills.length === 0) {
+            await pretty.info('No skills loaded');
+            await pretty.dim('Run "praisonai-ts skills discover <path>" to discover skills');
+        }
+        else {
+            for (const skill of skills) {
+                await pretty.plain(`  • ${skill.metadata.name}`);
+                if (skill.metadata.description) {
+                    await pretty.dim(`    ${skill.metadata.description}`);
+                }
+            }
+        }
+        await pretty.newline();
+        await pretty.info(`Total: ${skills.length} skills`);
+    }
+}
+async function discoverSkills(manager, args, outputFormat) {
+    const searchPath = args[0] || '.';
+    const discovered = await manager.discover();
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            discovered: discovered.map((s) => ({
+                name: s.metadata.name,
+                description: s.metadata.description,
+                path: s.path
+            })),
+            count: discovered.length,
+            searchPath
+        }));
+    }
+    else {
+        await pretty.heading(`Discovered Skills in: ${searchPath}`);
+        if (discovered.length === 0) {
+            await pretty.info('No skills found');
+        }
+        else {
+            for (const skill of discovered) {
+                await pretty.plain(`  • ${skill.metadata.name}`);
+                if (skill.metadata.description) {
+                    await pretty.dim(`    ${skill.metadata.description}`);
+                }
+                if (skill.path) {
+                    await pretty.dim(`    Path: ${skill.path}`);
+                }
+            }
+        }
+        await pretty.newline();
+        await pretty.info(`Found: ${discovered.length} skills`);
+    }
+}
+async function validateSkill(manager, args, outputFormat) {
+    const skillPath = args[0];
+    if (!skillPath) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a skill path'));
+        }
+        else {
+            await pretty.error('Please provide a skill path');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    try {
+        // Load the skill first, then validate
+        const skill = await manager.loadSkill(skillPath);
+        const result = manager.validate(skill);
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                valid: result.valid,
+                path: skillPath,
+                errors: result.errors || []
+            }));
+        }
+        else {
+            if (result.valid) {
+                await pretty.success(`Skill is valid: ${skillPath}`);
+            }
+            else {
+                await pretty.error(`Skill validation failed: ${skillPath}`);
+                if (result.errors) {
+                    for (const err of result.errors) {
+                        await pretty.plain(`  ❌ ${err}`);
+                    }
+                }
+            }
+        }
+    }
+    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(`Validation error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+}
+async function skillInfo(manager, args, outputFormat) {
+    const skillName = args[0];
+    if (!skillName) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a skill name'));
+        }
+        else {
+            await pretty.error('Please provide a skill name');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const skill = manager.get(skillName);
+    if (!skill) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, `Skill not found: ${skillName}`));
+        }
+        else {
+            await pretty.error(`Skill not found: ${skillName}`);
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            name: skill.metadata.name,
+            description: skill.metadata.description,
+            path: skill.path,
+            metadata: skill.metadata
+        }));
+    }
+    else {
+        await pretty.heading(`Skill: ${skill.metadata.name}`);
+        await pretty.keyValue({
+            'Name': skill.metadata.name,
+            'Description': skill.metadata.description || 'No description',
+            'Path': skill.path || 'N/A'
+        });
+        if (skill.metadata.metadata && Object.keys(skill.metadata.metadata).length > 0) {
+            await pretty.newline();
+            await pretty.plain('Metadata:');
+            await pretty.plain(JSON.stringify(skill.metadata.metadata, null, 2));
+        }
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'skills',
+        subcommands: [
+            { name: 'list', description: 'List loaded skills' },
+            { name: 'discover <path>', description: 'Discover skills in directory' },
+            { name: 'validate <path>', description: 'Validate a skill' },
+            { name: 'info <name>', description: 'Show skill information' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Skills Command');
+        await pretty.plain('Manage agent skills\n');
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(20)} ${cmd.description}`);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Telemetry command - Usage monitoring and analytics
+ */
+export interface TelemetryOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: TelemetryOptions): Promise<void>;

package/dist/cli/commands/telemetry.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Telemetry command - Usage monitoring and analytics
+ */
+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 telemetry_1 = require("../../telemetry");
+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] || 'status';
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        switch (action) {
+            case 'enable':
+                (0, telemetry_1.enableTelemetry)();
+                if (outputFormat === 'json') {
+                    (0, json_1.outputJson)((0, json_1.formatSuccess)({ enabled: true }));
+                }
+                else {
+                    await pretty.success('Telemetry enabled');
+                }
+                break;
+            case 'disable':
+                (0, telemetry_1.disableTelemetry)();
+                if (outputFormat === 'json') {
+                    (0, json_1.outputJson)((0, json_1.formatSuccess)({ enabled: false }));
+                }
+                else {
+                    await pretty.success('Telemetry disabled');
+                }
+                break;
+            case 'status':
+                await showStatus(outputFormat);
+                break;
+            case 'clear':
+                (0, telemetry_1.cleanupTelemetry)();
+                if (outputFormat === 'json') {
+                    (0, json_1.outputJson)((0, json_1.formatSuccess)({ cleared: true }));
+                }
+                else {
+                    await pretty.success('Telemetry data cleared');
+                }
+                break;
+            case 'export':
+                await exportTelemetry(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 showStatus(outputFormat) {
+    const telemetry = (0, telemetry_1.getTelemetry)();
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            enabled: telemetry.isEnabled()
+        }));
+    }
+    else {
+        await pretty.heading('Telemetry Status');
+        await pretty.plain(`Enabled: ${telemetry.isEnabled() ? 'Yes' : 'No'}`);
+    }
+}
+async function exportTelemetry(outputFormat) {
+    const telemetry = (0, telemetry_1.getTelemetry)();
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            enabled: telemetry.isEnabled(),
+            exportedAt: new Date().toISOString()
+        }));
+    }
+    else {
+        await pretty.plain(`Telemetry enabled: ${telemetry.isEnabled()}`);
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'telemetry',
+        subcommands: [
+            { name: 'status', description: 'Show telemetry status' },
+            { name: 'enable', description: 'Enable telemetry collection' },
+            { name: 'disable', description: 'Disable telemetry collection' },
+            { name: 'clear', description: 'Clear collected telemetry data' },
+            { name: 'export', description: 'Export telemetry data' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Telemetry Command');
+        await pretty.plain('Usage monitoring and analytics\n');
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(15)} ${cmd.description}`);
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Tools command - List, manage, and test AI SDK tools
+ *
+ * Subcommands:
+ *   list     - List all available tools
+ *   info     - Get detailed info about a tool
+ *   doctor   - Check tool dependencies and env vars
+ *   example  - Show usage example for a tool
+ *   add      - Register a custom tool from npm/local
+ *   test     - Test a tool (dry-run or live)
+ */
+export interface ToolsOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    live?: boolean;
+    tag?: string;
+}
+export declare function execute(args: string[], options: ToolsOptions): Promise<void>;