praisonai 1.2.2 → 1.2.3

package/dist/cli/commands/fast-context.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * CLI command: fast-context
+ * Fast context retrieval and summarization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const fast_context_1 = require("../features/fast-context");
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'query':
+            await handleQuery(args.slice(1), options, isJson);
+            break;
+        case 'stats':
+            await handleStats(isJson);
+            break;
+        case 'clear':
+            await handleClear(isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+let globalContext = null;
+function getContext(maxTokens) {
+    if (!globalContext) {
+        globalContext = (0, fast_context_1.createFastContext)({ maxTokens, cacheEnabled: true });
+    }
+    return globalContext;
+}
+async function handleQuery(args, options, isJson) {
+    const query = args.join(' ');
+    if (!query) {
+        console.error('Error: Query is required');
+        process.exit(1);
+    }
+    const maxTokens = options['max-tokens'];
+    const sources = options.sources;
+    const fc = getContext(maxTokens);
+    // Add sources if provided
+    if (sources) {
+        const sourceList = sources.split(',').map(s => s.trim());
+        fc.registerSource('cli-sources', 'custom', sourceList);
+    }
+    const result = await fc.getContext(query);
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, ...result }, null, 2));
+    }
+    else {
+        console.log('Fast Context Result:');
+        console.log(`  Query: ${query}`);
+        console.log(`  Token count: ${result.tokenCount}`);
+        console.log(`  Sources used: ${result.sources.length}`);
+        console.log(`  Cached: ${result.cached}`);
+        console.log(`  Latency: ${result.latencyMs}ms`);
+        console.log('\nContext:');
+        console.log(result.context || '(empty)');
+    }
+}
+async function handleStats(isJson) {
+    const fc = getContext();
+    const stats = fc.getCacheStats();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, stats }, null, 2));
+    }
+    else {
+        console.log('Fast Context Cache Stats:');
+        console.log(`  Cache size: ${stats.size}`);
+        console.log(`  Total hits: ${stats.totalHits}`);
+    }
+}
+async function handleClear(isJson) {
+    const fc = getContext();
+    fc.clearCache();
+    fc.clearSources();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, message: 'Cache and sources cleared' }));
+    }
+    else {
+        console.log('✓ Cache and sources cleared');
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'fast-context',
+        description: 'Fast context retrieval and summarization',
+        subcommands: {
+            query: 'Query for relevant context',
+            stats: 'Show cache statistics',
+            clear: 'Clear cache and sources'
+        },
+        flags: {
+            '--max-tokens': 'Maximum tokens in context (default: 4000)',
+            '--sources': 'Comma-separated source texts',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts fast-context query "What is the main topic?"',
+            'praisonai-ts fast-context query "summarize" --sources "text1,text2,text3"',
+            'praisonai-ts fast-context query "find relevant" --max-tokens 2000',
+            'praisonai-ts fast-context stats',
+            'praisonai-ts fast-context clear'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Fast Context - Fast context retrieval\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(14)} ${desc}`);
+        }
+        console.log('\nExamples:');
+        for (const ex of help.examples) {
+            console.log(`  ${ex}`);
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * CLI command: flow
+ * Workflow flow visualization
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/flow.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * CLI command: flow
+ * Workflow flow visualization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const flow_display_1 = require("../features/flow-display");
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'show':
+            await handleShow(args.slice(1), options, isJson);
+            break;
+        case 'dot':
+            await handleDot(args.slice(1), options, isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleShow(args, options, isJson) {
+    const stepsStr = args[0] || options.steps;
+    let steps = [];
+    if (stepsStr) {
+        try {
+            steps = JSON.parse(stepsStr);
+        }
+        catch {
+            // Parse simple format: "step1,step2,step3"
+            steps = stepsStr.split(',').map(s => {
+                const [name, type] = s.split(':');
+                return { name: name.trim(), type: type?.trim() };
+            });
+        }
+    }
+    else {
+        // Default example
+        steps = [
+            { name: 'Input', type: 'start' },
+            { name: 'Process', type: 'agent' },
+            { name: 'Validate', type: 'condition' },
+            { name: 'Output', type: 'end' }
+        ];
+    }
+    const display = (0, flow_display_1.createFlowDisplay)({
+        showStatus: Boolean(options.status),
+        compact: Boolean(options.compact)
+    });
+    display.fromWorkflowSteps(steps);
+    if (isJson) {
+        const graph = display.getGraph();
+        console.log(JSON.stringify({
+            success: true,
+            nodes: Array.from(graph.nodes.values()),
+            edges: graph.edges
+        }, null, 2));
+    }
+    else {
+        if (options.boxes) {
+            console.log(display.renderBoxes());
+        }
+        else {
+            console.log(display.render());
+        }
+    }
+}
+async function handleDot(args, options, isJson) {
+    const stepsStr = args[0] || options.steps;
+    let steps = [];
+    if (stepsStr) {
+        try {
+            steps = JSON.parse(stepsStr);
+        }
+        catch {
+            steps = stepsStr.split(',').map(s => {
+                const [name, type] = s.split(':');
+                return { name: name.trim(), type: type?.trim() };
+            });
+        }
+    }
+    else {
+        steps = [
+            { name: 'Start', type: 'start' },
+            { name: 'Agent', type: 'agent' },
+            { name: 'End', type: 'end' }
+        ];
+    }
+    const display = (0, flow_display_1.createFlowDisplay)();
+    display.fromWorkflowSteps(steps);
+    const dot = display.toDot();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, dot }));
+    }
+    else {
+        console.log(dot);
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'flow',
+        description: 'Workflow flow visualization',
+        subcommands: {
+            show: 'Display workflow as text tree or boxes',
+            dot: 'Export workflow as DOT format (for Graphviz)'
+        },
+        flags: {
+            '--steps': 'Steps as JSON or "name:type,name:type"',
+            '--status': 'Show status indicators',
+            '--compact': 'Compact display mode',
+            '--boxes': 'Display as ASCII boxes',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts flow show "Input,Process,Output"',
+            'praisonai-ts flow show "Start:start,Agent:agent,End:end"',
+            'praisonai-ts flow show --boxes',
+            'praisonai-ts flow dot "Step1,Step2,Step3" > workflow.dot'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Flow - Workflow visualization\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/git.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CLI command: git
+ * Git integration for repository operations
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/git.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * CLI command: git
+ * Git integration for repository operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const git_integration_1 = require("../features/git-integration");
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    const cwd = options.cwd || process.cwd();
+    switch (subcommand) {
+        case 'status':
+            await handleStatus(cwd, isJson);
+            break;
+        case 'diff':
+            await handleDiff(options, cwd, isJson);
+            break;
+        case 'log':
+            await handleLog(options, cwd, isJson);
+            break;
+        case 'branches':
+            await handleBranches(cwd, isJson);
+            break;
+        case 'stash':
+            await handleStash(args.slice(1), cwd, isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleStatus(cwd, isJson) {
+    const git = (0, git_integration_1.createGitManager)({ cwd, safe: true });
+    if (!await git.isRepo()) {
+        console.error('Error: Not a git repository');
+        process.exit(1);
+    }
+    const status = await git.getStatus();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, ...status }, null, 2));
+    }
+    else {
+        console.log(await git.getStatusString());
+    }
+}
+async function handleDiff(options, cwd, isJson) {
+    const git = (0, git_integration_1.createGitManager)({ cwd, safe: true });
+    const staged = Boolean(options.staged);
+    if (!await git.isRepo()) {
+        console.error('Error: Not a git repository');
+        process.exit(1);
+    }
+    const diff = await git.getDiff(staged);
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, ...diff }, null, 2));
+    }
+    else {
+        if (diff.files.length === 0) {
+            console.log(staged ? 'No staged changes' : 'No changes');
+        }
+        else {
+            console.log(`Changes (${diff.files.length} files):\n`);
+            for (const file of diff.files) {
+                console.log(`  ${file.path} (+${file.additions}/-${file.deletions})`);
+            }
+            if (options.full) {
+                console.log('\n' + diff.summary);
+            }
+        }
+    }
+}
+async function handleLog(options, cwd, isJson) {
+    const git = (0, git_integration_1.createGitManager)({ cwd, safe: true });
+    const limit = options.limit || 10;
+    if (!await git.isRepo()) {
+        console.error('Error: Not a git repository');
+        process.exit(1);
+    }
+    const commits = await git.getLog(limit);
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, commits }, null, 2));
+    }
+    else {
+        console.log('Recent commits:\n');
+        for (const commit of commits) {
+            console.log(`  ${commit.shortHash} ${commit.message}`);
+            console.log(`    by ${commit.author} on ${commit.date.toLocaleDateString()}`);
+        }
+    }
+}
+async function handleBranches(cwd, isJson) {
+    const git = (0, git_integration_1.createGitManager)({ cwd, safe: true });
+    if (!await git.isRepo()) {
+        console.error('Error: Not a git repository');
+        process.exit(1);
+    }
+    const branches = await git.getBranches();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, branches }, null, 2));
+    }
+    else {
+        console.log('Branches:\n');
+        for (const branch of branches) {
+            const marker = branch.current ? '* ' : '  ';
+            console.log(`${marker}${branch.name}`);
+        }
+    }
+}
+async function handleStash(args, cwd, isJson) {
+    const git = (0, git_integration_1.createGitManager)({ cwd, safe: true });
+    if (!await git.isRepo()) {
+        console.error('Error: Not a git repository');
+        process.exit(1);
+    }
+    const stashes = await git.getStashList();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, stashes }, null, 2));
+    }
+    else {
+        if (stashes.length === 0) {
+            console.log('No stashes');
+        }
+        else {
+            console.log('Stashes:\n');
+            for (const stash of stashes) {
+                console.log(`  ${stash}`);
+            }
+        }
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'git',
+        description: 'Git integration for repository operations (read-only by default)',
+        subcommands: {
+            status: 'Show repository status',
+            diff: 'Show changes',
+            log: 'Show recent commits',
+            branches: 'List branches',
+            stash: 'List stashes'
+        },
+        flags: {
+            '--cwd': 'Working directory (default: current)',
+            '--staged': 'Show staged changes only (for diff)',
+            '--full': 'Show full diff output',
+            '--limit': 'Number of commits to show (default: 10)',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts git status',
+            'praisonai-ts git diff',
+            'praisonai-ts git diff --staged',
+            'praisonai-ts git log --limit 5',
+            'praisonai-ts git branches',
+            'praisonai-ts git stash'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Git - Repository operations (read-only)\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/graph-rag.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Graph RAG command - Graph-based retrieval augmented generation
+ */
+export interface GraphRagOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: GraphRagOptions): Promise<void>;

package/dist/cli/commands/graph-rag.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Graph RAG command - Graph-based retrieval augmented generation
+ */
+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 '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: 'Graph RAG',
+        description: 'Graph-based retrieval augmented generation for complex knowledge queries',
+        capabilities: [
+            'Build knowledge graphs from documents',
+            'Query relationships between entities',
+            'Combine graph traversal with vector search',
+            'Extract entities and relationships',
+            'Support for complex multi-hop queries'
+        ],
+        sdkUsage: `
+import { createGraphRAG, GraphStore } from 'praisonai';
+
+// Create a graph RAG instance
+const graphRag = createGraphRAG({
+  llm: 'openai/gpt-4o-mini',
+  graphStore: new GraphStore()
+});
+
+// Add documents
+await graphRag.addDocument('Document content...');
+
+// Query with graph context
+const result = await graphRag.query('What is the relationship between X and Y?');
+`
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(info));
+    }
+    else {
+        await pretty.heading('Graph RAG');
+        await pretty.plain(info.description);
+        await pretty.newline();
+        await pretty.plain('Capabilities:');
+        for (const cap of info.capabilities) {
+            await pretty.plain(`  • ${cap}`);
+        }
+        await pretty.newline();
+        await pretty.dim('Use the SDK for full Graph RAG functionality');
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'graph-rag',
+        description: 'Graph-based retrieval augmented generation',
+        subcommands: [
+            { name: 'info', description: 'Show Graph RAG feature information' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Graph RAG 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/guardrail.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Guardrail command - Content validation and safety
+ */
+export interface GuardrailOptions {
+    model?: string;
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    criteria?: string;
+}
+export declare function execute(args: string[], options: GuardrailOptions): Promise<void>;