overai 1.4.0

package/dist/auto/index.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * AutoAgents - Automatic agent generation from task descriptions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoAgents = void 0;
+exports.createAutoAgents = createAutoAgents;
+const backend_resolver_1 = require("../llm/backend-resolver");
+/**
+ * AutoAgents - Generate agent configurations from task descriptions
+ */
+class AutoAgents {
+    constructor(config = {}) {
+        this.provider = null;
+        this.providerPromise = null;
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
+        this.pattern = config.pattern || 'sequential';
+        this.singleAgent = config.singleAgent ?? false;
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    async getProvider() {
+        if (this.provider) {
+            return this.provider;
+        }
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, {
+                    attribution: { agentId: 'AutoAgents' },
+                });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
+    /**
+     * Generate agent configuration from task description
+     */
+    async generate(taskDescription) {
+        const prompt = this.buildPrompt(taskDescription);
+        const provider = await this.getProvider();
+        const result = await provider.generateText({
+            messages: [
+                { role: 'system', content: this.getSystemPrompt() },
+                { role: 'user', content: prompt }
+            ]
+        });
+        return this.parseResponse(result.text);
+    }
+    /**
+     * Recommend a pattern for the task
+     */
+    recommendPattern(taskDescription) {
+        const lower = taskDescription.toLowerCase();
+        if (lower.includes('parallel') || lower.includes('concurrent') || lower.includes('simultaneously')) {
+            return 'parallel';
+        }
+        if (lower.includes('route') || lower.includes('classify') || lower.includes('categorize')) {
+            return 'routing';
+        }
+        if (lower.includes('orchestrat') || lower.includes('coordinat') || lower.includes('manage')) {
+            return 'orchestrator-workers';
+        }
+        if (lower.includes('evaluat') || lower.includes('optimi') || lower.includes('improv')) {
+            return 'evaluator-optimizer';
+        }
+        return 'sequential';
+    }
+    /**
+     * Analyze task complexity
+     */
+    analyzeComplexity(taskDescription) {
+        const words = taskDescription.split(/\s+/).length;
+        const hasMultipleSteps = /step|then|after|before|first|second|third|finally/i.test(taskDescription);
+        const hasMultipleAgents = /team|multiple|several|different|various/i.test(taskDescription);
+        if (words < 20 && !hasMultipleSteps && !hasMultipleAgents) {
+            return 'simple';
+        }
+        if (words > 100 || (hasMultipleSteps && hasMultipleAgents)) {
+            return 'complex';
+        }
+        return 'moderate';
+    }
+    getSystemPrompt() {
+        return `You are an AI agent architect. Your job is to analyze task descriptions and generate optimal agent configurations.
+
+Output a JSON object with the following structure:
+{
+  "agents": [
+    {
+      "name": "AgentName",
+      "role": "Role description",
+      "goal": "Agent's goal",
+      "backstory": "Optional backstory",
+      "instructions": "Specific instructions",
+      "tools": ["tool1", "tool2"]
+    }
+  ],
+  "tasks": [
+    {
+      "description": "Task description",
+      "expectedOutput": "What the task should produce",
+      "agent": "AgentName"
+    }
+  ],
+  "pattern": "sequential|parallel|hierarchical"
+}
+
+Guidelines:
+- For simple tasks, use 1 agent
+- For moderate tasks, use 2-3 agents
+- For complex tasks, use 3-5 agents
+- Match the pattern to the task requirements
+- Be specific about roles and goals`;
+    }
+    buildPrompt(taskDescription) {
+        const complexity = this.analyzeComplexity(taskDescription);
+        const recommendedPattern = this.recommendPattern(taskDescription);
+        return `Task Description: ${taskDescription}
+
+Complexity: ${complexity}
+Recommended Pattern: ${this.pattern || recommendedPattern}
+Single Agent Mode: ${this.singleAgent}
+
+Generate an optimal agent configuration for this task.`;
+    }
+    parseResponse(response) {
+        try {
+            // Extract JSON from response
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                return JSON.parse(jsonMatch[0]);
+            }
+        }
+        catch (error) {
+            // Fallback to default structure
+        }
+        // Default fallback
+        return {
+            agents: [{
+                    name: 'GeneralAgent',
+                    role: 'General purpose agent',
+                    goal: 'Complete the assigned task',
+                    instructions: 'Follow the task description carefully'
+                }],
+            tasks: [{
+                    description: 'Complete the task',
+                    agent: 'GeneralAgent'
+                }],
+            pattern: 'sequential'
+        };
+    }
+}
+exports.AutoAgents = AutoAgents;
+/**
+ * Create an AutoAgents instance
+ */
+function createAutoAgents(config) {
+    return new AutoAgents(config);
+}

package/dist/cache/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Cache System - In-memory and persistent caching for agents
+ * Inspired by mastra's cache module
+ */
+export interface CacheConfig {
+    name?: string;
+    ttl?: number;
+    maxSize?: number;
+}
+export interface CacheEntry<T = any> {
+    value: T;
+    createdAt: number;
+    expiresAt?: number;
+}
+/**
+ * Abstract base class for cache implementations
+ */
+export declare abstract class BaseCache {
+    readonly name: string;
+    constructor(config?: CacheConfig);
+    abstract get<T = any>(key: string): Promise<T | undefined>;
+    abstract set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    abstract delete(key: string): Promise<boolean>;
+    abstract clear(): Promise<void>;
+    abstract has(key: string): Promise<boolean>;
+    abstract keys(): Promise<string[]>;
+    abstract size(): Promise<number>;
+    abstract listPush<T = any>(key: string, value: T): Promise<void>;
+    abstract listLength(key: string): Promise<number>;
+    abstract listRange<T = any>(key: string, start: number, end?: number): Promise<T[]>;
+}
+/**
+ * In-memory cache implementation
+ */
+export declare class MemoryCache extends BaseCache {
+    private cache;
+    private lists;
+    private ttl?;
+    private maxSize?;
+    constructor(config?: CacheConfig);
+    get<T = any>(key: string): Promise<T | undefined>;
+    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    keys(): Promise<string[]>;
+    size(): Promise<number>;
+    listPush<T = any>(key: string, value: T): Promise<void>;
+    listLength(key: string): Promise<number>;
+    listRange<T = any>(key: string, start: number, end?: number): Promise<T[]>;
+}
+/**
+ * File-based cache implementation
+ */
+export declare class FileCache extends BaseCache {
+    private cacheDir;
+    private fs;
+    private path;
+    constructor(config?: CacheConfig & {
+        cacheDir?: string;
+    });
+    private ensureDir;
+    private getFilePath;
+    get<T = any>(key: string): Promise<T | undefined>;
+    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    keys(): Promise<string[]>;
+    size(): Promise<number>;
+    listPush<T = any>(key: string, value: T): Promise<void>;
+    listLength(key: string): Promise<number>;
+    listRange<T = any>(key: string, start: number, end?: number): Promise<T[]>;
+}
+export declare function createMemoryCache(config?: CacheConfig): MemoryCache;
+export declare function createFileCache(config?: CacheConfig & {
+    cacheDir?: string;
+}): FileCache;

package/dist/cache/index.js

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * Cache System - In-memory and persistent caching for agents
+ * Inspired by mastra's cache module
+ */
+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.FileCache = exports.MemoryCache = exports.BaseCache = void 0;
+exports.createMemoryCache = createMemoryCache;
+exports.createFileCache = createFileCache;
+/**
+ * Abstract base class for cache implementations
+ */
+class BaseCache {
+    constructor(config = {}) {
+        this.name = config.name || 'cache';
+    }
+}
+exports.BaseCache = BaseCache;
+/**
+ * In-memory cache implementation
+ */
+class MemoryCache extends BaseCache {
+    constructor(config = {}) {
+        super(config);
+        this.cache = new Map();
+        this.lists = new Map();
+        this.ttl = config.ttl;
+        this.maxSize = config.maxSize;
+    }
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        // Check expiration
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    async set(key, value, ttl) {
+        // Enforce max size
+        if (this.maxSize && this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            // Remove oldest entry
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey)
+                this.cache.delete(firstKey);
+        }
+        const effectiveTtl = ttl ?? this.ttl;
+        const entry = {
+            value,
+            createdAt: Date.now(),
+            expiresAt: effectiveTtl ? Date.now() + effectiveTtl : undefined
+        };
+        this.cache.set(key, entry);
+    }
+    async delete(key) {
+        const existed = this.cache.has(key);
+        this.cache.delete(key);
+        this.lists.delete(key);
+        return existed;
+    }
+    async clear() {
+        this.cache.clear();
+        this.lists.clear();
+    }
+    async has(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return false;
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    async keys() {
+        return Array.from(this.cache.keys());
+    }
+    async size() {
+        return this.cache.size;
+    }
+    async listPush(key, value) {
+        if (!this.lists.has(key)) {
+            this.lists.set(key, []);
+        }
+        this.lists.get(key).push(value);
+    }
+    async listLength(key) {
+        return this.lists.get(key)?.length ?? 0;
+    }
+    async listRange(key, start, end) {
+        const list = this.lists.get(key) ?? [];
+        return list.slice(start, end);
+    }
+}
+exports.MemoryCache = MemoryCache;
+/**
+ * File-based cache implementation
+ */
+class FileCache extends BaseCache {
+    constructor(config = {}) {
+        super(config);
+        this.cacheDir = config.cacheDir || '.cache';
+    }
+    async ensureDir() {
+        if (!this.fs) {
+            this.fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            this.path = await Promise.resolve().then(() => __importStar(require('path')));
+        }
+        try {
+            await this.fs.mkdir(this.cacheDir, { recursive: true });
+        }
+        catch { }
+    }
+    getFilePath(key) {
+        const safeKey = key.replace(/[^a-zA-Z0-9-_]/g, '_');
+        return this.path.join(this.cacheDir, `${safeKey}.json`);
+    }
+    async get(key) {
+        await this.ensureDir();
+        try {
+            const data = await this.fs.readFile(this.getFilePath(key), 'utf-8');
+            const entry = JSON.parse(data);
+            if (entry.expiresAt && Date.now() > entry.expiresAt) {
+                await this.delete(key);
+                return undefined;
+            }
+            return entry.value;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async set(key, value, ttl) {
+        await this.ensureDir();
+        const entry = {
+            value,
+            createdAt: Date.now(),
+            expiresAt: ttl ? Date.now() + ttl : undefined
+        };
+        await this.fs.writeFile(this.getFilePath(key), JSON.stringify(entry));
+    }
+    async delete(key) {
+        await this.ensureDir();
+        try {
+            await this.fs.unlink(this.getFilePath(key));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async clear() {
+        await this.ensureDir();
+        try {
+            const files = await this.fs.readdir(this.cacheDir);
+            await Promise.all(files.filter((f) => f.endsWith('.json'))
+                .map((f) => this.fs.unlink(this.path.join(this.cacheDir, f))));
+        }
+        catch { }
+    }
+    async has(key) {
+        return (await this.get(key)) !== undefined;
+    }
+    async keys() {
+        await this.ensureDir();
+        try {
+            const files = await this.fs.readdir(this.cacheDir);
+            return files
+                .filter((f) => f.endsWith('.json'))
+                .map((f) => f.replace('.json', ''));
+        }
+        catch {
+            return [];
+        }
+    }
+    async size() {
+        return (await this.keys()).length;
+    }
+    async listPush(key, value) {
+        const list = (await this.get(`list_${key}`)) || [];
+        list.push(value);
+        await this.set(`list_${key}`, list);
+    }
+    async listLength(key) {
+        const list = (await this.get(`list_${key}`)) || [];
+        return list.length;
+    }
+    async listRange(key, start, end) {
+        const list = (await this.get(`list_${key}`)) || [];
+        return list.slice(start, end);
+    }
+}
+exports.FileCache = FileCache;
+// Factory functions
+function createMemoryCache(config) {
+    return new MemoryCache(config);
+}
+function createFileCache(config) {
+    return new FileCache(config);
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Agent command - Run a single agent with instructions
+ *
+ * Usage:
+ *   praisonai agent chat "Hello, how are you?"
+ *   praisonai agent run --instructions "You are helpful" "Tell me a joke"
+ */
+export interface AgentOptions {
+    instructions?: string;
+    model?: string;
+    stream?: boolean;
+    verbose?: boolean;
+    profile?: string;
+    config?: string;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    sessionId?: string;
+}
+/**
+ * Execute agent chat subcommand
+ */
+export declare function executeChat(args: string[], options: AgentOptions): Promise<void>;
+/**
+ * Execute agent run subcommand (same as chat but requires instructions)
+ */
+export declare function executeRun(args: string[], options: AgentOptions): Promise<void>;
+/**
+ * Main execute function - routes to subcommands
+ */
+export declare function execute(args: string[], options: AgentOptions): Promise<void>;

package/dist/cli/commands/agent.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Agent command - Run a single agent with instructions
+ *
+ * Usage:
+ *   praisonai agent chat "Hello, how are you?"
+ *   praisonai agent run --instructions "You are helpful" "Tell me a joke"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeChat = executeChat;
+exports.executeRun = executeRun;
+exports.execute = execute;
+const agent_1 = require("../../agent");
+const resolve_1 = require("../config/resolve");
+const cli_spec_1 = require("../spec/cli-spec");
+const pretty_logger_1 = require("../../utils/pretty-logger");
+const outputJson = (obj) => console.log(JSON.stringify(obj));
+const formatSuccess = (data, meta) => meta ? { success: true, data, meta } : { success: true, data };
+const formatError = (code, message, details) => details
+    ? { success: false, error: { code, message, details } }
+    : { success: false, error: { code, message } };
+const ERROR_CODES = {
+    INVALID_ARGS: 'INVALID_ARGUMENTS',
+    MISSING_ARG: 'MISSING_ARGUMENT',
+    UNKNOWN: 'UNKNOWN_ERROR',
+};
+function normalizeError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const details = error instanceof Error && error.stack ? { stack: error.stack } : undefined;
+    return { code: ERROR_CODES.UNKNOWN, message, details, exitCode: cli_spec_1.EXIT_CODES.RUNTIME_ERROR };
+}
+const pretty = {
+    success: pretty_logger_1.PrettyLogger.success,
+    error: pretty_logger_1.PrettyLogger.error,
+    info: pretty_logger_1.PrettyLogger.info,
+    dim: async (s) => console.log(s),
+    plain: async (s) => console.log(s),
+    heading: async (s) => console.log(s),
+    newline: async () => console.log(),
+};
+/**
+ * Execute agent chat subcommand
+ */
+async function executeChat(args, options) {
+    const prompt = args[0];
+    if (!prompt) {
+        if (options.json || options.output === 'json') {
+            outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Please provide a prompt'));
+        }
+        else {
+            await pretty.error('Please provide a prompt');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const config = (0, resolve_1.resolveConfig)({
+        configPath: options.config,
+        profile: options.profile,
+        model: options.model,
+        verbose: options.verbose,
+        stream: options.stream
+    });
+    const startTime = Date.now();
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        const agent = new agent_1.Agent({
+            instructions: options.instructions || 'You are a helpful AI assistant.',
+            llm: config.model,
+            stream: config.stream && outputFormat !== 'json',
+            verbose: config.verbose,
+            sessionId: options.sessionId
+        });
+        const response = await agent.chat(prompt);
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                response,
+                agent: agent.name,
+                sessionId: agent.getSessionId()
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else if (outputFormat === 'text') {
+            console.log(response);
+        }
+        else {
+            // Pretty output - response already printed if streaming
+            if (!config.stream) {
+                console.log(response);
+            }
+            console.log(); // Newline
+            await pretty.dim(`Completed in ${duration}ms`);
+        }
+    }
+    catch (error) {
+        const cliError = normalizeError(error);
+        if (outputFormat === 'json') {
+            outputJson(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);
+    }
+}
+/**
+ * Execute agent run subcommand (same as chat but requires instructions)
+ */
+async function executeRun(args, options) {
+    if (!options.instructions) {
+        if (options.json || options.output === 'json') {
+            outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Please provide --instructions'));
+        }
+        else {
+            await pretty.error('Please provide --instructions');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    return executeChat(args, options);
+}
+/**
+ * Main execute function - routes to subcommands
+ */
+async function execute(args, options) {
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    switch (subcommand) {
+        case 'chat':
+            return executeChat(subArgs, options);
+        case 'run':
+            return executeRun(subArgs, options);
+        default:
+            // If no subcommand, treat the first arg as a prompt for chat
+            if (subcommand) {
+                return executeChat(args, options);
+            }
+            if (options.json || options.output === 'json') {
+                outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Please provide a subcommand (chat, run) or a prompt'));
+            }
+            else {
+                await pretty.error('Usage: overai agent [chat|run] <prompt>');
+                await pretty.info('  agent chat "Hello"           - Chat with default agent');
+                await pretty.info('  agent run --instructions "..." "Hello" - Run with custom instructions');
+            }
+            process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Agents command - Run multi-agent orchestration
+ *
+ * Usage:
+ *   overai agents run --agents "researcher,writer" "Research AI trends"
+ */
+export interface AgentsOptions {
+    agents?: string;
+    process?: 'sequential' | 'parallel';
+    model?: string;
+    verbose?: boolean;
+    profile?: string;
+    config?: string;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+/**
+ * Execute agents run subcommand
+ */
+export declare function executeRun(args: string[], options: AgentsOptions): Promise<void>;
+/**
+ * Main execute function - routes to subcommands
+ */
+export declare function execute(args: string[], options: AgentsOptions): Promise<void>;