overai 1.4.0

package/dist/cli/commands/autonomy.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * CLI command: autonomy
+ * Autonomy mode management for agent actions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const autonomy_mode_1 = require("../features/autonomy-mode");
+let manager = null;
+function getManager() {
+    if (!manager) {
+        manager = (0, autonomy_mode_1.createAutonomyManager)();
+    }
+    return manager;
+}
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'status':
+            await handleStatus(isJson);
+            break;
+        case 'set':
+            await handleSet(args.slice(1), isJson);
+            break;
+        case 'policies':
+            await handlePolicies(args.slice(1), isJson);
+            break;
+        case 'reset':
+            await handleReset(isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleStatus(isJson) {
+    const mgr = getManager();
+    const summary = mgr.getSummary();
+    const mode = mgr.getMode();
+    const actionCount = mgr.getActionCount();
+    if (isJson) {
+        console.log(JSON.stringify({
+            success: true,
+            mode,
+            actionCount,
+            policies: autonomy_mode_1.MODE_POLICIES[mode]
+        }, null, 2));
+    }
+    else {
+        console.log(summary);
+    }
+}
+async function handleSet(args, isJson) {
+    const mode = args[0];
+    if (!mode || !['suggest', 'auto_edit', 'full_auto'].includes(mode)) {
+        console.error('Error: Valid mode required (suggest, auto_edit, full_auto)');
+        process.exit(1);
+    }
+    const mgr = getManager();
+    mgr.setMode(mode);
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, mode }));
+    }
+    else {
+        console.log(`✓ Autonomy mode set to: ${mode}`);
+        console.log('\nPolicies for this mode:');
+        for (const policy of autonomy_mode_1.MODE_POLICIES[mode]) {
+            const status = policy.requiresApproval ? '⚠️ requires approval' : '✓ auto-approved';
+            console.log(`  ${policy.action}: ${status}`);
+        }
+    }
+}
+async function handlePolicies(args, isJson) {
+    const mode = args[0] || 'suggest';
+    if (!['suggest', 'auto_edit', 'full_auto'].includes(mode)) {
+        console.error('Error: Valid mode required (suggest, auto_edit, full_auto)');
+        process.exit(1);
+    }
+    const policies = autonomy_mode_1.MODE_POLICIES[mode];
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, mode, policies }, null, 2));
+    }
+    else {
+        console.log(`Policies for mode: ${mode}\n`);
+        for (const policy of policies) {
+            const status = policy.requiresApproval ? '⚠️ requires approval' : '✓ auto-approved';
+            console.log(`  ${policy.action.padEnd(20)} ${status}`);
+        }
+    }
+}
+async function handleReset(isJson) {
+    const mgr = getManager();
+    mgr.clearRemembered();
+    mgr.resetActionCount();
+    mgr.setMode('suggest');
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, message: 'Autonomy state reset' }));
+    }
+    else {
+        console.log('✓ Autonomy state reset');
+        console.log('  Mode: suggest');
+        console.log('  Remembered decisions: cleared');
+        console.log('  Action count: 0');
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'autonomy',
+        description: 'Autonomy mode management for agent actions',
+        subcommands: {
+            status: 'Show current autonomy status',
+            set: 'Set autonomy mode',
+            policies: 'Show policies for a mode',
+            reset: 'Reset autonomy state'
+        },
+        modes: {
+            suggest: 'Requires approval for most actions (default)',
+            auto_edit: 'Auto-approves file edits, requires approval for others',
+            full_auto: 'Auto-approves most actions (use with caution)'
+        },
+        flags: {
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts autonomy status',
+            'praisonai-ts autonomy set suggest',
+            'praisonai-ts autonomy set auto_edit',
+            'praisonai-ts autonomy set full_auto',
+            'praisonai-ts autonomy policies suggest',
+            'praisonai-ts autonomy reset'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Autonomy - Agent action approval management\n');
+        console.log('Subcommands:');
+        for (const [cmd, desc] of Object.entries(help.subcommands)) {
+            console.log(`  ${cmd.padEnd(12)} ${desc}`);
+        }
+        console.log('\nModes:');
+        for (const [mode, desc] of Object.entries(help.modes)) {
+            console.log(`  ${mode.padEnd(12)} ${desc}`);
+        }
+        console.log('\nExamples:');
+        for (const ex of help.examples) {
+            console.log(`  ${ex}`);
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Benchmark Command - Performance benchmarks for AI SDK vs Native backends
+ *
+ * Measures:
+ * - Import time (cold start)
+ * - Memory usage
+ * - First-call latency
+ * - Streaming throughput
+ * - Embedding throughput
+ */
+export interface BenchmarkOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    iterations?: number;
+    backend?: 'ai-sdk' | 'native' | 'both';
+    real?: boolean;
+}
+export declare function execute(args: string[], options: BenchmarkOptions): Promise<void>;

package/dist/cli/commands/benchmark.js

@@ -0,0 +1,484 @@
+"use strict";
+/**
+ * Benchmark Command - Performance benchmarks for AI SDK vs Native backends
+ *
+ * Measures:
+ * - Import time (cold start)
+ * - Memory usage
+ * - First-call latency
+ * - Streaming throughput
+ * - Embedding throughput
+ */
+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 errors_1 = require("../output/errors");
+const EXIT_CODES = {
+    SUCCESS: 0,
+    GENERAL_ERROR: 1,
+    INVALID_ARGS: 2,
+};
+function formatBenchmarkSuccess(data, meta) {
+    return {
+        success: true,
+        data,
+        meta,
+    };
+}
+function calculateStats(values) {
+    if (values.length === 0)
+        return { mean: 0, min: 0, max: 0, p95: 0, stdDev: 0 };
+    const sorted = [...values].sort((a, b) => a - b);
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    const min = sorted[0];
+    const max = sorted[sorted.length - 1];
+    const p95Index = Math.floor(sorted.length * 0.95);
+    const p95 = sorted[p95Index] || max;
+    const squaredDiffs = values.map(v => Math.pow(v - mean, 2));
+    const avgSquaredDiff = squaredDiffs.reduce((a, b) => a + b, 0) / values.length;
+    const stdDev = Math.sqrt(avgSquaredDiff);
+    return { mean, min, max, p95, stdDev };
+}
+async function execute(args, options) {
+    const subcommand = args[0] || 'run';
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    switch (subcommand) {
+        case 'run':
+            await runAllBenchmarks(args.slice(1), options, outputFormat);
+            break;
+        case 'import':
+            await importBenchmark(args.slice(1), options, outputFormat);
+            break;
+        case 'memory':
+            await memoryBenchmark(args.slice(1), options, outputFormat);
+            break;
+        case 'latency':
+            await latencyBenchmark(args.slice(1), options, outputFormat);
+            break;
+        case 'streaming':
+            await streamingBenchmark(args.slice(1), options, outputFormat);
+            break;
+        case 'embedding':
+            await embeddingBenchmark(args.slice(1), options, outputFormat);
+            break;
+        default:
+            if (outputFormat === 'json') {
+                (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.INVALID_ARGS, `Unknown subcommand: ${subcommand}`));
+            }
+            else {
+                await pretty.error(`Unknown subcommand: ${subcommand}`);
+                await pretty.info('Available subcommands: run, import, memory, latency, streaming, embedding');
+            }
+            process.exit(EXIT_CODES.INVALID_ARGS);
+    }
+}
+/**
+ * Run all benchmarks
+ */
+async function runAllBenchmarks(args, options, outputFormat) {
+    const iterations = options.iterations || 5;
+    const results = [];
+    if (outputFormat !== 'json') {
+        await pretty.success('Running All Benchmarks');
+        console.log(`Iterations: ${iterations}`);
+        console.log('');
+    }
+    // Import benchmark
+    const importResult = await measureImportTime(iterations);
+    results.push(importResult);
+    // Memory benchmark
+    const memoryResult = await measureMemory(iterations);
+    results.push(memoryResult);
+    // Latency benchmark (mock mode unless --real)
+    if (options.real) {
+        const latencyResult = await measureLatency(iterations, true);
+        results.push(latencyResult);
+    }
+    else {
+        const latencyResult = await measureLatency(iterations, false);
+        results.push(latencyResult);
+    }
+    const report = {
+        timestamp: new Date().toISOString(),
+        results,
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)(formatBenchmarkSuccess(report));
+    }
+    else {
+        printBenchmarkTable(results);
+        console.log('');
+        await pretty.info('Use --real flag to run benchmarks with real API calls');
+    }
+}
+/**
+ * Benchmark import time
+ */
+async function importBenchmark(args, options, outputFormat) {
+    const iterations = options.iterations || 10;
+    if (outputFormat !== 'json') {
+        await pretty.success('Import Time Benchmark');
+        console.log(`Iterations: ${iterations}`);
+        console.log('');
+    }
+    const results = [];
+    // Measure core import (without AI SDK)
+    const coreResult = await measureCoreImportTime(iterations);
+    results.push(coreResult);
+    // Measure AI SDK import
+    const aiSdkResult = await measureAISDKImportTime(iterations);
+    results.push(aiSdkResult);
+    // Measure full import (with AI SDK loaded)
+    const fullResult = await measureImportTime(iterations);
+    results.push(fullResult);
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)(formatBenchmarkSuccess({ results }));
+    }
+    else {
+        printBenchmarkTable(results);
+        console.log('');
+        // Show comparison
+        const overhead = aiSdkResult.mean;
+        console.log(`AI SDK import overhead: ${overhead.toFixed(2)}ms`);
+        console.log(`Core import (no AI SDK): ${coreResult.mean.toFixed(2)}ms`);
+    }
+}
+/**
+ * Benchmark memory usage
+ */
+async function memoryBenchmark(args, options, outputFormat) {
+    const iterations = options.iterations || 5;
+    if (outputFormat !== 'json') {
+        await pretty.success('Memory Usage Benchmark');
+        console.log(`Iterations: ${iterations}`);
+        console.log('');
+    }
+    const result = await measureMemory(iterations);
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)(formatBenchmarkSuccess({ result }));
+    }
+    else {
+        printBenchmarkTable([result]);
+    }
+}
+/**
+ * Benchmark first-call latency
+ */
+async function latencyBenchmark(args, options, outputFormat) {
+    const iterations = options.iterations || 3;
+    const useReal = options.real || false;
+    if (outputFormat !== 'json') {
+        await pretty.success('First-Call Latency Benchmark');
+        console.log(`Iterations: ${iterations}`);
+        console.log(`Mode: ${useReal ? 'Real API' : 'Mock'}`);
+        console.log('');
+    }
+    const result = await measureLatency(iterations, useReal);
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)(formatBenchmarkSuccess({ result }));
+    }
+    else {
+        printBenchmarkTable([result]);
+        if (!useReal) {
+            console.log('');
+            await pretty.info('Use --real flag to measure with real API calls');
+        }
+    }
+}
+/**
+ * Benchmark streaming throughput
+ */
+async function streamingBenchmark(args, options, outputFormat) {
+    const iterations = options.iterations || 3;
+    const useReal = options.real || false;
+    if (outputFormat !== 'json') {
+        await pretty.success('Streaming Throughput Benchmark');
+        console.log(`Iterations: ${iterations}`);
+        console.log(`Mode: ${useReal ? 'Real API' : 'Mock'}`);
+        console.log('');
+    }
+    if (!useReal) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)(formatBenchmarkSuccess({
+                message: 'Streaming benchmark requires --real flag',
+                result: null
+            }));
+        }
+        else {
+            await pretty.info('Streaming benchmark requires --real flag for meaningful results');
+        }
+        return;
+    }
+    const result = await measureStreaming(iterations);
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)(formatBenchmarkSuccess({ result }));
+    }
+    else {
+        printBenchmarkTable([result]);
+    }
+}
+/**
+ * Benchmark embedding throughput
+ */
+async function embeddingBenchmark(args, options, outputFormat) {
+    const iterations = options.iterations || 3;
+    const useReal = options.real || false;
+    if (outputFormat !== 'json') {
+        await pretty.success('Embedding Throughput Benchmark');
+        console.log(`Iterations: ${iterations}`);
+        console.log(`Mode: ${useReal ? 'Real API' : 'Mock'}`);
+        console.log('');
+    }
+    if (!useReal) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)(formatBenchmarkSuccess({
+                message: 'Embedding benchmark requires --real flag',
+                result: null
+            }));
+        }
+        else {
+            await pretty.info('Embedding benchmark requires --real flag for meaningful results');
+        }
+        return;
+    }
+    const result = await measureEmbedding(iterations);
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)(formatBenchmarkSuccess({ result }));
+    }
+    else {
+        printBenchmarkTable([result]);
+    }
+}
+// Measurement functions
+async function measureCoreImportTime(iterations) {
+    const times = [];
+    for (let i = 0; i < iterations; i++) {
+        // Clear require cache for accurate measurement
+        const cacheKeys = Object.keys(require.cache).filter(k => k.includes('praisonai-ts') && !k.includes('node_modules'));
+        cacheKeys.forEach(k => delete require.cache[k]);
+        const start = performance.now();
+        // Import just the Agent class
+        await Promise.resolve().then(() => __importStar(require('../../agent/simple')));
+        const end = performance.now();
+        times.push(end - start);
+    }
+    const stats = calculateStats(times);
+    return {
+        name: 'Core Import (Agent)',
+        iterations,
+        ...stats,
+        unit: 'ms',
+    };
+}
+async function measureAISDKImportTime(iterations) {
+    const times = [];
+    for (let i = 0; i < iterations; i++) {
+        // Clear AI SDK from cache
+        const cacheKeys = Object.keys(require.cache).filter(k => k.includes('ai'));
+        cacheKeys.forEach(k => delete require.cache[k]);
+        const start = performance.now();
+        try {
+            await Promise.resolve().then(() => __importStar(require('ai')));
+        }
+        catch {
+            // AI SDK not installed
+        }
+        const end = performance.now();
+        times.push(end - start);
+    }
+    const stats = calculateStats(times);
+    return {
+        name: 'AI SDK Import',
+        iterations,
+        ...stats,
+        unit: 'ms',
+    };
+}
+async function measureImportTime(iterations) {
+    const times = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        // Import the main module
+        await Promise.resolve().then(() => __importStar(require('../../index')));
+        const end = performance.now();
+        times.push(end - start);
+    }
+    const stats = calculateStats(times);
+    return {
+        name: 'Full Import',
+        iterations,
+        ...stats,
+        unit: 'ms',
+    };
+}
+async function measureMemory(iterations) {
+    const measurements = [];
+    for (let i = 0; i < iterations; i++) {
+        // Force GC if available
+        if (global.gc)
+            global.gc();
+        const before = process.memoryUsage().heapUsed;
+        // Import and create an agent
+        const { Agent } = await Promise.resolve().then(() => __importStar(require('../../agent/simple')));
+        const agent = new Agent({ instructions: 'Test agent' });
+        const after = process.memoryUsage().heapUsed;
+        measurements.push((after - before) / 1024 / 1024); // Convert to MB
+        // Keep reference to prevent GC
+        void agent;
+    }
+    const stats = calculateStats(measurements);
+    return {
+        name: 'Memory (Agent creation)',
+        iterations,
+        ...stats,
+        unit: 'MB',
+    };
+}
+async function measureLatency(iterations, useReal) {
+    const times = [];
+    if (useReal) {
+        const { Agent } = await Promise.resolve().then(() => __importStar(require('../../agent/simple')));
+        for (let i = 0; i < iterations; i++) {
+            const agent = new Agent({
+                instructions: 'Say "OK" and nothing else.',
+                stream: false,
+            });
+            const start = performance.now();
+            try {
+                await agent.chat('Hi');
+            }
+            catch {
+                // API error, skip
+            }
+            const end = performance.now();
+            times.push(end - start);
+        }
+    }
+    else {
+        // Mock latency measurement
+        for (let i = 0; i < iterations; i++) {
+            const start = performance.now();
+            // Simulate backend resolution
+            const { resolveBackend } = await Promise.resolve().then(() => __importStar(require('../../llm/backend-resolver')));
+            await resolveBackend('openai/gpt-4o-mini');
+            const end = performance.now();
+            times.push(end - start);
+        }
+    }
+    const stats = calculateStats(times);
+    return {
+        name: useReal ? 'First-Call Latency (Real)' : 'Backend Resolution',
+        iterations,
+        ...stats,
+        unit: 'ms',
+    };
+}
+async function measureStreaming(iterations) {
+    const throughputs = [];
+    const { Agent } = await Promise.resolve().then(() => __importStar(require('../../agent/simple')));
+    for (let i = 0; i < iterations; i++) {
+        const agent = new Agent({
+            instructions: 'Count from 1 to 20.',
+            stream: true,
+        });
+        let tokenCount = 0;
+        const start = performance.now();
+        try {
+            // Note: This is a simplified measurement
+            const response = await agent.chat('Count');
+            tokenCount = response.split(/\s+/).length;
+        }
+        catch {
+            // API error
+        }
+        const end = performance.now();
+        const duration = (end - start) / 1000; // seconds
+        throughputs.push(tokenCount / duration);
+    }
+    const stats = calculateStats(throughputs);
+    return {
+        name: 'Streaming Throughput',
+        iterations,
+        ...stats,
+        unit: 'tokens/sec',
+    };
+}
+async function measureEmbedding(iterations) {
+    const throughputs = [];
+    const { embedMany } = await Promise.resolve().then(() => __importStar(require('../../llm/embeddings')));
+    // Test texts
+    const texts = Array(10).fill(0).map((_, i) => `This is test text number ${i + 1} for embedding benchmark.`);
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        try {
+            await embedMany(texts);
+        }
+        catch {
+            // API error
+        }
+        const end = performance.now();
+        const duration = (end - start) / 1000; // seconds
+        throughputs.push(texts.length / duration);
+    }
+    const stats = calculateStats(throughputs);
+    return {
+        name: 'Embedding Throughput',
+        iterations,
+        ...stats,
+        unit: 'vectors/sec',
+    };
+}
+function printBenchmarkTable(results) {
+    console.log('Benchmark Results');
+    console.log('─'.repeat(80));
+    console.log('Name'.padEnd(30) +
+        'Mean'.padStart(10) +
+        'Min'.padStart(10) +
+        'Max'.padStart(10) +
+        'P95'.padStart(10) +
+        'Unit'.padStart(10));
+    console.log('─'.repeat(80));
+    for (const r of results) {
+        console.log(r.name.padEnd(30) +
+            r.mean.toFixed(2).padStart(10) +
+            r.min.toFixed(2).padStart(10) +
+            r.max.toFixed(2).padStart(10) +
+            r.p95.toFixed(2).padStart(10) +
+            r.unit.padStart(10));
+    }
+    console.log('─'.repeat(80));
+}

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

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