overai 1.4.0

package/dist/cli/commands/external-agents.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * CLI command: external-agents
+ * Integration with external AI CLI tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const external_agents_1 = require("../features/external-agents");
+async function execute(args, options) {
+    const subcommand = args[0] || 'help';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'list':
+            await handleList(isJson);
+            break;
+        case 'check':
+            await handleCheck(args.slice(1), isJson);
+            break;
+        case 'run':
+            await handleRun(args.slice(1), options, isJson);
+            break;
+        case 'help':
+        default:
+            showHelp(isJson);
+    }
+}
+async function handleList(isJson) {
+    const registry = (0, external_agents_1.getExternalAgentRegistry)();
+    const all = registry.list();
+    const available = await registry.getAvailable();
+    if (isJson) {
+        console.log(JSON.stringify({
+            success: true,
+            agents: all,
+            available
+        }, null, 2));
+    }
+    else {
+        console.log('External Agents:\n');
+        for (const name of all) {
+            const status = available.includes(name) ? '✓' : '✗';
+            console.log(`  ${status} ${name}`);
+        }
+        console.log(`\n${available.length}/${all.length} available`);
+    }
+}
+async function handleCheck(args, isJson) {
+    const name = args[0];
+    if (!name) {
+        console.error('Error: Agent name is required');
+        process.exit(1);
+    }
+    const agent = (0, external_agents_1.createExternalAgent)(name);
+    if (!agent) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: `Unknown agent: ${name}` }));
+        }
+        else {
+            console.error(`Unknown agent: ${name}`);
+        }
+        process.exit(1);
+    }
+    const available = await agent.isAvailable();
+    if (isJson) {
+        console.log(JSON.stringify({ success: true, agent: name, available }));
+    }
+    else {
+        if (available) {
+            console.log(`✓ ${name} is available`);
+        }
+        else {
+            console.log(`✗ ${name} is not available (CLI not found)`);
+        }
+    }
+}
+async function handleRun(args, options, isJson) {
+    const name = args[0];
+    const prompt = args.slice(1).join(' ');
+    if (!name) {
+        console.error('Error: Agent name is required');
+        process.exit(1);
+    }
+    if (!prompt) {
+        console.error('Error: Prompt is required');
+        process.exit(1);
+    }
+    const cwd = options.cwd;
+    const agent = (0, external_agents_1.createExternalAgent)(name, cwd);
+    if (!agent) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: `Unknown agent: ${name}` }));
+        }
+        else {
+            console.error(`Unknown agent: ${name}`);
+        }
+        process.exit(1);
+    }
+    if (!await agent.isAvailable()) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: `${name} CLI not available` }));
+        }
+        else {
+            console.error(`${name} CLI not available`);
+        }
+        process.exit(1);
+    }
+    const result = await agent.execute(prompt);
+    if (isJson) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        if (result.success) {
+            console.log(result.output);
+        }
+        else {
+            console.error(`Error: ${result.error}`);
+            process.exit(result.exitCode);
+        }
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'external-agents',
+        description: 'Integration with external AI CLI tools',
+        subcommands: {
+            list: 'List all external agents and availability',
+            check: 'Check if an agent is available',
+            run: 'Run a prompt with an external agent'
+        },
+        agents: {
+            claude: 'Claude Code CLI',
+            gemini: 'Gemini CLI',
+            codex: 'OpenAI Codex CLI',
+            aider: 'Aider CLI'
+        },
+        flags: {
+            '--cwd': 'Working directory for the agent',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'overai external-agents list',
+            'overai external-agents check claude',
+            'overai external-agents run claude "Explain this code"',
+            'overai external-agents run gemini "Refactor this function" --cwd ./src',
+            'overai external-agents run aider "Fix this bug"'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('External Agents - AI CLI tool integration\n');
+        console.log('Subcommands:');
+        for (const [cmd, desc] of Object.entries(help.subcommands)) {
+            console.log(`  ${cmd.padEnd(12)} ${desc}`);
+        }
+        console.log('\nSupported Agents:');
+        for (const [agent, desc] of Object.entries(help.agents)) {
+            console.log(`  ${agent.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/fast-context.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CLI command: fast-context
+ * Fast context retrieval and summarization
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

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