overai 1.4.0

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>;

package/dist/cli/commands/run.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Run command - Run an agent with a task
+ */
+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 task = args[0];
+    if (!task) {
+        if (options.json || options.output === 'json') {
+            (0, json_1.printError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a task');
+        }
+        else {
+            await pretty.error('Please provide a task');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    // Resolve config with precedence
+    const config = (0, resolve_1.resolveConfig)({
+        configPath: options.config,
+        profile: options.profile,
+        model: options.model,
+        verbose: options.verbose
+    });
+    const startTime = Date.now();
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        // Parse tools if provided
+        const tools = options.tools ? options.tools.split(',').map(t => t.trim()) : [];
+        // Create agent
+        const agent = new agent_1.Agent({
+            name: 'CLI Agent',
+            instructions: 'You are a helpful AI assistant.',
+            llm: config.model,
+            verbose: config.verbose
+        });
+        // Execute task
+        const result = await agent.start(task);
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                result: result,
+                agent: 'CLI Agent',
+                task: task
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else {
+            if (typeof result === 'string') {
+                console.log(result);
+            }
+            else {
+                console.log(JSON.stringify(result, null, 2));
+            }
+        }
+    }
+    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);
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * CLI command: sandbox
+ * Safe command execution with restrictions
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/sandbox.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * CLI command: sandbox
+ * Safe command execution with restrictions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const sandbox_executor_1 = require("../features/sandbox-executor");
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'exec':
+            await handleExec(args.slice(1), options, isJson);
+            break;
+        case 'check':
+            await handleCheck(args.slice(1), isJson);
+            break;
+        case 'mode':
+            await handleMode(args.slice(1), isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleExec(args, options, isJson) {
+    const command = args.join(' ');
+    if (!command) {
+        console.error('Error: Command is required');
+        process.exit(1);
+    }
+    const mode = options.mode || 'basic';
+    const timeout = options.timeout || 30000;
+    const executor = (0, sandbox_executor_1.createSandboxExecutor)({ mode, timeout });
+    const result = await executor.execute(command);
+    if (isJson) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        if (result.success) {
+            console.log('✓ Command executed successfully');
+            console.log(`Duration: ${result.duration}ms`);
+            if (result.stdout) {
+                console.log('\nOutput:');
+                console.log(result.stdout);
+            }
+        }
+        else {
+            console.error('✗ Command failed');
+            if (result.stderr)
+                console.error(result.stderr);
+        }
+    }
+    if (!result.success)
+        process.exit(result.exitCode || 1);
+}
+async function handleCheck(args, isJson) {
+    const command = args.join(' ');
+    if (!command) {
+        console.error('Error: Command is required');
+        process.exit(1);
+    }
+    const validator = new sandbox_executor_1.CommandValidator();
+    const result = validator.validate(command);
+    if (isJson) {
+        console.log(JSON.stringify({ command, ...result }, null, 2));
+    }
+    else {
+        if (result.valid) {
+            console.log(`✓ Command is allowed: ${command}`);
+        }
+        else {
+            console.log(`✗ Command blocked: ${command}`);
+            console.log(`  Reason: ${result.reason}`);
+        }
+    }
+}
+async function handleMode(args, isJson) {
+    const modes = {
+        disabled: 'No execution allowed',
+        basic: 'Basic validation, blocks dangerous patterns',
+        strict: 'Minimal environment, restricted PATH',
+        'network-isolated': 'No network access (proxy blocked)'
+    };
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, modes }, null, 2));
+    }
+    else {
+        console.log('Sandbox Modes:\n');
+        for (const [mode, desc] of Object.entries(modes)) {
+            console.log(`  ${mode.padEnd(18)} ${desc}`);
+        }
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'sandbox',
+        description: 'Safe command execution with restrictions',
+        subcommands: {
+            exec: 'Execute a command in sandbox',
+            check: 'Check if a command would be allowed',
+            mode: 'List available sandbox modes'
+        },
+        flags: {
+            '--mode': 'Sandbox mode (disabled, basic, strict, network-isolated)',
+            '--timeout': 'Execution timeout in ms (default: 30000)',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'praisonai-ts sandbox exec "ls -la"',
+            'praisonai-ts sandbox exec "npm install" --mode strict',
+            'praisonai-ts sandbox check "rm -rf /"',
+            'praisonai-ts sandbox mode'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Sandbox - Safe command execution\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}`);
+        }
+    }
+}