praisonai 1.2.2 → 1.2.3

package/dist/cli/commands/repo-map.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * CLI command: repo-map
+ * Repository structure visualization and symbol extraction
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const repo_map_1 = require("../features/repo-map");
+async function execute(args, options) {
+    const subcommand = args[0] || 'tree';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'tree':
+            await handleTree(args.slice(1), options, isJson);
+            break;
+        case 'symbols':
+            await handleSymbols(args.slice(1), options, isJson);
+            break;
+        case 'help':
+        default:
+            if (subcommand !== 'help' && !subcommand.startsWith('-')) {
+                // Treat as path for tree command
+                await handleTree([subcommand, ...args.slice(1)], options, isJson);
+            }
+            else {
+                showHelp(isJson);
+            }
+    }
+}
+async function handleTree(args, options, isJson) {
+    const rootPath = args[0] || process.cwd();
+    const maxDepth = options.depth || 5;
+    const includeSymbols = Boolean(options.symbols);
+    const map = (0, repo_map_1.createRepoMap)({
+        rootPath,
+        maxDepth,
+        includeSymbols
+    });
+    try {
+        const result = await map.generate();
+        if (isJson) {
+            console.log(JSON.stringify({
+                success: true,
+                root: result.root,
+                totalFiles: result.totalFiles,
+                totalDirectories: result.totalDirectories,
+                symbolCount: result.symbols.length
+            }, null, 2));
+        }
+        else {
+            console.log(result.summary);
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+async function handleSymbols(args, options, isJson) {
+    const rootPath = args[0] || process.cwd();
+    const maxDepth = options.depth || 5;
+    const map = (0, repo_map_1.createRepoMap)({
+        rootPath,
+        maxDepth,
+        includeSymbols: true
+    });
+    try {
+        const result = await map.generate();
+        if (isJson) {
+            console.log(JSON.stringify({
+                success: true,
+                symbols: result.symbols,
+                count: result.symbols.length
+            }, null, 2));
+        }
+        else {
+            console.log(`Symbols in ${rootPath}:\n`);
+            const byType = {};
+            for (const sym of result.symbols) {
+                if (!byType[sym.type])
+                    byType[sym.type] = [];
+                byType[sym.type].push(sym);
+            }
+            for (const [type, symbols] of Object.entries(byType)) {
+                console.log(`${type}s (${symbols.length}):`);
+                for (const sym of symbols.slice(0, 20)) {
+                    const exported = sym.exported ? ' [exported]' : '';
+                    console.log(`  ${sym.name}${exported} (line ${sym.line})`);
+                }
+                if (symbols.length > 20) {
+                    console.log(`  ... and ${symbols.length - 20} more`);
+                }
+                console.log();
+            }
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'repo-map',
+        description: 'Repository structure visualization and symbol extraction',
+        subcommands: {
+            tree: 'Show repository tree structure',
+            symbols: 'Extract and list code symbols'
+        },
+        flags: {
+            '--depth': 'Maximum directory depth (default: 5)',
+            '--symbols': 'Include symbols in tree output',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts repo-map',
+            'praisonai-ts repo-map tree ./src',
+            'praisonai-ts repo-map tree --depth 3',
+            'praisonai-ts repo-map symbols ./src',
+            'praisonai-ts repo-map tree --symbols'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Repo Map - Repository 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/reranker.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Reranker command - Document reranking
+ */
+export interface RerankerOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    provider?: string;
+}
+export declare function execute(args: string[], options: RerankerOptions): Promise<void>;

package/dist/cli/commands/reranker.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Reranker command - Document reranking
+ */
+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 'providers':
+                await listProviders(outputFormat);
+                break;
+            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: 'Reranker',
+        description: 'Rerank search results for improved relevance',
+        providers: [
+            { name: 'CohereReranker', description: 'Cohere reranking API' },
+            { name: 'CrossEncoderReranker', description: 'Cross-encoder model reranking' },
+            { name: 'LLMReranker', description: 'LLM-based reranking' }
+        ],
+        capabilities: [
+            'Rerank search results by relevance',
+            'Improve RAG retrieval quality',
+            'Multiple reranking strategies',
+            'Configurable top-k selection'
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(info));
+    }
+    else {
+        await pretty.heading('Reranker');
+        await pretty.plain(info.description);
+        await pretty.newline();
+        await pretty.plain('Providers:');
+        for (const p of info.providers) {
+            await pretty.plain(`  • ${p.name}: ${p.description}`);
+        }
+        await pretty.newline();
+        await pretty.plain('Capabilities:');
+        for (const cap of info.capabilities) {
+            await pretty.plain(`  • ${cap}`);
+        }
+    }
+}
+async function listProviders(outputFormat) {
+    const providers = [
+        { name: 'cohere', description: 'Cohere reranking API', available: true },
+        { name: 'cross-encoder', description: 'Cross-encoder model', available: true },
+        { name: 'llm', description: 'LLM-based reranking', available: true }
+    ];
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({ providers }));
+    }
+    else {
+        await pretty.heading('Reranker Providers');
+        for (const p of providers) {
+            const status = p.available ? '✓' : '✗';
+            await pretty.plain(`  ${status} ${p.name.padEnd(15)} ${p.description}`);
+        }
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'reranker',
+        description: 'Document reranking for improved search relevance',
+        subcommands: [
+            { name: 'info', description: 'Show reranker feature information' },
+            { name: 'providers', description: 'List available reranker providers' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Reranker 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/research.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Research command - Deep research agent
+ */
+export interface ResearchOptions {
+    model?: string;
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    depth?: number;
+    maxSources?: number;
+}
+export declare function execute(args: string[], options: ResearchOptions): Promise<void>;

package/dist/cli/commands/research.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Research command - Deep research agent
+ */
+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 research_1 = require("../../agent/research");
+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 query = args.join(' ');
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    const config = (0, resolve_1.resolveConfig)(options);
+    if (!query) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a research query'));
+        }
+        else {
+            await pretty.error('Please provide a research query');
+            await pretty.dim('Usage: praisonai-ts research "What are the latest AI trends?"');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const startTime = Date.now();
+    try {
+        if (outputFormat !== 'json') {
+            await pretty.info(`Researching: "${query}"`);
+        }
+        const agent = (0, research_1.createDeepResearchAgent)({
+            llm: config.model,
+            verbose: options.verbose,
+            maxIterations: options.depth
+        });
+        const result = await agent.research(query);
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                query,
+                answer: result.answer,
+                citations: result.citations,
+                reasoning: result.reasoning,
+                confidence: result.confidence
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else {
+            await pretty.heading('Research Results');
+            await pretty.newline();
+            await pretty.plain(result.answer);
+            if (result.citations && result.citations.length > 0) {
+                await pretty.newline();
+                await pretty.plain('Citations:');
+                for (const citation of result.citations) {
+                    await pretty.dim(`  • ${citation.title || citation.url}`);
+                }
+            }
+            await pretty.newline();
+            await pretty.success(`Completed in ${duration}ms`);
+        }
+    }
+    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);
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Router command - Route requests to appropriate agents
+ */
+export interface RouterOptions {
+    model?: string;
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    routes?: string;
+}
+export declare function execute(args: string[], options: RouterOptions): Promise<void>;

package/dist/cli/commands/router.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Router command - Route requests to appropriate agents
+ */
+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 {
+        switch (action) {
+            case 'analyze':
+                await analyzeInput(actionArgs, 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 analyzeInput(args, outputFormat) {
+    const input = args.join(' ');
+    if (!input) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide input to analyze'));
+        }
+        else {
+            await pretty.error('Please provide input to analyze');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const startTime = Date.now();
+    if (outputFormat !== 'json') {
+        await pretty.info(`Analyzing routing for: "${input}"`);
+    }
+    // Simple rule-based routing analysis
+    const routes = [
+        { name: 'greeting', pattern: /\b(hello|hi|hey|greetings)\b/i, priority: 1 },
+        { name: 'question', pattern: /\?$/, priority: 2 },
+        { name: 'code', pattern: /\b(code|function|class|implement|debug)\b/i, priority: 3 },
+        { name: 'research', pattern: /\b(research|analyze|investigate|study)\b/i, priority: 3 },
+        { name: 'creative', pattern: /\b(write|create|generate|compose)\b/i, priority: 2 },
+        { name: 'general', pattern: /.*/, priority: 0 }
+    ];
+    const matches = routes
+        .filter(r => r.pattern.test(input))
+        .sort((a, b) => b.priority - a.priority);
+    const selectedRoute = matches[0]?.name || 'general';
+    const confidence = matches[0]?.priority ? Math.min(0.5 + matches[0].priority * 0.15, 0.95) : 0.5;
+    const duration = Date.now() - startTime;
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            input,
+            selectedRoute,
+            confidence,
+            matchedRoutes: matches.map(m => m.name)
+        }, {
+            duration_ms: duration
+        }));
+    }
+    else {
+        await pretty.heading('Routing Analysis');
+        await pretty.plain(`Input: "${input}"`);
+        await pretty.plain(`Selected Route: ${selectedRoute}`);
+        await pretty.plain(`Confidence: ${(confidence * 100).toFixed(1)}%`);
+        await pretty.plain(`Matched Routes: ${matches.map(m => m.name).join(', ')}`);
+        await pretty.newline();
+        await pretty.success(`Analyzed in ${duration}ms`);
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'router',
+        description: 'Route requests to appropriate agents based on content analysis',
+        subcommands: [
+            { name: 'analyze <input>', description: 'Analyze input and suggest routing' },
+            { name: 'help', description: 'Show this help' }
+        ],
+        usage: 'For programmatic routing with actual agents, use the RouterAgent SDK class'
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Router Command');
+        await pretty.plain('Route requests to appropriate agents\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.dim('Note: For full routing with agents, use the RouterAgent SDK class');
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Run command - Run an agent with a task
+ */
+export interface RunOptions {
+    agent?: string;
+    tools?: string;
+    model?: string;
+    verbose?: boolean;
+    profile?: string;
+    config?: string;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: RunOptions): Promise<void>;