overai 1.4.0

package/dist/cli/commands/knowledge.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * Knowledge command - Manage knowledge base
+ */
+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 knowledge_1 = require("../../knowledge");
+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");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+// Singleton knowledge base instance
+let kbInstance = null;
+function getKnowledgeBase() {
+    if (!kbInstance) {
+        kbInstance = new knowledge_1.BaseKnowledgeBase();
+    }
+    return kbInstance;
+}
+async function execute(args, options) {
+    const action = args[0] || 'help';
+    const actionArgs = args.slice(1);
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        const kb = getKnowledgeBase();
+        switch (action) {
+            case 'add':
+                await addKnowledge(kb, actionArgs, outputFormat);
+                break;
+            case 'search':
+                await searchKnowledge(kb, actionArgs, outputFormat);
+                break;
+            case 'list':
+                await listKnowledge(kb, 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 addKnowledge(kb, args, outputFormat) {
+    const source = args[0];
+    if (!source) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a file path or text content'));
+        }
+        else {
+            await pretty.error('Please provide a file path or text content');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    let content;
+    let sourceName;
+    // Check if it's a file path
+    if (fs.existsSync(source)) {
+        content = fs.readFileSync(source, 'utf-8');
+        sourceName = path.basename(source);
+    }
+    else {
+        // Treat as direct text content
+        content = args.join(' ');
+        sourceName = 'text-input';
+    }
+    const knowledge = {
+        id: (0, crypto_1.randomUUID)(),
+        type: 'text',
+        content,
+        metadata: { source: sourceName, addedAt: new Date().toISOString() }
+    };
+    kb.addKnowledge(knowledge);
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            added: true,
+            id: knowledge.id,
+            source: sourceName,
+            contentLength: content.length
+        }));
+    }
+    else {
+        await pretty.success(`Knowledge added from: ${sourceName}`);
+        await pretty.dim(`Content length: ${content.length} characters`);
+    }
+}
+async function searchKnowledge(kb, args, outputFormat) {
+    const query = args.join(' ');
+    if (!query) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a search query'));
+        }
+        else {
+            await pretty.error('Please provide a search query');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const results = kb.searchKnowledge(query);
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            query,
+            results: results.map(r => ({
+                id: r.id,
+                content: r.content,
+                metadata: r.metadata
+            })),
+            count: results.length
+        }));
+    }
+    else {
+        await pretty.heading(`Search Results for: "${query}"`);
+        if (results.length === 0) {
+            await pretty.info('No matching knowledge found');
+        }
+        else {
+            for (const result of results) {
+                const contentStr = typeof result.content === 'string' ? result.content : JSON.stringify(result.content);
+                await pretty.plain(`  • ${contentStr.substring(0, 100)}${contentStr.length > 100 ? '...' : ''}`);
+                if (result.metadata?.source) {
+                    await pretty.dim(`    Source: ${result.metadata.source}`);
+                }
+            }
+        }
+        await pretty.newline();
+        await pretty.info(`Found: ${results.length} results`);
+    }
+}
+async function listKnowledge(kb, outputFormat) {
+    // Search with empty string to get all
+    const entries = kb.searchKnowledge('');
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            entries: entries.map((e) => ({
+                id: e.id,
+                type: e.type,
+                contentPreview: typeof e.content === 'string' ? e.content.substring(0, 100) : JSON.stringify(e.content).substring(0, 100),
+                source: e.metadata?.source
+            })),
+            count: entries.length
+        }));
+    }
+    else {
+        await pretty.heading('Knowledge Base Entries');
+        if (entries.length === 0) {
+            await pretty.info('No knowledge entries found');
+        }
+        else {
+            for (const entry of entries) {
+                const contentStr = typeof entry.content === 'string' ? entry.content : JSON.stringify(entry.content);
+                await pretty.plain(`  • ${contentStr.substring(0, 80)}${contentStr.length > 80 ? '...' : ''}`);
+                if (entry.metadata?.source) {
+                    await pretty.dim(`    Source: ${entry.metadata.source}`);
+                }
+            }
+        }
+        await pretty.newline();
+        await pretty.info(`Total: ${entries.length} entries`);
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'knowledge',
+        subcommands: [
+            { name: 'add <file|text>', description: 'Add knowledge from file or text' },
+            { name: 'search <query>', description: 'Search knowledge base' },
+            { name: 'list', description: 'List all knowledge entries' },
+            { name: 'clear', description: 'Clear all knowledge' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Knowledge Command');
+        await pretty.plain('Manage knowledge base for RAG\n');
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(25)} ${cmd.description}`);
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+/**
+ * LLM Command - AI SDK provider management and testing
+ *
+ * Subcommands:
+ * - providers: List available AI SDK providers
+ * - test: Test connectivity to a provider
+ * - validate: Validate provider configuration
+ * - run: Run a prompt with a specific model
+ */
+export interface LLMOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    model?: string;
+    stream?: boolean;
+    timeout?: number;
+    provider?: string;
+    schema?: string;
+    tool?: string;
+}
+export declare function execute(args: string[], options: LLMOptions): Promise<void>;