overai 1.4.0

package/dist/cli/commands/context.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Context command - Manage conversation context
+ */
+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 context_1 = require("../../agent/context");
+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 'chat':
+                await chatWithContext(actionArgs, options, config, outputFormat);
+                break;
+            case 'summarize':
+                await summarizeContext(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 chatWithContext(args, options, config, outputFormat) {
+    const message = args.join(' ');
+    if (!message) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a message'));
+        }
+        else {
+            await pretty.error('Please provide a message');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const startTime = Date.now();
+    if (outputFormat !== 'json') {
+        await pretty.info('Processing with context...');
+    }
+    const agent = (0, context_1.createContextAgent)({
+        llm: config.model,
+        instructions: 'You are a helpful assistant with context awareness.',
+        contextWindow: options.maxMessages || 10,
+        verbose: options.verbose
+    });
+    const result = await agent.chat(message);
+    const duration = Date.now() - startTime;
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            message,
+            response: result.text
+        }, {
+            duration_ms: duration,
+            model: config.model
+        }));
+    }
+    else {
+        await pretty.heading('Response');
+        await pretty.plain(result.text);
+        await pretty.newline();
+        await pretty.success(`Completed in ${duration}ms`);
+    }
+}
+async function summarizeContext(args, options, config, outputFormat) {
+    const context = args.join(' ');
+    if (!context) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide context to summarize'));
+        }
+        else {
+            await pretty.error('Please provide context to summarize');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const startTime = Date.now();
+    if (outputFormat !== 'json') {
+        await pretty.info('Summarizing context...');
+    }
+    const agent = (0, context_1.createContextAgent)({
+        llm: config.model,
+        instructions: 'You are a summarization assistant. Provide concise summaries.',
+        verbose: options.verbose
+    });
+    // Use chat to summarize
+    const result = await agent.chat(`Please summarize the following text concisely:\n\n${context}`);
+    const duration = Date.now() - startTime;
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            originalLength: context.length,
+            summary: result.text
+        }, {
+            duration_ms: duration,
+            model: config.model
+        }));
+    }
+    else {
+        await pretty.heading('Summary');
+        await pretty.plain(result.text);
+        await pretty.newline();
+        await pretty.dim(`Original: ${context.length} chars`);
+        await pretty.success(`Summarized in ${duration}ms`);
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'context',
+        subcommands: [
+            { name: 'chat <message>', description: 'Chat with context management' },
+            { name: 'summarize <text>', description: 'Summarize context' },
+            { name: 'help', description: 'Show this help' }
+        ],
+        flags: [
+            { name: '--max-messages', description: 'Maximum messages to keep in context' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Context Command');
+        await pretty.plain('Manage conversation context\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/cost.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CLI command: cost
+ * Token usage and cost tracking
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/cost.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * CLI command: cost
+ * Token usage and cost tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const cost_tracker_1 = require("../features/cost-tracker");
+let tracker = null;
+function getTracker() {
+    if (!tracker) {
+        tracker = (0, cost_tracker_1.createCostTracker)();
+    }
+    return tracker;
+}
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'summary':
+            await handleSummary(isJson);
+            break;
+        case 'add':
+            await handleAdd(args.slice(1), options, isJson);
+            break;
+        case 'reset':
+            await handleReset(isJson);
+            break;
+        case 'pricing':
+            await handlePricing(args.slice(1), isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleSummary(isJson) {
+    const t = getTracker();
+    const stats = t.getStats();
+    const breakdown = t.getBreakdownByModel();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, stats, breakdown }, null, 2));
+    }
+    else {
+        console.log(t.getSummary());
+        if (Object.keys(breakdown).length > 0) {
+            console.log('\nBreakdown by model:');
+            for (const [model, data] of Object.entries(breakdown)) {
+                console.log(`  ${model}: ${data.tokens} tokens, ${(0, cost_tracker_1.formatCost)(data.cost)}, ${data.requests} requests`);
+            }
+        }
+    }
+}
+async function handleAdd(args, options, isJson) {
+    const model = args[0] || 'gpt-4o-mini';
+    const inputTokens = parseInt(args[1] || '0');
+    const outputTokens = parseInt(args[2] || '0');
+    if (isNaN(inputTokens) || isNaN(outputTokens)) {
+        console.error('Error: Invalid token counts');
+        process.exit(1);
+    }
+    const t = getTracker();
+    const request = t.addUsage(model, inputTokens, outputTokens);
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, request }, null, 2));
+    }
+    else {
+        console.log(`✓ Added usage: ${model}`);
+        console.log(`  Input: ${inputTokens} tokens`);
+        console.log(`  Output: ${outputTokens} tokens`);
+        console.log(`  Cost: ${(0, cost_tracker_1.formatCost)(request.cost)}`);
+    }
+}
+async function handleReset(isJson) {
+    const t = getTracker();
+    t.reset();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, message: 'Cost tracker reset' }));
+    }
+    else {
+        console.log('✓ Cost tracker reset');
+    }
+}
+async function handlePricing(args, isJson) {
+    const model = args[0];
+    if (model) {
+        const pricing = cost_tracker_1.MODEL_PRICING[model] || cost_tracker_1.MODEL_PRICING['default'];
+        if (isJson) {
+            console.log(JSON.stringify({ success: true, model, pricing }, null, 2));
+        }
+        else {
+            console.log(`Pricing for ${model}:`);
+            console.log(`  Input: $${pricing.inputCostPer1k}/1K tokens`);
+            console.log(`  Output: $${pricing.outputCostPer1k}/1K tokens`);
+        }
+    }
+    else {
+        if (isJson) {
+            console.log(JSON.stringify({ success: true, pricing: cost_tracker_1.MODEL_PRICING }, null, 2));
+        }
+        else {
+            console.log('Model Pricing (per 1K tokens):\n');
+            for (const [name, pricing] of Object.entries(cost_tracker_1.MODEL_PRICING)) {
+                if (name === 'default')
+                    continue;
+                console.log(`  ${name.padEnd(30)} in: $${pricing.inputCostPer1k.toFixed(5)}  out: $${pricing.outputCostPer1k.toFixed(5)}`);
+            }
+        }
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'cost',
+        description: 'Token usage and cost tracking',
+        subcommands: {
+            summary: 'Show cost summary',
+            add: 'Add token usage',
+            reset: 'Reset cost tracker',
+            pricing: 'Show model pricing'
+        },
+        flags: {
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'overai cost summary',
+            'overai cost add gpt-4o 1000 500',
+            'overai cost pricing',
+            'overai cost pricing gpt-4o',
+            'overai cost reset'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Cost - Token usage and cost tracking\n');
+        console.log('Subcommands:');
+        for (const [cmd, desc] of Object.entries(help.subcommands)) {
+            console.log(`  ${cmd.padEnd(12)} ${desc}`);
+        }
+        console.log('\nExamples:');
+        for (const ex of help.examples) {
+            console.log(`  ${ex}`);
+        }
+    }
+}

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

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

package/dist/cli/commands/db.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * DB command - Database adapter 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 'adapters':
+                await listAdapters(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: 'Database Adapters',
+        description: 'Database adapters for persistence and session storage',
+        adapters: [
+            { name: 'SQLiteAdapter', description: 'SQLite database adapter' },
+            { name: 'UpstashRedisAdapter', description: 'Upstash Redis adapter' },
+            { name: 'MemoryRedisAdapter', description: 'In-memory Redis-compatible adapter' },
+            { name: 'NeonPostgresAdapter', description: 'Neon PostgreSQL adapter' },
+            { name: 'MemoryPostgresAdapter', description: 'In-memory PostgreSQL-compatible adapter' },
+            { name: 'PostgresSessionStorage', description: 'PostgreSQL session storage' }
+        ],
+        capabilities: [
+            'Store conversation history',
+            'Persist agent state',
+            'Session management',
+            'Message storage and retrieval',
+            'Trace logging'
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(info));
+    }
+    else {
+        await pretty.heading('Database Adapters');
+        await pretty.plain(info.description);
+        await pretty.newline();
+        await pretty.plain('Available Adapters:');
+        for (const a of info.adapters) {
+            await pretty.plain(`  • ${a.name}: ${a.description}`);
+        }
+        await pretty.newline();
+        await pretty.plain('Capabilities:');
+        for (const cap of info.capabilities) {
+            await pretty.plain(`  • ${cap}`);
+        }
+    }
+}
+async function listAdapters(outputFormat) {
+    const adapters = [
+        { name: 'sqlite', description: 'SQLite database', available: true },
+        { name: 'redis', description: 'Redis (Upstash)', available: true },
+        { name: 'postgres', description: 'PostgreSQL (Neon)', available: true },
+        { name: 'memory', description: 'In-memory adapters', available: true }
+    ];
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ adapters }));
+    }
+    else {
+        await pretty.heading('Database Adapters');
+        for (const a of adapters) {
+            const status = a.available ? '✓' : '✗';
+            await pretty.plain(`  ${status} ${a.name.padEnd(15)} ${a.description}`);
+        }
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'db',
+        description: 'Database adapter management',
+        subcommands: [
+            { name: 'info', description: 'Show database adapter information' },
+            { name: 'adapters', description: 'List available database adapters' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Database 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/embed.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Embed Command - Generate embeddings using AI SDK (preferred) or native provider
+ *
+ * Subcommands:
+ * - text: Embed a single text or multiple texts
+ * - file: Embed contents of a file
+ * - query: Find similar texts using embeddings
+ */
+export interface EmbedOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    model?: string;
+    provider?: string;
+    backend?: 'ai-sdk' | 'native' | 'auto';
+    dimensions?: number;
+    file?: string;
+    save?: string;
+}
+export declare function execute(args: string[], options: EmbedOptions): Promise<void>;