praisonai 1.2.2 → 1.2.3

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/eval.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Eval command - Evaluate agent performance
+ */
+export interface EvalOptions {
+    input?: string;
+    expected?: string;
+    iterations?: number;
+    warmup?: number;
+    'expected-tools'?: string;
+    model?: string;
+    verbose?: boolean;
+    profile?: string;
+    config?: string;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: EvalOptions): Promise<void>;

package/dist/cli/commands/eval.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Eval command - Evaluate agent performance
+ */
+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 agent_1 = require("../../agent");
+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 subcommand = args[0];
+    if (!subcommand || !['accuracy', 'performance', 'reliability'].includes(subcommand)) {
+        if (options.json || options.output === 'json') {
+            (0, json_1.printError)(errors_1.ERROR_CODES.INVALID_ARGS, 'Please specify a subcommand: accuracy, performance, or reliability');
+        }
+        else {
+            await pretty.error('Please specify a subcommand: accuracy, performance, or reliability');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const config = (0, resolve_1.resolveConfig)({
+        configPath: options.config,
+        profile: options.profile,
+        model: options.model,
+        verbose: options.verbose
+    });
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        switch (subcommand) {
+            case 'accuracy':
+                await runAccuracyEval(options, config, outputFormat);
+                break;
+            case 'performance':
+                await runPerformanceEval(options, config, outputFormat);
+                break;
+            case 'reliability':
+                await runReliabilityEval(options, config, outputFormat);
+                break;
+        }
+    }
+    catch (error) {
+        const cliError = (0, errors_1.normalizeError)(error);
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(cliError.code, cliError.message, cliError.details));
+        }
+        else {
+            await pretty.error(cliError.message);
+            if (config.verbose && error instanceof Error && error.stack) {
+                await pretty.dim(error.stack);
+            }
+        }
+        process.exit(cliError.exitCode);
+    }
+}
+async function runAccuracyEval(options, config, outputFormat) {
+    if (!options.input) {
+        throw new Error('--input is required for accuracy evaluation');
+    }
+    if (!options.expected) {
+        throw new Error('--expected is required for accuracy evaluation');
+    }
+    const iterations = options.iterations || 1;
+    const results = [];
+    const startTime = Date.now();
+    const agent = new agent_1.Agent({
+        name: 'Eval Agent',
+        instructions: 'You are a helpful AI assistant.',
+        llm: config.model,
+        verbose: config.verbose
+    });
+    for (let i = 0; i < iterations; i++) {
+        const output = await agent.start(options.input);
+        // Simple similarity check (in production, use LLM-as-judge)
+        const similarity = calculateSimilarity(output, options.expected);
+        const score = Math.round(similarity * 10);
+        results.push({
+            iteration: i + 1,
+            output,
+            score,
+            passed: score >= 7
+        });
+    }
+    const duration = Date.now() - startTime;
+    const avgScore = results.reduce((sum, r) => sum + r.score, 0) / results.length;
+    const passRate = results.filter(r => r.passed).length / results.length;
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            type: 'accuracy',
+            results,
+            summary: {
+                avg_score: avgScore,
+                pass_rate: passRate,
+                iterations
+            }
+        }, { duration_ms: duration, model: config.model }));
+    }
+    else {
+        await pretty.heading('Accuracy Evaluation Results');
+        await pretty.keyValue({
+            'Iterations': iterations,
+            'Average Score': avgScore.toFixed(2),
+            'Pass Rate': `${(passRate * 100).toFixed(1)}%`,
+            'Duration': `${duration}ms`
+        });
+    }
+}
+async function runPerformanceEval(options, config, outputFormat) {
+    const iterations = options.iterations || 10;
+    const warmup = options.warmup || 2;
+    const results = [];
+    const agent = new agent_1.Agent({
+        name: 'Perf Agent',
+        instructions: 'You are a helpful AI assistant.',
+        llm: config.model,
+        verbose: false // Disable verbose for performance testing
+    });
+    const testPrompt = 'Say "hello" and nothing else.';
+    // Warmup runs
+    for (let i = 0; i < warmup; i++) {
+        await agent.start(testPrompt);
+    }
+    // Actual runs
+    for (let i = 0; i < iterations; i++) {
+        const start = Date.now();
+        await agent.start(testPrompt);
+        const duration = Date.now() - start;
+        results.push({
+            iteration: i + 1,
+            duration_ms: duration
+        });
+    }
+    const durations = results.map(r => r.duration_ms);
+    const avg = durations.reduce((a, b) => a + b, 0) / durations.length;
+    const min = Math.min(...durations);
+    const max = Math.max(...durations);
+    const sorted = [...durations].sort((a, b) => a - b);
+    const p95 = sorted[Math.floor(sorted.length * 0.95)];
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            type: 'performance',
+            results,
+            summary: {
+                avg_ms: avg,
+                min_ms: min,
+                max_ms: max,
+                p95_ms: p95,
+                iterations,
+                warmup_runs: warmup
+            }
+        }, { model: config.model }));
+    }
+    else {
+        await pretty.heading('Performance Evaluation Results');
+        await pretty.keyValue({
+            'Iterations': iterations,
+            'Warmup Runs': warmup,
+            'Avg Duration': `${avg.toFixed(2)}ms`,
+            'Min Duration': `${min}ms`,
+            'Max Duration': `${max}ms`,
+            'P95 Duration': `${p95}ms`
+        });
+    }
+}
+async function runReliabilityEval(options, config, outputFormat) {
+    const expectedTools = options['expected-tools']?.split(',').map(t => t.trim()) || [];
+    if (expectedTools.length === 0) {
+        throw new Error('--expected-tools is required for reliability evaluation');
+    }
+    // For now, simulate reliability check
+    // In production, this would track actual tool calls
+    const results = {
+        expected: expectedTools,
+        called: expectedTools, // Simulated
+        missing: [],
+        unexpected: []
+    };
+    const passed = results.missing.length === 0;
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            type: 'reliability',
+            status: passed ? 'PASSED' : 'FAILED',
+            results
+        }));
+    }
+    else {
+        await pretty.heading('Reliability Evaluation Results');
+        if (passed) {
+            await pretty.success('All expected tools were called');
+        }
+        else {
+            await pretty.error(`Missing tool calls: ${results.missing.join(', ')}`);
+        }
+    }
+}
+/**
+ * Simple string similarity calculation
+ */
+function calculateSimilarity(str1, str2) {
+    const s1 = str1.toLowerCase().trim();
+    const s2 = str2.toLowerCase().trim();
+    if (s1 === s2)
+        return 1;
+    if (s1.includes(s2) || s2.includes(s1))
+        return 0.9;
+    // Simple word overlap
+    const words1 = new Set(s1.split(/\s+/));
+    const words2 = new Set(s2.split(/\s+/));
+    const intersection = [...words1].filter(w => words2.has(w));
+    const union = new Set([...words1, ...words2]);
+    return intersection.length / union.size;
+}

package/dist/cli/commands/external-agents.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CLI command: external-agents
+ * Integration with external AI CLI tools
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/external-agents.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * CLI command: external-agents
+ * Integration with external AI CLI tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const external_agents_1 = require("../features/external-agents");
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'list':
+            await handleList(isJson);
+            break;
+        case 'check':
+            await handleCheck(args.slice(1), isJson);
+            break;
+        case 'run':
+            await handleRun(args.slice(1), options, isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleList(isJson) {
+    const registry = (0, external_agents_1.getExternalAgentRegistry)();
+    const all = registry.list();
+    const available = await registry.getAvailable();
+    if (isJson) {
+        console.log(JSON.stringify({
+            success: true,
+            agents: all,
+            available
+        }, null, 2));
+    }
+    else {
+        console.log('External Agents:\n');
+        for (const name of all) {
+            const status = available.includes(name) ? '✓' : '✗';
+            console.log(`  ${status} ${name}`);
+        }
+        console.log(`\n${available.length}/${all.length} available`);
+    }
+}
+async function handleCheck(args, isJson) {
+    const name = args[0];
+    if (!name) {
+        console.error('Error: Agent name is required');
+        process.exit(1);
+    }
+    const agent = (0, external_agents_1.createExternalAgent)(name);
+    if (!agent) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: `Unknown agent: ${name}` }));
+        }
+        else {
+            console.error(`Unknown agent: ${name}`);
+        }
+        process.exit(1);
+    }
+    const available = await agent.isAvailable();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, agent: name, available }));
+    }
+    else {
+        if (available) {
+            console.log(`✓ ${name} is available`);
+        }
+        else {
+            console.log(`✗ ${name} is not available (CLI not found)`);
+        }
+    }
+}
+async function handleRun(args, options, isJson) {
+    const name = args[0];
+    const prompt = args.slice(1).join(' ');
+    if (!name) {
+        console.error('Error: Agent name is required');
+        process.exit(1);
+    }
+    if (!prompt) {
+        console.error('Error: Prompt is required');
+        process.exit(1);
+    }
+    const cwd = options.cwd;
+    const agent = (0, external_agents_1.createExternalAgent)(name, cwd);
+    if (!agent) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: `Unknown agent: ${name}` }));
+        }
+        else {
+            console.error(`Unknown agent: ${name}`);
+        }
+        process.exit(1);
+    }
+    if (!await agent.isAvailable()) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: `${name} CLI not available` }));
+        }
+        else {
+            console.error(`${name} CLI not available`);
+        }
+        process.exit(1);
+    }
+    const result = await agent.execute(prompt);
+    if (isJson) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        if (result.success) {
+            console.log(result.output);
+        }
+        else {
+            console.error(`Error: ${result.error}`);
+            process.exit(result.exitCode);
+        }
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'external-agents',
+        description: 'Integration with external AI CLI tools',
+        subcommands: {
+            list: 'List all external agents and availability',
+            check: 'Check if an agent is available',
+            run: 'Run a prompt with an external agent'
+        },
+        agents: {
+            claude: 'Claude Code CLI',
+            gemini: 'Gemini CLI',
+            codex: 'OpenAI Codex CLI',
+            aider: 'Aider CLI'
+        },
+        flags: {
+            '--cwd': 'Working directory for the agent',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts external-agents list',
+            'praisonai-ts external-agents check claude',
+            'praisonai-ts external-agents run claude "Explain this code"',
+            'praisonai-ts external-agents run gemini "Refactor this function" --cwd ./src'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('External Agents - AI CLI tool integration\n');
+        console.log('Subcommands:');
+        for (const [cmd, desc] of Object.entries(help.subcommands)) {
+            console.log(`  ${cmd.padEnd(12)} ${desc}`);
+        }
+        console.log('\nSupported Agents:');
+        for (const [agent, desc] of Object.entries(help.agents)) {
+            console.log(`  ${agent.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/fast-context.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CLI command: fast-context
+ * Fast context retrieval and summarization
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;