overai 1.4.0

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

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * External Agents - Integration adapters for external AI CLI tools
+ *
+ * Allows OverAI to use other CLI tools as sub-agents or tools.
+ */
+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.GenericExternalAgent = exports.AiderAgent = exports.CodexCliAgent = exports.GeminiCliAgent = exports.ClaudeCodeAgent = exports.BaseExternalAgent = void 0;
+exports.getExternalAgentRegistry = getExternalAgentRegistry;
+exports.createExternalAgent = createExternalAgent;
+exports.externalAgentAsTool = externalAgentAsTool;
+/**
+ * Base class for external agent integrations
+ */
+class BaseExternalAgent {
+    constructor(config) {
+        this.config = {
+            timeout: 300000, // 5 minutes default
+            ...config
+        };
+    }
+    /**
+     * Get the agent name
+     */
+    getName() {
+        return this.config.name;
+    }
+    /**
+     * Execute a command and return result
+     */
+    async runCommand(args) {
+        const { spawn } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        const startTime = Date.now();
+        return new Promise((resolve) => {
+            const proc = spawn(this.config.command, args, {
+                cwd: this.config.cwd || process.cwd(),
+                env: { ...process.env, ...this.config.env },
+                timeout: this.config.timeout,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                resolve({
+                    success: code === 0,
+                    output: stdout,
+                    error: stderr || undefined,
+                    exitCode: code || 0,
+                    duration: Date.now() - startTime
+                });
+            });
+            proc.on('error', (error) => {
+                resolve({
+                    success: false,
+                    output: '',
+                    error: error.message,
+                    exitCode: 1,
+                    duration: Date.now() - startTime
+                });
+            });
+        });
+    }
+    /**
+     * Check if a command exists
+     */
+    async commandExists(command) {
+        const { spawn } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        return new Promise((resolve) => {
+            const proc = spawn('which', [command], { stdio: 'pipe' });
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+        });
+    }
+}
+exports.BaseExternalAgent = BaseExternalAgent;
+/**
+ * Claude Code CLI integration
+ */
+class ClaudeCodeAgent extends BaseExternalAgent {
+    constructor(cwd) {
+        super({
+            name: 'claude-code',
+            command: 'claude',
+            cwd
+        });
+    }
+    async isAvailable() {
+        return this.commandExists('claude');
+    }
+    async execute(prompt) {
+        return this.runCommand(['--print', prompt]);
+    }
+    async executeWithSession(prompt, sessionId) {
+        const args = ['--print'];
+        if (sessionId) {
+            args.push('--continue', sessionId);
+        }
+        args.push(prompt);
+        return this.runCommand(args);
+    }
+}
+exports.ClaudeCodeAgent = ClaudeCodeAgent;
+/**
+ * Gemini CLI integration
+ */
+class GeminiCliAgent extends BaseExternalAgent {
+    constructor(cwd, model = 'gemini-2.5-pro') {
+        super({
+            name: 'gemini-cli',
+            command: 'gemini',
+            cwd
+        });
+        this.model = model;
+    }
+    async isAvailable() {
+        return this.commandExists('gemini');
+    }
+    async execute(prompt) {
+        return this.runCommand(['-m', this.model, prompt]);
+    }
+}
+exports.GeminiCliAgent = GeminiCliAgent;
+/**
+ * OpenAI Codex CLI integration
+ */
+class CodexCliAgent extends BaseExternalAgent {
+    constructor(cwd) {
+        super({
+            name: 'codex-cli',
+            command: 'codex',
+            cwd
+        });
+    }
+    async isAvailable() {
+        return this.commandExists('codex');
+    }
+    async execute(prompt) {
+        return this.runCommand(['exec', '--full-auto', prompt]);
+    }
+}
+exports.CodexCliAgent = CodexCliAgent;
+/**
+ * Aider CLI integration
+ */
+class AiderAgent extends BaseExternalAgent {
+    constructor(cwd) {
+        super({
+            name: 'aider',
+            command: 'aider',
+            cwd
+        });
+    }
+    async isAvailable() {
+        return this.commandExists('aider');
+    }
+    async execute(prompt) {
+        return this.runCommand(['--message', prompt, '--yes']);
+    }
+}
+exports.AiderAgent = AiderAgent;
+/**
+ * Generic external agent for any CLI tool
+ */
+class GenericExternalAgent extends BaseExternalAgent {
+    constructor(config) {
+        super(config);
+        this.promptArg = config.promptArg || '';
+    }
+    async isAvailable() {
+        return this.commandExists(this.config.command);
+    }
+    async execute(prompt) {
+        const args = [...(this.config.args || [])];
+        if (this.promptArg) {
+            args.push(this.promptArg, prompt);
+        }
+        else {
+            args.push(prompt);
+        }
+        return this.runCommand(args);
+    }
+}
+exports.GenericExternalAgent = GenericExternalAgent;
+/**
+ * External Agent Registry
+ */
+class ExternalAgentRegistry {
+    constructor() {
+        this.agents = new Map();
+        // Register built-in agents
+        this.register('claude', () => new ClaudeCodeAgent());
+        this.register('gemini', () => new GeminiCliAgent());
+        this.register('codex', () => new CodexCliAgent());
+        this.register('aider', () => new AiderAgent());
+    }
+    register(name, factory) {
+        this.agents.set(name, factory);
+    }
+    get(name) {
+        const factory = this.agents.get(name);
+        return factory ? factory() : undefined;
+    }
+    list() {
+        return Array.from(this.agents.keys());
+    }
+    async getAvailable() {
+        const available = [];
+        for (const [name, factory] of this.agents) {
+            const agent = factory();
+            if (await agent.isAvailable()) {
+                available.push(name);
+            }
+        }
+        return available;
+    }
+}
+let registry = null;
+function getExternalAgentRegistry() {
+    if (!registry) {
+        registry = new ExternalAgentRegistry();
+    }
+    return registry;
+}
+/**
+ * Create an external agent by name
+ */
+function createExternalAgent(name, cwd) {
+    const reg = getExternalAgentRegistry();
+    switch (name) {
+        case 'claude':
+            return new ClaudeCodeAgent(cwd);
+        case 'gemini':
+            return new GeminiCliAgent(cwd);
+        case 'codex':
+            return new CodexCliAgent(cwd);
+        case 'aider':
+            return new AiderAgent(cwd);
+        default:
+            return reg.get(name);
+    }
+}
+/**
+ * Convert external agent to tool for use with PraisonAI agents
+ */
+function externalAgentAsTool(agent) {
+    return {
+        name: `external_${agent.getName()}`,
+        description: `Execute a prompt using the ${agent.getName()} external agent`,
+        execute: async (input) => {
+            const result = await agent.execute(input);
+            if (!result.success) {
+                throw new Error(result.error || 'External agent execution failed');
+            }
+            return result.output;
+        }
+    };
+}

package/dist/cli/features/fast-context.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Fast Context - Fast retrieval and summarization pipeline
+ * Minimizes tokens and latency with deterministic caching
+ */
+export interface FastContextConfig {
+    maxTokens?: number;
+    cacheEnabled?: boolean;
+    cacheTTL?: number;
+    summarizer?: (text: string, maxTokens: number) => Promise<string>;
+    embeddingProvider?: {
+        embed: (text: string) => Promise<number[]>;
+    };
+}
+export interface ContextSource {
+    id: string;
+    type: 'memory' | 'knowledge' | 'file' | 'custom';
+    content: string;
+    relevance?: number;
+    metadata?: Record<string, any>;
+}
+export interface FastContextResult {
+    context: string;
+    sources: ContextSource[];
+    tokenCount: number;
+    cached: boolean;
+    latencyMs: number;
+}
+export interface CacheEntry {
+    result: FastContextResult;
+    timestamp: number;
+    hits: number;
+}
+/**
+ * Fast Context class for efficient context retrieval
+ */
+export declare class FastContext {
+    private config;
+    private cache;
+    private sources;
+    constructor(config?: FastContextConfig);
+    /**
+     * Register a context source
+     */
+    registerSource(id: string, type: ContextSource['type'], contents: string[], metadata?: Record<string, any>): void;
+    /**
+     * Register memory as a source
+     */
+    registerMemory(memory: {
+        getAll: () => Array<{
+            content: string;
+            metadata?: any;
+        }>;
+    }): void;
+    /**
+     * Register knowledge base as a source
+     */
+    registerKnowledge(knowledge: {
+        search: (query: string, limit?: number) => Promise<Array<{
+            content: string;
+            score: number;
+        }>>;
+    }): void;
+    /**
+     * Get context for a query
+     */
+    getContext(query: string): Promise<FastContextResult>;
+    /**
+     * Gather relevant sources for a query
+     */
+    private gatherRelevantSources;
+    /**
+     * Score relevance using embeddings
+     */
+    private scoreRelevance;
+    /**
+     * Simple text-based relevance scoring
+     */
+    private scoreRelevanceSimple;
+    /**
+     * Build context from sources within token limit
+     */
+    private buildContext;
+    /**
+     * Get cache key for query
+     */
+    private getCacheKey;
+    /**
+     * Get from cache
+     */
+    private getFromCache;
+    /**
+     * Add to cache
+     */
+    private addToCache;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache stats
+     */
+    getCacheStats(): {
+        size: number;
+        totalHits: number;
+    };
+    /**
+     * Estimate token count
+     */
+    private estimateTokens;
+    /**
+     * Cosine similarity
+     */
+    private cosineSimilarity;
+    /**
+     * Clear all sources
+     */
+    clearSources(): void;
+}
+/**
+ * Create a fast context instance
+ */
+export declare function createFastContext(config?: FastContextConfig): FastContext;
+/**
+ * Quick context retrieval
+ */
+export declare function getQuickContext(query: string, sources: string[], maxTokens?: number): Promise<string>;