overai 1.4.0

package/dist/cli/features/interactive-tui.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Interactive TUI - Terminal User Interface for CLI
+ * Minimal but functional interactive mode with readline
+ */
+import { SlashCommandContext } from './slash-commands';
+import { CostTracker } from './cost-tracker';
+export interface TUIConfig {
+    prompt?: string;
+    welcomeMessage?: string;
+    historyFile?: string;
+    maxHistorySize?: number;
+    onMessage?: (message: string) => Promise<string>;
+    onExit?: () => void;
+}
+export interface TUIState {
+    running: boolean;
+    history: string[];
+    context: SlashCommandContext;
+}
+/**
+ * Interactive TUI class
+ */
+export declare class InteractiveTUI {
+    private config;
+    private state;
+    private slashHandler;
+    private costTracker;
+    private readline;
+    private rl;
+    constructor(config?: TUIConfig);
+    /**
+     * Start the interactive session
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the interactive session
+     */
+    stop(): void;
+    /**
+     * Main input loop
+     */
+    private inputLoop;
+    /**
+     * Prompt for input
+     */
+    private prompt;
+    /**
+     * Output a message
+     */
+    private output;
+    /**
+     * Add input to history
+     */
+    private addToHistory;
+    /**
+     * Load history from file
+     */
+    private loadHistory;
+    /**
+     * Save history to file
+     */
+    private saveHistory;
+    /**
+     * Get current state
+     */
+    getState(): TUIState;
+    /**
+     * Get cost tracker
+     */
+    getCostTracker(): CostTracker;
+    /**
+     * Update context
+     */
+    updateContext(updates: Partial<SlashCommandContext>): void;
+}
+/**
+ * Create an interactive TUI instance
+ */
+export declare function createInteractiveTUI(config?: TUIConfig): InteractiveTUI;
+/**
+ * Simple status display helper
+ */
+export declare class StatusDisplay {
+    private lines;
+    add(label: string, value: string | number): this;
+    addSeparator(): this;
+    addHeader(text: string): this;
+    toString(): string;
+    print(): void;
+    clear(): void;
+}
+/**
+ * Create a status display
+ */
+export declare function createStatusDisplay(): StatusDisplay;
+/**
+ * History manager for persistent command history
+ */
+export declare class HistoryManager {
+    private history;
+    private maxSize;
+    private filePath?;
+    constructor(maxSize?: number, filePath?: string);
+    add(entry: string): void;
+    getAll(): string[];
+    search(query: string): string[];
+    load(): Promise<void>;
+    save(): Promise<void>;
+    clear(): void;
+}
+/**
+ * Create a history manager
+ */
+export declare function createHistoryManager(maxSize?: number, filePath?: string): HistoryManager;

package/dist/cli/features/interactive-tui.js

@@ -0,0 +1,326 @@
+"use strict";
+/**
+ * Interactive TUI - Terminal User Interface for CLI
+ * Minimal but functional interactive mode with readline
+ */
+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.HistoryManager = exports.StatusDisplay = exports.InteractiveTUI = void 0;
+exports.createInteractiveTUI = createInteractiveTUI;
+exports.createStatusDisplay = createStatusDisplay;
+exports.createHistoryManager = createHistoryManager;
+const slash_commands_1 = require("./slash-commands");
+const cost_tracker_1 = require("./cost-tracker");
+/**
+ * Interactive TUI class
+ */
+class InteractiveTUI {
+    constructor(config = {}) {
+        this.config = {
+            prompt: '> ',
+            welcomeMessage: 'OverAI Interactive Mode. Type /help for commands, /exit to quit.',
+            maxHistorySize: 1000,
+            ...config
+        };
+        this.costTracker = (0, cost_tracker_1.createCostTracker)();
+        this.state = {
+            running: false,
+            history: [],
+            context: {
+                history: [],
+                settings: {},
+                costTracker: this.costTracker,
+                onOutput: (msg) => this.output(msg)
+            }
+        };
+        this.slashHandler = new slash_commands_1.SlashCommandHandler(this.state.context);
+    }
+    /**
+     * Start the interactive session
+     */
+    async start() {
+        if (this.state.running)
+            return;
+        // Lazy load readline
+        this.readline = await Promise.resolve().then(() => __importStar(require('readline')));
+        this.rl = this.readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true
+        });
+        this.state.running = true;
+        // Load history if available
+        await this.loadHistory();
+        // Show welcome message
+        if (this.config.welcomeMessage) {
+            this.output(this.config.welcomeMessage);
+        }
+        // Start the input loop
+        await this.inputLoop();
+    }
+    /**
+     * Stop the interactive session
+     */
+    stop() {
+        this.state.running = false;
+        if (this.rl) {
+            this.rl.close();
+        }
+        this.saveHistory();
+        this.config.onExit?.();
+    }
+    /**
+     * Main input loop
+     */
+    async inputLoop() {
+        while (this.state.running) {
+            const input = await this.prompt();
+            if (input === null) {
+                // EOF or Ctrl+C
+                this.stop();
+                break;
+            }
+            const trimmed = input.trim();
+            if (!trimmed)
+                continue;
+            // Add to history
+            this.addToHistory(trimmed);
+            // Handle slash commands
+            if ((0, slash_commands_1.isSlashCommand)(trimmed)) {
+                const result = await this.slashHandler.handle(trimmed);
+                if (result.shouldExit) {
+                    this.stop();
+                    break;
+                }
+                continue;
+            }
+            // Handle regular message
+            if (this.config.onMessage) {
+                try {
+                    const response = await this.config.onMessage(trimmed);
+                    this.output(response);
+                }
+                catch (error) {
+                    this.output(`Error: ${error.message}`);
+                }
+            }
+            else {
+                this.output('No message handler configured. Use /help for available commands.');
+            }
+        }
+    }
+    /**
+     * Prompt for input
+     */
+    prompt() {
+        return new Promise((resolve) => {
+            if (!this.state.running || !this.rl) {
+                resolve(null);
+                return;
+            }
+            this.rl.question(this.config.prompt, (answer) => {
+                resolve(answer);
+            });
+            // Handle Ctrl+C
+            this.rl.once('close', () => {
+                resolve(null);
+            });
+        });
+    }
+    /**
+     * Output a message
+     */
+    output(message) {
+        console.log(message);
+    }
+    /**
+     * Add input to history
+     */
+    addToHistory(input) {
+        this.state.history.push(input);
+        if (this.state.history.length > (this.config.maxHistorySize || 1000)) {
+            this.state.history.shift();
+        }
+    }
+    /**
+     * Load history from file
+     */
+    async loadHistory() {
+        if (!this.config.historyFile)
+            return;
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const content = await fs.readFile(this.config.historyFile, 'utf-8');
+            this.state.history = content.trim().split('\n').filter(Boolean);
+        }
+        catch {
+            // Ignore if file doesn't exist
+        }
+    }
+    /**
+     * Save history to file
+     */
+    async saveHistory() {
+        if (!this.config.historyFile)
+            return;
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            await fs.writeFile(this.config.historyFile, this.state.history.join('\n'));
+        }
+        catch {
+            // Ignore save errors
+        }
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Get cost tracker
+     */
+    getCostTracker() {
+        return this.costTracker;
+    }
+    /**
+     * Update context
+     */
+    updateContext(updates) {
+        this.slashHandler.updateContext(updates);
+    }
+}
+exports.InteractiveTUI = InteractiveTUI;
+/**
+ * Create an interactive TUI instance
+ */
+function createInteractiveTUI(config) {
+    return new InteractiveTUI(config);
+}
+/**
+ * Simple status display helper
+ */
+class StatusDisplay {
+    constructor() {
+        this.lines = [];
+    }
+    add(label, value) {
+        this.lines.push(`${label}: ${value}`);
+        return this;
+    }
+    addSeparator() {
+        this.lines.push('─'.repeat(40));
+        return this;
+    }
+    addHeader(text) {
+        this.lines.push(`\n=== ${text} ===`);
+        return this;
+    }
+    toString() {
+        return this.lines.join('\n');
+    }
+    print() {
+        console.log(this.toString());
+    }
+    clear() {
+        this.lines = [];
+    }
+}
+exports.StatusDisplay = StatusDisplay;
+/**
+ * Create a status display
+ */
+function createStatusDisplay() {
+    return new StatusDisplay();
+}
+/**
+ * History manager for persistent command history
+ */
+class HistoryManager {
+    constructor(maxSize = 1000, filePath) {
+        this.history = [];
+        this.maxSize = maxSize;
+        this.filePath = filePath;
+    }
+    add(entry) {
+        // Don't add duplicates of the last entry
+        if (this.history[this.history.length - 1] === entry)
+            return;
+        this.history.push(entry);
+        if (this.history.length > this.maxSize) {
+            this.history.shift();
+        }
+    }
+    getAll() {
+        return [...this.history];
+    }
+    search(query) {
+        const lower = query.toLowerCase();
+        return this.history.filter(h => h.toLowerCase().includes(lower));
+    }
+    async load() {
+        if (!this.filePath)
+            return;
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const content = await fs.readFile(this.filePath, 'utf-8');
+            this.history = content.trim().split('\n').filter(Boolean);
+        }
+        catch {
+            // File doesn't exist yet
+        }
+    }
+    async save() {
+        if (!this.filePath)
+            return;
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            await fs.writeFile(this.filePath, this.history.join('\n'));
+        }
+        catch {
+            // Ignore save errors
+        }
+    }
+    clear() {
+        this.history = [];
+    }
+}
+exports.HistoryManager = HistoryManager;
+/**
+ * Create a history manager
+ */
+function createHistoryManager(maxSize, filePath) {
+    return new HistoryManager(maxSize, filePath);
+}

package/dist/cli/features/n8n-integration.d.ts

@@ -0,0 +1,111 @@
+/**
+ * N8N Integration - Webhook triggers and workflow export for n8n
+ */
+export interface N8NConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    webhookPath?: string;
+}
+export interface N8NWebhookPayload {
+    event: string;
+    data: Record<string, any>;
+    timestamp: string;
+    source: string;
+}
+export interface N8NWorkflowNode {
+    id: string;
+    name: string;
+    type: string;
+    position: [number, number];
+    parameters: Record<string, any>;
+    credentials?: Record<string, any>;
+}
+export interface N8NWorkflowConnection {
+    node: string;
+    type: string;
+    index: number;
+}
+export interface N8NWorkflow {
+    name: string;
+    nodes: N8NWorkflowNode[];
+    connections: Record<string, {
+        main: N8NWorkflowConnection[][];
+    }>;
+    settings?: Record<string, any>;
+}
+/**
+ * N8N Integration class
+ *
+ * Enables integration with n8n workflows and webhooks.
+ * Allows OverAI agents to trigger n8n workflows and receive events.
+ */
+export declare class N8NIntegration {
+    private config;
+    constructor(config?: N8NConfig);
+    /**
+     * Trigger a webhook
+     */
+    triggerWebhook(webhookId: string, payload: Record<string, any>): Promise<{
+        success: boolean;
+        response?: any;
+        error?: string;
+    }>;
+    /**
+     * Create a webhook payload for agent events
+     */
+    createAgentEventPayload(event: string, agentId: string, data: Record<string, any>): N8NWebhookPayload;
+    /**
+     * Export PraisonAI workflow to n8n format
+     */
+    exportWorkflow(name: string, steps: Array<{
+        name: string;
+        type: 'agent' | 'tool' | 'condition';
+        config?: Record<string, any>;
+    }>): N8NWorkflow;
+    /**
+     * Map OverAI step type to n8n node type
+     */
+    private mapStepTypeToN8N;
+    /**
+     * Map step parameters to n8n format
+     */
+    private mapStepParameters;
+    /**
+     * Generate n8n workflow JSON string
+     */
+    exportWorkflowJSON(name: string, steps: Array<{
+        name: string;
+        type: 'agent' | 'tool' | 'condition';
+        config?: Record<string, any>;
+    }>): string;
+    /**
+     * Import n8n workflow and convert to PraisonAI format
+     */
+    importWorkflow(n8nWorkflow: N8NWorkflow): Array<{
+        name: string;
+        type: string;
+        config: Record<string, any>;
+    }>;
+    /**
+     * Map n8n node type to PraisonAI step type
+     */
+    private mapN8NTypeToStep;
+    /**
+     * Create a webhook listener (for local development)
+     */
+    createWebhookListener(port: number, handler: (payload: N8NWebhookPayload) => Promise<any>): Promise<{
+        close: () => void;
+    }>;
+}
+/**
+ * Create an n8n integration instance
+ */
+export declare function createN8NIntegration(config?: N8NConfig): N8NIntegration;
+/**
+ * Quick function to trigger an n8n webhook
+ */
+export declare function triggerN8NWebhook(webhookId: string, payload: Record<string, any>, config?: N8NConfig): Promise<{
+    success: boolean;
+    response?: any;
+    error?: string;
+}>;