praisonai 1.5.0 → 1.5.1

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

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

package/dist/cli/commands/context.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Context command - Manage conversation context
+ * Context command - Manage context windows
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -37,24 +37,39 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 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");
+let currentManager = null;
 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 {
+        // Lazy load to avoid import overhead
+        const { ContextManager, ContextBudgeter, ContextOptimizer } = await Promise.resolve().then(() => __importStar(require('../../context')));
         switch (action) {
-            case 'chat':
-                await chatWithContext(actionArgs, options, config, outputFormat);
+            case 'create':
+                await createContext(options, outputFormat, ContextManager);
                 break;
-            case 'summarize':
-                await summarizeContext(actionArgs, options, config, outputFormat);
+            case 'add':
+                await addContent(actionArgs, options, outputFormat);
+                break;
+            case 'stats':
+                await showStats(outputFormat);
+                break;
+            case 'budget':
+                await manageBudget(actionArgs, options, outputFormat, ContextBudgeter);
+                break;
+            case 'optimize':
+                await optimizeContext(options, outputFormat, ContextOptimizer);
+                break;
+            case 'build':
+                await buildContext(outputFormat);
+                break;
+            case 'clear':
+                await clearContext(outputFormat);
                 break;
             case 'help':
             default:
@@ -72,95 +87,120 @@ async function execute(args, options) {
         process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
     }
 }
-async function chatWithContext(args, options, config, outputFormat) {
-    const message = args.join(' ');
-    if (!message) {
+async function createContext(options, outputFormat, ContextManager) {
+    const budget = options.budget || 4000;
+    currentManager = new ContextManager({ maxTokens: budget });
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ created: true, budget }));
+    }
+    else {
+        await pretty.success(`Context manager created with budget: ${budget} tokens`);
+    }
+}
+async function addContent(args, options, outputFormat) {
+    if (!currentManager) {
+        const { ContextManager } = await Promise.resolve().then(() => __importStar(require('../../context')));
+        currentManager = new ContextManager({ maxTokens: options.budget || 4000 });
+    }
+    const content = args.join(' ');
+    const priority = options.priority || 0.5;
+    currentManager.add({ content, priority, type: 'user' });
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ added: true, priority, tokenEstimate: Math.ceil(content.length / 4) }));
+    }
+    else {
+        await pretty.success(`Added content with priority ${priority}`);
+    }
+}
+async function showStats(outputFormat) {
+    if (!currentManager) {
         if (outputFormat === 'json') {
-            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a message'));
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'No context manager created'));
         }
         else {
-            await pretty.error('Please provide a message');
+            await pretty.warn('No context manager created. Run: praisonai context create');
         }
-        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;
+        return;
+    }
+    const stats = {
+        itemCount: currentManager.getItems?.()?.length || 0,
+        tokenCount: currentManager.getTokenCount?.() || 0,
+        maxTokens: currentManager.maxTokens || 4000
+    };
     if (outputFormat === 'json') {
-        (0, json_1.outputJson)((0, json_1.formatSuccess)({
-            message,
-            response: result.text
-        }, {
-            duration_ms: duration,
-            model: config.model
-        }));
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(stats));
     }
     else {
-        await pretty.heading('Response');
-        await pretty.plain(result.text);
-        await pretty.newline();
-        await pretty.success(`Completed in ${duration}ms`);
+        await pretty.heading('Context Stats');
+        await pretty.plain(`  Items: ${stats.itemCount}`);
+        await pretty.plain(`  Tokens: ${stats.tokenCount}/${stats.maxTokens}`);
     }
 }
-async function summarizeContext(args, options, config, outputFormat) {
-    const context = args.join(' ');
-    if (!context) {
+async function manageBudget(args, options, outputFormat, ContextBudgeter) {
+    const subAction = args[0] || 'show';
+    if (subAction === 'show') {
         if (outputFormat === 'json') {
-            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide context to summarize'));
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({ budget: options.budget || 4000 }));
         }
         else {
-            await pretty.error('Please provide context to summarize');
+            await pretty.heading('Budget Configuration');
+            await pretty.plain(`  Total: ${options.budget || 4000} tokens`);
         }
-        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;
+    }
+}
+async function optimizeContext(options, outputFormat, ContextOptimizer) {
+    const target = options.target || 4000;
+    const strategy = options.strategy || 'truncate-low-priority';
+    const optimizer = new ContextOptimizer({ targetTokens: target, strategies: [strategy] });
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ optimized: true, target, strategy }));
+    }
+    else {
+        await pretty.success(`Optimization applied: ${strategy} (target: ${target} tokens)`);
+    }
+}
+async function buildContext(outputFormat) {
+    if (!currentManager) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'No context manager'));
+        }
+        else {
+            await pretty.warn('No context manager. Run: praisonai context create');
+        }
+        return;
+    }
+    const built = currentManager.build?.() || '';
     if (outputFormat === 'json') {
-        (0, json_1.outputJson)((0, json_1.formatSuccess)({
-            originalLength: context.length,
-            summary: result.text
-        }, {
-            duration_ms: duration,
-            model: config.model
-        }));
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ context: built, length: built.length }));
     }
     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`);
+        console.log(built);
+    }
+}
+async function clearContext(outputFormat) {
+    if (currentManager) {
+        currentManager.clear?.();
+    }
+    currentManager = null;
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ cleared: true }));
+    }
+    else {
+        await pretty.success('Context cleared');
     }
 }
 async function showHelp(outputFormat) {
     const help = {
         command: 'context',
         subcommands: [
-            { name: 'chat <message>', description: 'Chat with context management' },
-            { name: 'summarize <text>', description: 'Summarize context' },
+            { name: 'create', description: 'Create context manager', options: ['--budget'] },
+            { name: 'add <content>', description: 'Add content', options: ['--priority'] },
+            { name: 'stats', description: 'Show context stats' },
+            { name: 'budget', description: 'Manage token budget' },
+            { name: 'optimize', description: 'Optimize context', options: ['--target', '--strategy'] },
+            { name: 'build', description: 'Build context string' },
+            { name: 'clear', description: 'Clear context' },
             { name: 'help', description: 'Show this help' }
-        ],
-        flags: [
-            { name: '--max-messages', description: 'Maximum messages to keep in context' }
         ]
     };
     if (outputFormat === 'json') {
@@ -168,15 +208,10 @@ async function showHelp(outputFormat) {
     }
     else {
         await pretty.heading('Context Command');
-        await pretty.plain('Manage conversation context\n');
+        await pretty.plain('Manage Agent context windows\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/hooks.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hooks CLI command - Manage hooks and callbacks
+ */
+export interface HooksOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    event?: string;
+    enabled?: boolean;
+    logging?: boolean;
+}
+export declare function execute(args: string[], options: HooksOptions): Promise<void>;

package/dist/cli/commands/hooks.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Hooks CLI command - Manage hooks and callbacks
+ */
+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 actionArgs = args.slice(1);
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        const { HooksManager, createHooksManager, registerDisplayCallback, getRegisteredDisplayTypes, clearAllCallbacks, DisplayTypes } = await Promise.resolve().then(() => __importStar(require('../../hooks')));
+        switch (action) {
+            case 'list':
+                await listHooks(outputFormat);
+                break;
+            case 'events':
+                await listEvents(outputFormat);
+                break;
+            case 'display-types':
+                await listDisplayTypes(outputFormat, getRegisteredDisplayTypes, DisplayTypes);
+                break;
+            case 'clear':
+                await clearHooks(outputFormat, clearAllCallbacks);
+                break;
+            case 'stats':
+                await showStats(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 listHooks(outputFormat) {
+    const { HooksManager } = await Promise.resolve().then(() => __importStar(require('../../hooks')));
+    const manager = new HooksManager({ logging: false });
+    const hookEvents = [
+        'pre_read_code', 'post_read_code',
+        'pre_write_code', 'post_write_code',
+        'pre_run_command', 'post_run_command',
+        'pre_user_prompt', 'post_user_prompt',
+        'pre_mcp_tool_use', 'post_mcp_tool_use',
+        'pre_llm_call', 'post_llm_call',
+        'pre_tool_call', 'post_tool_call',
+        'agent_start', 'agent_complete',
+        'run_started', 'run_completed'
+    ];
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ events: hookEvents, count: hookEvents.length }));
+    }
+    else {
+        await pretty.heading('Available Hook Events');
+        await pretty.plain(`\nOperation Hooks:`);
+        await pretty.plain(`  pre_read_code, post_read_code`);
+        await pretty.plain(`  pre_write_code, post_write_code`);
+        await pretty.plain(`  pre_run_command, post_run_command`);
+        await pretty.plain(`  pre_user_prompt, post_user_prompt`);
+        await pretty.plain(`  pre_mcp_tool_use, post_mcp_tool_use`);
+        await pretty.plain(`\nLLM/Tool Hooks:`);
+        await pretty.plain(`  pre_llm_call, post_llm_call`);
+        await pretty.plain(`  pre_tool_call, post_tool_call`);
+        await pretty.plain(`\nLifecycle Hooks:`);
+        await pretty.plain(`  agent_start, agent_complete`);
+        await pretty.plain(`  run_started, run_completed`);
+        await pretty.plain(`\nTotal: ${hookEvents.length} hook events`);
+    }
+}
+async function listEvents(outputFormat) {
+    await listHooks(outputFormat);
+}
+async function listDisplayTypes(outputFormat, getRegisteredDisplayTypes, DisplayTypes) {
+    const registered = getRegisteredDisplayTypes();
+    const builtIn = Object.values(DisplayTypes);
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            builtIn,
+            registered,
+            builtInCount: builtIn.length,
+            registeredCount: registered.length
+        }));
+    }
+    else {
+        await pretty.heading('Display Types');
+        await pretty.plain(`\nBuilt-in types (${builtIn.length}):`);
+        for (const type of builtIn) {
+            await pretty.plain(`  ${type}`);
+        }
+        await pretty.plain(`\nRegistered callbacks: ${registered.length}`);
+    }
+}
+async function clearHooks(outputFormat, clearAllCallbacks) {
+    clearAllCallbacks();
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ cleared: true }));
+    }
+    else {
+        await pretty.success('All callbacks cleared');
+    }
+}
+async function showStats(outputFormat) {
+    const { getRegisteredDisplayTypes, hasApprovalCallback } = await Promise.resolve().then(() => __importStar(require('../../hooks')));
+    const stats = {
+        displayTypes: getRegisteredDisplayTypes().length,
+        hasApprovalCallback: hasApprovalCallback(),
+        hookEvents: 20 // Total available hook events
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(stats));
+    }
+    else {
+        await pretty.heading('Hooks Stats');
+        await pretty.plain(`  Display callbacks: ${stats.displayTypes}`);
+        await pretty.plain(`  Approval callback: ${stats.hasApprovalCallback ? 'Yes' : 'No'}`);
+        await pretty.plain(`  Available events: ${stats.hookEvents}`);
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'hooks',
+        description: 'Manage hooks and callbacks',
+        subcommands: [
+            { name: 'list', description: 'List all available hook events' },
+            { name: 'events', description: 'List hook events (alias for list)' },
+            { name: 'display-types', description: 'List display callback types' },
+            { name: 'stats', description: 'Show hooks statistics' },
+            { name: 'clear', description: 'Clear all registered callbacks' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Hooks Command');
+        await pretty.plain('Manage hooks and callbacks for agent operations\n');
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(20)} ${cmd.description}`);
+        }
+        await pretty.plain('\nExamples:');
+        await pretty.plain('  praisonai-ts hooks list');
+        await pretty.plain('  praisonai-ts hooks display-types --json');
+        await pretty.plain('  praisonai-ts hooks stats');
+    }
+}

package/dist/cli/features/enhanced-flow-display.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Enhanced Flow Display - Visualization options for workflows
+ *
+ * Provides multiple output formats and interactive modes.
+ */
+/**
+ * Display format
+ */
+export type DisplayFormat = 'text' | 'markdown' | 'json' | 'tree' | 'mermaid';
+/**
+ * Flow step representation
+ */
+export interface FlowStep {
+    id: string;
+    name: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+    duration?: number;
+    input?: any;
+    output?: any;
+    error?: string;
+    children?: FlowStep[];
+}
+/**
+ * Display options
+ */
+export interface FlowDisplayOptions {
+    format?: DisplayFormat;
+    showInput?: boolean;
+    showOutput?: boolean;
+    showDuration?: boolean;
+    maxDepth?: number;
+    colorize?: boolean;
+}
+/**
+ * FlowDisplay - Workflow visualization
+ */
+export declare class FlowDisplay {
+    private options;
+    constructor(options?: FlowDisplayOptions);
+    /**
+     * Render flow
+     */
+    render(steps: FlowStep[]): string;
+    /**
+     * Render as plain text
+     */
+    private renderText;
+    /**
+     * Render as markdown
+     */
+    private renderMarkdown;
+    /**
+     * Render as JSON
+     */
+    private renderJson;
+    /**
+     * Render as tree
+     */
+    private renderTree;
+    /**
+     * Render as Mermaid diagram
+     */
+    private renderMermaid;
+    /**
+     * Get status icon
+     */
+    private getStatusIcon;
+    /**
+     * Print to console
+     */
+    print(steps: FlowStep[]): void;
+}
+/**
+ * Create flow display
+ */
+export declare function createFlowDisplay(options?: FlowDisplayOptions): FlowDisplay;
+/**
+ * Quick render
+ */
+export declare function renderFlow(steps: FlowStep[], format?: DisplayFormat): string;
+export default FlowDisplay;