praisonai 1.2.2 → 1.2.3

package/dist/cli/commands/checkpoints.js

@@ -0,0 +1,236 @@
+"use strict";
+/**
+ * CLI command: checkpoints
+ * Session state checkpointing and recovery
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const checkpoints_1 = require("../features/checkpoints");
+let manager = null;
+function getManager(storagePath) {
+    if (!manager) {
+        const storage = storagePath ? (0, checkpoints_1.createFileCheckpointStorage)(storagePath) : undefined;
+        manager = (0, checkpoints_1.createCheckpointManager)({ storage });
+    }
+    return manager;
+}
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    const storagePath = options.storage;
+    switch (subcommand) {
+        case 'create':
+            await handleCreate(args.slice(1), options, isJson, storagePath);
+            break;
+        case 'list':
+            await handleList(isJson, storagePath);
+            break;
+        case 'get':
+            await handleGet(args.slice(1), isJson, storagePath);
+            break;
+        case 'restore':
+            await handleRestore(args.slice(1), isJson, storagePath);
+            break;
+        case 'delete':
+            await handleDelete(args.slice(1), isJson, storagePath);
+            break;
+        case 'export':
+            await handleExport(args.slice(1), isJson, storagePath);
+            break;
+        case 'import':
+            await handleImport(args.slice(1), isJson, storagePath);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleCreate(args, options, isJson, storagePath) {
+    const name = args[0] || `checkpoint-${Date.now()}`;
+    const mgr = getManager(storagePath);
+    // Set state from options if provided
+    const state = options.state ? JSON.parse(options.state) : {};
+    mgr.setState(state);
+    const checkpoint = await mgr.create(name, {
+        sessionId: options.session,
+        metadata: options.metadata ? JSON.parse(options.metadata) : undefined
+    });
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, checkpoint }, null, 2));
+    }
+    else {
+        console.log(`✓ Checkpoint created: ${checkpoint.id}`);
+        console.log(`  Name: ${checkpoint.name}`);
+        console.log(`  Time: ${checkpoint.timestamp.toISOString()}`);
+    }
+}
+async function handleList(isJson, storagePath) {
+    const mgr = getManager(storagePath);
+    const checkpoints = await mgr.list();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, checkpoints }, null, 2));
+    }
+    else {
+        if (checkpoints.length === 0) {
+            console.log('No checkpoints found');
+        }
+        else {
+            console.log('Checkpoints:');
+            for (const cp of checkpoints) {
+                console.log(`  ${cp.name} (${cp.id})`);
+                console.log(`    Created: ${cp.timestamp.toISOString()}`);
+                if (cp.sessionId)
+                    console.log(`    Session: ${cp.sessionId}`);
+            }
+        }
+    }
+}
+async function handleGet(args, isJson, storagePath) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Checkpoint ID is required');
+        process.exit(1);
+    }
+    const mgr = getManager(storagePath);
+    const checkpoint = await mgr.get(id);
+    if (!checkpoint) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: 'Checkpoint not found' }));
+        }
+        else {
+            console.error(`Checkpoint ${id} not found`);
+        }
+        process.exit(1);
+    }
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, checkpoint }, null, 2));
+    }
+    else {
+        console.log(`Checkpoint: ${checkpoint.id}`);
+        console.log(`  Name: ${checkpoint.name}`);
+        console.log(`  Created: ${checkpoint.timestamp.toISOString()}`);
+        console.log(`  State: ${JSON.stringify(checkpoint.state, null, 2)}`);
+    }
+}
+async function handleRestore(args, isJson, storagePath) {
+    const id = args[0];
+    const mgr = getManager(storagePath);
+    let checkpoint;
+    if (id) {
+        checkpoint = await mgr.restore(id);
+    }
+    else {
+        checkpoint = await mgr.restoreLatest();
+    }
+    if (!checkpoint) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: 'No checkpoint to restore' }));
+        }
+        else {
+            console.error('No checkpoint to restore');
+        }
+        process.exit(1);
+    }
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, restored: checkpoint }, null, 2));
+    }
+    else {
+        console.log(`✓ Restored checkpoint: ${checkpoint.id}`);
+        console.log(`  Name: ${checkpoint.name}`);
+        console.log(`  State keys: ${Object.keys(checkpoint.state).join(', ') || 'none'}`);
+    }
+}
+async function handleDelete(args, isJson, storagePath) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Checkpoint ID is required');
+        process.exit(1);
+    }
+    const mgr = getManager(storagePath);
+    await mgr.delete(id);
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, deleted: id }));
+    }
+    else {
+        console.log(`✓ Checkpoint ${id} deleted`);
+    }
+}
+async function handleExport(args, isJson, storagePath) {
+    const id = args[0];
+    if (!id) {
+        console.error('Error: Checkpoint ID is required');
+        process.exit(1);
+    }
+    const mgr = getManager(storagePath);
+    const exported = await mgr.export(id);
+    if (!exported) {
+        console.error(`Checkpoint ${id} not found`);
+        process.exit(1);
+    }
+    console.log(exported);
+}
+async function handleImport(args, isJson, storagePath) {
+    const jsonData = args[0];
+    if (!jsonData) {
+        console.error('Error: JSON data is required');
+        process.exit(1);
+    }
+    const mgr = getManager(storagePath);
+    const checkpoint = await mgr.import(jsonData);
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, imported: checkpoint }, null, 2));
+    }
+    else {
+        console.log(`✓ Checkpoint imported: ${checkpoint.id}`);
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'checkpoints',
+        description: 'Session state checkpointing and recovery',
+        subcommands: {
+            create: 'Create a new checkpoint',
+            list: 'List all checkpoints',
+            get: 'Get checkpoint details',
+            restore: 'Restore from a checkpoint',
+            delete: 'Delete a checkpoint',
+            export: 'Export checkpoint as JSON',
+            import: 'Import checkpoint from JSON'
+        },
+        flags: {
+            '--storage': 'Path to checkpoint storage directory',
+            '--state': 'JSON state to save with checkpoint',
+            '--session': 'Session ID to associate',
+            '--metadata': 'JSON metadata',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts checkpoints create my-checkpoint',
+            'praisonai-ts checkpoints create --state \'{"key": "value"}\'',
+            'praisonai-ts checkpoints list',
+            'praisonai-ts checkpoints restore <id>',
+            'praisonai-ts checkpoints restore  # restores latest',
+            'praisonai-ts checkpoints export <id> > checkpoint.json',
+            'praisonai-ts checkpoints import \'{"name": "imported"}\'',
+            'praisonai-ts checkpoints delete <id>'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Checkpoints - Session state checkpointing\n');
+        console.log('Subcommands:');
+        for (const [cmd, desc] of Object.entries(help.subcommands)) {
+            console.log(`  ${cmd.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/context.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Context command - Manage conversation context
+ */
+export interface ContextOptions {
+    model?: string;
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    maxMessages?: number;
+}
+export declare function execute(args: string[], options: ContextOptions): Promise<void>;

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: [
+            'praisonai-ts cost summary',
+            'praisonai-ts cost add gpt-4o 1000 500',
+            'praisonai-ts cost pricing',
+            'praisonai-ts cost pricing gpt-4o',
+            'praisonai-ts 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>;