overai 1.4.0

package/dist/cli/features/checkpoints.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * Checkpoints - Snapshot session/run state for recovery
+ */
+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.CheckpointManager = exports.FileCheckpointStorage = exports.MemoryCheckpointStorage = void 0;
+exports.createCheckpointManager = createCheckpointManager;
+exports.createFileCheckpointStorage = createFileCheckpointStorage;
+/**
+ * In-memory checkpoint storage
+ */
+class MemoryCheckpointStorage {
+    constructor() {
+        this.checkpoints = new Map();
+    }
+    async save(checkpoint) {
+        this.checkpoints.set(checkpoint.id, { ...checkpoint });
+    }
+    async load(id) {
+        return this.checkpoints.get(id) || null;
+    }
+    async list() {
+        return Array.from(this.checkpoints.values())
+            .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    }
+    async delete(id) {
+        this.checkpoints.delete(id);
+    }
+    async clear() {
+        this.checkpoints.clear();
+    }
+}
+exports.MemoryCheckpointStorage = MemoryCheckpointStorage;
+/**
+ * File-based checkpoint storage
+ */
+class FileCheckpointStorage {
+    constructor(dirPath) {
+        this.dirPath = dirPath;
+    }
+    async ensureDir() {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        await fs.mkdir(this.dirPath, { recursive: true });
+    }
+    getFilePath(id) {
+        return `${this.dirPath}/${id}.json`;
+    }
+    async save(checkpoint) {
+        await this.ensureDir();
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        await fs.writeFile(this.getFilePath(checkpoint.id), JSON.stringify(checkpoint, null, 2));
+    }
+    async load(id) {
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const content = await fs.readFile(this.getFilePath(id), 'utf-8');
+            const data = JSON.parse(content);
+            data.timestamp = new Date(data.timestamp);
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
+    async list() {
+        try {
+            await this.ensureDir();
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const files = await fs.readdir(this.dirPath);
+            const checkpoints = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const id = file.replace('.json', '');
+                    const checkpoint = await this.load(id);
+                    if (checkpoint) {
+                        checkpoints.push(checkpoint);
+                    }
+                }
+            }
+            return checkpoints.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        }
+        catch {
+            return [];
+        }
+    }
+    async delete(id) {
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            await fs.unlink(this.getFilePath(id));
+        }
+        catch {
+            // Ignore if file doesn't exist
+        }
+    }
+    async clear() {
+        const checkpoints = await this.list();
+        for (const checkpoint of checkpoints) {
+            await this.delete(checkpoint.id);
+        }
+    }
+}
+exports.FileCheckpointStorage = FileCheckpointStorage;
+/**
+ * Checkpoint Manager class
+ */
+class CheckpointManager {
+    constructor(config = {}) {
+        this.currentState = {};
+        this.config = {
+            autoSave: false,
+            autoSaveInterval: 60000, // 1 minute
+            maxCheckpoints: 10,
+            ...config
+        };
+        this.storage = config.storage || new MemoryCheckpointStorage();
+    }
+    /**
+     * Create a checkpoint
+     */
+    async create(name, options = {}) {
+        const checkpoint = {
+            id: `cp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            name,
+            timestamp: new Date(),
+            state: { ...this.currentState },
+            ...options
+        };
+        await this.storage.save(checkpoint);
+        await this.enforceMaxCheckpoints();
+        return checkpoint;
+    }
+    /**
+     * Restore from a checkpoint
+     */
+    async restore(id) {
+        const checkpoint = await this.storage.load(id);
+        if (checkpoint) {
+            this.currentState = { ...checkpoint.state };
+        }
+        return checkpoint;
+    }
+    /**
+     * Restore the latest checkpoint
+     */
+    async restoreLatest() {
+        const checkpoints = await this.storage.list();
+        if (checkpoints.length === 0)
+            return null;
+        return this.restore(checkpoints[0].id);
+    }
+    /**
+     * Get a checkpoint by ID
+     */
+    async get(id) {
+        return this.storage.load(id);
+    }
+    /**
+     * List all checkpoints
+     */
+    async list() {
+        return this.storage.list();
+    }
+    /**
+     * Delete a checkpoint
+     */
+    async delete(id) {
+        await this.storage.delete(id);
+    }
+    /**
+     * Clear all checkpoints
+     */
+    async clear() {
+        await this.storage.clear();
+    }
+    /**
+     * Update current state
+     */
+    setState(state) {
+        this.currentState = { ...this.currentState, ...state };
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return { ...this.currentState };
+    }
+    /**
+     * Start auto-save
+     */
+    startAutoSave() {
+        if (this.autoSaveTimer)
+            return;
+        if (!this.config.autoSave)
+            return;
+        this.autoSaveTimer = setInterval(async () => {
+            await this.create('auto-save', { metadata: { auto: true } });
+        }, this.config.autoSaveInterval);
+    }
+    /**
+     * Stop auto-save
+     */
+    stopAutoSave() {
+        if (this.autoSaveTimer) {
+            clearInterval(this.autoSaveTimer);
+            this.autoSaveTimer = undefined;
+        }
+    }
+    /**
+     * Enforce maximum checkpoints limit
+     */
+    async enforceMaxCheckpoints() {
+        if (!this.config.maxCheckpoints)
+            return;
+        const checkpoints = await this.storage.list();
+        if (checkpoints.length > this.config.maxCheckpoints) {
+            // Delete oldest checkpoints (but keep auto-saves separate)
+            const toDelete = checkpoints.slice(this.config.maxCheckpoints);
+            for (const checkpoint of toDelete) {
+                await this.storage.delete(checkpoint.id);
+            }
+        }
+    }
+    /**
+     * Export checkpoint to JSON string
+     */
+    async export(id) {
+        const checkpoint = await this.storage.load(id);
+        if (!checkpoint)
+            return null;
+        return JSON.stringify(checkpoint, null, 2);
+    }
+    /**
+     * Import checkpoint from JSON string
+     */
+    async import(json) {
+        const data = JSON.parse(json);
+        data.timestamp = new Date(data.timestamp);
+        data.id = `cp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`; // New ID
+        await this.storage.save(data);
+        return data;
+    }
+}
+exports.CheckpointManager = CheckpointManager;
+/**
+ * Create a checkpoint manager
+ */
+function createCheckpointManager(config) {
+    return new CheckpointManager(config);
+}
+/**
+ * Create file-based checkpoint storage
+ */
+function createFileCheckpointStorage(dirPath) {
+    return new FileCheckpointStorage(dirPath);
+}

package/dist/cli/features/cost-tracker.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Cost Tracker - Track token usage and costs across LLM requests
+ */
+export interface ModelPricing {
+    inputCostPer1k: number;
+    outputCostPer1k: number;
+}
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+export interface RequestStats {
+    timestamp: number;
+    model: string;
+    usage: TokenUsage;
+    cost: number;
+    latencyMs?: number;
+}
+export interface SessionStats {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalTokens: number;
+    totalCost: number;
+    requestCount: number;
+    avgLatencyMs: number;
+    startTime: number;
+    requests: RequestStats[];
+}
+/**
+ * Model pricing data (USD per 1K tokens)
+ */
+export declare const MODEL_PRICING: Record<string, ModelPricing>;
+/**
+ * Cost Tracker class
+ */
+export declare class CostTracker {
+    private stats;
+    private customPricing;
+    constructor();
+    private createEmptyStats;
+    /**
+     * Add a request's token usage
+     */
+    addUsage(model: string, inputTokens: number, outputTokens: number, latencyMs?: number): RequestStats;
+    /**
+     * Calculate cost for token usage
+     */
+    calculateCost(model: string, inputTokens: number, outputTokens: number): number;
+    /**
+     * Get pricing for a model
+     */
+    getPricing(model: string): ModelPricing;
+    /**
+     * Set custom pricing for a model
+     */
+    setCustomPricing(model: string, pricing: ModelPricing): void;
+    /**
+     * Get current session stats
+     */
+    getStats(): SessionStats;
+    /**
+     * Get summary string
+     */
+    getSummary(): string;
+    /**
+     * Get detailed breakdown by model
+     */
+    getBreakdownByModel(): Record<string, {
+        tokens: number;
+        cost: number;
+        requests: number;
+    }>;
+    /**
+     * Reset stats
+     */
+    reset(): void;
+    /**
+     * Export stats to JSON
+     */
+    toJSON(): SessionStats;
+    /**
+     * Import stats from JSON
+     */
+    fromJSON(data: SessionStats): void;
+    get totalTokens(): number;
+    get totalCost(): number;
+    get requests(): number;
+}
+/**
+ * Create a cost tracker instance
+ */
+export declare function createCostTracker(): CostTracker;
+/**
+ * Estimate tokens from text (rough approximation)
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Format cost as currency string
+ */
+export declare function formatCost(cost: number): string;

package/dist/cli/features/cost-tracker.js

@@ -0,0 +1,212 @@
+"use strict";
+/**
+ * Cost Tracker - Track token usage and costs across LLM requests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostTracker = exports.MODEL_PRICING = void 0;
+exports.createCostTracker = createCostTracker;
+exports.estimateTokens = estimateTokens;
+exports.formatCost = formatCost;
+/**
+ * Model pricing data (USD per 1K tokens)
+ */
+exports.MODEL_PRICING = {
+    // OpenAI
+    'gpt-4o': { inputCostPer1k: 0.005, outputCostPer1k: 0.015 },
+    'gpt-4o-mini': { inputCostPer1k: 0.00015, outputCostPer1k: 0.0006 },
+    'gpt-4-turbo': { inputCostPer1k: 0.01, outputCostPer1k: 0.03 },
+    'gpt-4': { inputCostPer1k: 0.03, outputCostPer1k: 0.06 },
+    'gpt-3.5-turbo': { inputCostPer1k: 0.0005, outputCostPer1k: 0.0015 },
+    'o1': { inputCostPer1k: 0.015, outputCostPer1k: 0.06 },
+    'o1-mini': { inputCostPer1k: 0.003, outputCostPer1k: 0.012 },
+    'o1-preview': { inputCostPer1k: 0.015, outputCostPer1k: 0.06 },
+    // Anthropic
+    'claude-3-5-sonnet-20241022': { inputCostPer1k: 0.003, outputCostPer1k: 0.015 },
+    'claude-3-5-haiku-20241022': { inputCostPer1k: 0.001, outputCostPer1k: 0.005 },
+    'claude-3-opus-20240229': { inputCostPer1k: 0.015, outputCostPer1k: 0.075 },
+    'claude-3-sonnet-20240229': { inputCostPer1k: 0.003, outputCostPer1k: 0.015 },
+    'claude-3-haiku-20240307': { inputCostPer1k: 0.00025, outputCostPer1k: 0.00125 },
+    // Google
+    'gemini-2.0-flash': { inputCostPer1k: 0.0001, outputCostPer1k: 0.0004 },
+    'gemini-1.5-pro': { inputCostPer1k: 0.00125, outputCostPer1k: 0.005 },
+    'gemini-1.5-flash': { inputCostPer1k: 0.000075, outputCostPer1k: 0.0003 },
+    // Default fallback
+    'default': { inputCostPer1k: 0.001, outputCostPer1k: 0.002 }
+};
+/**
+ * Cost Tracker class
+ */
+class CostTracker {
+    constructor() {
+        this.customPricing = new Map();
+        this.stats = this.createEmptyStats();
+    }
+    createEmptyStats() {
+        return {
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalTokens: 0,
+            totalCost: 0,
+            requestCount: 0,
+            avgLatencyMs: 0,
+            startTime: Date.now(),
+            requests: []
+        };
+    }
+    /**
+     * Add a request's token usage
+     */
+    addUsage(model, inputTokens, outputTokens, latencyMs) {
+        const totalTokens = inputTokens + outputTokens;
+        const cost = this.calculateCost(model, inputTokens, outputTokens);
+        const request = {
+            timestamp: Date.now(),
+            model,
+            usage: { inputTokens, outputTokens, totalTokens },
+            cost,
+            latencyMs
+        };
+        this.stats.requests.push(request);
+        this.stats.totalInputTokens += inputTokens;
+        this.stats.totalOutputTokens += outputTokens;
+        this.stats.totalTokens += totalTokens;
+        this.stats.totalCost += cost;
+        this.stats.requestCount++;
+        if (latencyMs !== undefined) {
+            const totalLatency = this.stats.avgLatencyMs * (this.stats.requestCount - 1) + latencyMs;
+            this.stats.avgLatencyMs = totalLatency / this.stats.requestCount;
+        }
+        return request;
+    }
+    /**
+     * Calculate cost for token usage
+     */
+    calculateCost(model, inputTokens, outputTokens) {
+        const pricing = this.getPricing(model);
+        const inputCost = (inputTokens / 1000) * pricing.inputCostPer1k;
+        const outputCost = (outputTokens / 1000) * pricing.outputCostPer1k;
+        return inputCost + outputCost;
+    }
+    /**
+     * Get pricing for a model
+     */
+    getPricing(model) {
+        // Check custom pricing first
+        if (this.customPricing.has(model)) {
+            return this.customPricing.get(model);
+        }
+        // Check built-in pricing
+        if (exports.MODEL_PRICING[model]) {
+            return exports.MODEL_PRICING[model];
+        }
+        // Try to match partial model names
+        for (const [key, pricing] of Object.entries(exports.MODEL_PRICING)) {
+            if (model.includes(key) || key.includes(model)) {
+                return pricing;
+            }
+        }
+        return exports.MODEL_PRICING['default'];
+    }
+    /**
+     * Set custom pricing for a model
+     */
+    setCustomPricing(model, pricing) {
+        this.customPricing.set(model, pricing);
+    }
+    /**
+     * Get current session stats
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get summary string
+     */
+    getSummary() {
+        const duration = (Date.now() - this.stats.startTime) / 1000;
+        const lines = [
+            '=== Cost Summary ===',
+            `Requests: ${this.stats.requestCount}`,
+            `Duration: ${duration.toFixed(1)}s`,
+            '',
+            'Tokens:',
+            `  Input:  ${this.stats.totalInputTokens.toLocaleString()}`,
+            `  Output: ${this.stats.totalOutputTokens.toLocaleString()}`,
+            `  Total:  ${this.stats.totalTokens.toLocaleString()}`,
+            '',
+            `Total Cost: $${this.stats.totalCost.toFixed(6)}`,
+        ];
+        if (this.stats.avgLatencyMs > 0) {
+            lines.push(`Avg Latency: ${this.stats.avgLatencyMs.toFixed(0)}ms`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get detailed breakdown by model
+     */
+    getBreakdownByModel() {
+        const breakdown = {};
+        for (const request of this.stats.requests) {
+            if (!breakdown[request.model]) {
+                breakdown[request.model] = { tokens: 0, cost: 0, requests: 0 };
+            }
+            breakdown[request.model].tokens += request.usage.totalTokens;
+            breakdown[request.model].cost += request.cost;
+            breakdown[request.model].requests++;
+        }
+        return breakdown;
+    }
+    /**
+     * Reset stats
+     */
+    reset() {
+        this.stats = this.createEmptyStats();
+    }
+    /**
+     * Export stats to JSON
+     */
+    toJSON() {
+        return this.getStats();
+    }
+    /**
+     * Import stats from JSON
+     */
+    fromJSON(data) {
+        this.stats = { ...data };
+    }
+    // Legacy interface compatibility
+    get totalTokens() {
+        return this.stats.totalTokens;
+    }
+    get totalCost() {
+        return this.stats.totalCost;
+    }
+    get requests() {
+        return this.stats.requestCount;
+    }
+}
+exports.CostTracker = CostTracker;
+/**
+ * Create a cost tracker instance
+ */
+function createCostTracker() {
+    return new CostTracker();
+}
+/**
+ * Estimate tokens from text (rough approximation)
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Format cost as currency string
+ */
+function formatCost(cost) {
+    if (cost < 0.01) {
+        return `$${cost.toFixed(6)}`;
+    }
+    if (cost < 1) {
+        return `$${cost.toFixed(4)}`;
+    }
+    return `$${cost.toFixed(2)}`;
+}

package/dist/cli/features/external-agents.d.ts

@@ -0,0 +1,117 @@
+/**
+ * External Agents - Integration adapters for external AI CLI tools
+ *
+ * Allows OverAI to use other CLI tools as sub-agents or tools.
+ */
+export interface ExternalAgentConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+}
+export interface ExternalAgentResult {
+    success: boolean;
+    output: string;
+    error?: string;
+    exitCode: number;
+    duration: number;
+}
+/**
+ * Base class for external agent integrations
+ */
+export declare abstract class BaseExternalAgent {
+    protected config: ExternalAgentConfig;
+    constructor(config: ExternalAgentConfig);
+    /**
+     * Check if the external tool is available
+     */
+    abstract isAvailable(): Promise<boolean>;
+    /**
+     * Execute a prompt with the external agent
+     */
+    abstract execute(prompt: string): Promise<ExternalAgentResult>;
+    /**
+     * Get the agent name
+     */
+    getName(): string;
+    /**
+     * Execute a command and return result
+     */
+    protected runCommand(args: string[]): Promise<ExternalAgentResult>;
+    /**
+     * Check if a command exists
+     */
+    protected commandExists(command: string): Promise<boolean>;
+}
+/**
+ * Claude Code CLI integration
+ */
+export declare class ClaudeCodeAgent extends BaseExternalAgent {
+    constructor(cwd?: string);
+    isAvailable(): Promise<boolean>;
+    execute(prompt: string): Promise<ExternalAgentResult>;
+    executeWithSession(prompt: string, sessionId?: string): Promise<ExternalAgentResult>;
+}
+/**
+ * Gemini CLI integration
+ */
+export declare class GeminiCliAgent extends BaseExternalAgent {
+    private model;
+    constructor(cwd?: string, model?: string);
+    isAvailable(): Promise<boolean>;
+    execute(prompt: string): Promise<ExternalAgentResult>;
+}
+/**
+ * OpenAI Codex CLI integration
+ */
+export declare class CodexCliAgent extends BaseExternalAgent {
+    constructor(cwd?: string);
+    isAvailable(): Promise<boolean>;
+    execute(prompt: string): Promise<ExternalAgentResult>;
+}
+/**
+ * Aider CLI integration
+ */
+export declare class AiderAgent extends BaseExternalAgent {
+    constructor(cwd?: string);
+    isAvailable(): Promise<boolean>;
+    execute(prompt: string): Promise<ExternalAgentResult>;
+}
+/**
+ * Generic external agent for any CLI tool
+ */
+export declare class GenericExternalAgent extends BaseExternalAgent {
+    private promptArg;
+    constructor(config: ExternalAgentConfig & {
+        promptArg?: string;
+    });
+    isAvailable(): Promise<boolean>;
+    execute(prompt: string): Promise<ExternalAgentResult>;
+}
+/**
+ * External Agent Registry
+ */
+declare class ExternalAgentRegistry {
+    private agents;
+    constructor();
+    register(name: string, factory: () => BaseExternalAgent): void;
+    get(name: string): BaseExternalAgent | undefined;
+    list(): string[];
+    getAvailable(): Promise<string[]>;
+}
+export declare function getExternalAgentRegistry(): ExternalAgentRegistry;
+/**
+ * Create an external agent by name
+ */
+export declare function createExternalAgent(name: string, cwd?: string): BaseExternalAgent | undefined;
+/**
+ * Convert external agent to tool for use with PraisonAI agents
+ */
+export declare function externalAgentAsTool(agent: BaseExternalAgent): {
+    name: string;
+    description: string;
+    execute: (input: string) => Promise<string>;
+};
+export {};