overai 1.4.0

package/dist/cli/features/n8n-integration.js

@@ -0,0 +1,299 @@
+"use strict";
+/**
+ * N8N Integration - Webhook triggers and workflow export for n8n
+ */
+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.N8NIntegration = void 0;
+exports.createN8NIntegration = createN8NIntegration;
+exports.triggerN8NWebhook = triggerN8NWebhook;
+/**
+ * N8N Integration class
+ *
+ * Enables integration with n8n workflows and webhooks.
+ * Allows OverAI agents to trigger n8n workflows and receive events.
+ */
+class N8NIntegration {
+    constructor(config = {}) {
+        this.config = {
+            baseUrl: config.baseUrl || process.env.N8N_BASE_URL || 'http://localhost:5678',
+            apiKey: config.apiKey || process.env.N8N_API_KEY,
+            webhookPath: config.webhookPath || '/webhook',
+            ...config
+        };
+    }
+    /**
+     * Trigger a webhook
+     */
+    async triggerWebhook(webhookId, payload) {
+        const url = `${this.config.baseUrl}${this.config.webhookPath}/${webhookId}`;
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(this.config.apiKey ? { 'X-N8N-API-KEY': this.config.apiKey } : {})
+                },
+                body: JSON.stringify(payload)
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                return { success: false, error: `HTTP ${response.status}: ${error}` };
+            }
+            const data = await response.json().catch(() => ({}));
+            return { success: true, response: data };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Create a webhook payload for agent events
+     */
+    createAgentEventPayload(event, agentId, data) {
+        return {
+            event,
+            data: {
+                agentId,
+                ...data
+            },
+            timestamp: new Date().toISOString(),
+            source: 'praisonai'
+        };
+    }
+    /**
+     * Export PraisonAI workflow to n8n format
+     */
+    exportWorkflow(name, steps) {
+        const nodes = [];
+        const connections = {};
+        // Add trigger node
+        nodes.push({
+            id: 'trigger',
+            name: 'Webhook Trigger',
+            type: 'n8n-nodes-base.webhook',
+            position: [250, 300],
+            parameters: {
+                httpMethod: 'POST',
+                path: name.toLowerCase().replace(/\s+/g, '-'),
+                responseMode: 'onReceived'
+            }
+        });
+        let prevNodeId = 'trigger';
+        let yPosition = 300;
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            const nodeId = `node_${i}`;
+            yPosition += 150;
+            // Map step type to n8n node type
+            const nodeType = this.mapStepTypeToN8N(step.type);
+            nodes.push({
+                id: nodeId,
+                name: step.name,
+                type: nodeType,
+                position: [250, yPosition],
+                parameters: this.mapStepParameters(step)
+            });
+            // Add connection from previous node
+            if (!connections[prevNodeId]) {
+                connections[prevNodeId] = { main: [[]] };
+            }
+            connections[prevNodeId].main[0].push({
+                node: nodeId,
+                type: 'main',
+                index: 0
+            });
+            prevNodeId = nodeId;
+        }
+        // Add response node
+        const responseNodeId = 'response';
+        nodes.push({
+            id: responseNodeId,
+            name: 'Response',
+            type: 'n8n-nodes-base.respondToWebhook',
+            position: [250, yPosition + 150],
+            parameters: {
+                respondWith: 'json',
+                responseBody: '={{ $json }}'
+            }
+        });
+        connections[prevNodeId] = {
+            main: [[{ node: responseNodeId, type: 'main', index: 0 }]]
+        };
+        return {
+            name,
+            nodes,
+            connections,
+            settings: {
+                executionOrder: 'v1'
+            }
+        };
+    }
+    /**
+     * Map OverAI step type to n8n node type
+     */
+    mapStepTypeToN8N(type) {
+        const mapping = {
+            agent: 'n8n-nodes-base.httpRequest',
+            tool: 'n8n-nodes-base.function',
+            condition: 'n8n-nodes-base.if'
+        };
+        return mapping[type] || 'n8n-nodes-base.noOp';
+    }
+    /**
+     * Map step parameters to n8n format
+     */
+    mapStepParameters(step) {
+        switch (step.type) {
+            case 'agent':
+                return {
+                    method: 'POST',
+                    url: '={{ $env.PRAISONAI_API_URL }}/agent/execute',
+                    sendBody: true,
+                    bodyParameters: {
+                        parameters: [
+                            { name: 'input', value: '={{ $json.input }}' }
+                        ]
+                    },
+                    ...step.config
+                };
+            case 'tool':
+                return {
+                    functionCode: `
+// Tool execution
+const input = $input.all();
+// Add your tool logic here
+return input;
+          `.trim(),
+                    ...step.config
+                };
+            case 'condition':
+                return {
+                    conditions: {
+                        boolean: [
+                            {
+                                value1: '={{ $json.success }}',
+                                value2: true
+                            }
+                        ]
+                    },
+                    ...step.config
+                };
+            default:
+                return step.config || {};
+        }
+    }
+    /**
+     * Generate n8n workflow JSON string
+     */
+    exportWorkflowJSON(name, steps) {
+        const workflow = this.exportWorkflow(name, steps);
+        return JSON.stringify(workflow, null, 2);
+    }
+    /**
+     * Import n8n workflow and convert to PraisonAI format
+     */
+    importWorkflow(n8nWorkflow) {
+        const steps = [];
+        // Skip trigger and response nodes
+        const workflowNodes = n8nWorkflow.nodes.filter(n => !n.type.includes('webhook') && !n.type.includes('respondToWebhook'));
+        for (const node of workflowNodes) {
+            steps.push({
+                name: node.name,
+                type: this.mapN8NTypeToStep(node.type),
+                config: node.parameters
+            });
+        }
+        return steps;
+    }
+    /**
+     * Map n8n node type to PraisonAI step type
+     */
+    mapN8NTypeToStep(n8nType) {
+        if (n8nType.includes('httpRequest'))
+            return 'agent';
+        if (n8nType.includes('function') || n8nType.includes('code'))
+            return 'tool';
+        if (n8nType.includes('if') || n8nType.includes('switch'))
+            return 'condition';
+        return 'tool';
+    }
+    /**
+     * Create a webhook listener (for local development)
+     */
+    async createWebhookListener(port, handler) {
+        const http = await Promise.resolve().then(() => __importStar(require('http')));
+        const server = http.createServer(async (req, res) => {
+            if (req.method !== 'POST') {
+                res.writeHead(405);
+                res.end('Method not allowed');
+                return;
+            }
+            let body = '';
+            req.on('data', chunk => { body += chunk; });
+            req.on('end', async () => {
+                try {
+                    const payload = JSON.parse(body);
+                    const result = await handler(payload);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(result));
+                }
+                catch (error) {
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: error.message }));
+                }
+            });
+        });
+        server.listen(port);
+        console.log(`N8N webhook listener started on port ${port}`);
+        return {
+            close: () => server.close()
+        };
+    }
+}
+exports.N8NIntegration = N8NIntegration;
+/**
+ * Create an n8n integration instance
+ */
+function createN8NIntegration(config) {
+    return new N8NIntegration(config);
+}
+/**
+ * Quick function to trigger an n8n webhook
+ */
+async function triggerN8NWebhook(webhookId, payload, config) {
+    const integration = createN8NIntegration(config);
+    return integration.triggerWebhook(webhookId, payload);
+}

package/dist/cli/features/repo-map.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Repo Map - Repository structure visualization and symbol extraction
+ */
+export interface RepoMapConfig {
+    rootPath: string;
+    maxDepth?: number;
+    ignorePatterns?: string[];
+    includeSymbols?: boolean;
+    maxFiles?: number;
+}
+export interface FileInfo {
+    path: string;
+    relativePath: string;
+    size: number;
+    isDirectory: boolean;
+    children?: FileInfo[];
+    symbols?: SymbolInfo[];
+}
+export interface SymbolInfo {
+    name: string;
+    type: 'function' | 'class' | 'method' | 'variable' | 'interface' | 'type' | 'export';
+    line: number;
+    exported?: boolean;
+}
+export interface RepoMapResult {
+    root: string;
+    tree: FileInfo;
+    totalFiles: number;
+    totalDirectories: number;
+    symbols: SymbolInfo[];
+    summary: string;
+}
+/**
+ * Default ignore patterns
+ */
+export declare const DEFAULT_IGNORE_PATTERNS: string[];
+/**
+ * RepoMap class for repository analysis
+ */
+export declare class RepoMap {
+    private config;
+    private fs;
+    private path;
+    constructor(config: RepoMapConfig);
+    /**
+     * Generate repository map
+     */
+    generate(): Promise<RepoMapResult>;
+    /**
+     * Scan a directory recursively
+     */
+    private scanDirectory;
+    /**
+     * Check if path should be ignored
+     */
+    private shouldIgnore;
+    /**
+     * Check if file is a code file
+     */
+    private isCodeFile;
+    /**
+     * Extract symbols from a file
+     */
+    private extractSymbols;
+    /**
+     * Extract symbols from JavaScript/TypeScript
+     */
+    private extractJSSymbols;
+    /**
+     * Extract symbols from Python
+     */
+    private extractPythonSymbols;
+    /**
+     * Count files and directories
+     */
+    private countItems;
+    /**
+     * Collect all symbols from tree
+     */
+    private collectSymbols;
+    /**
+     * Generate text summary
+     */
+    private generateSummary;
+    /**
+     * Render tree as text
+     */
+    private renderTree;
+    /**
+     * Get tree as simple text format
+     */
+    getTreeText(): Promise<string>;
+}
+/**
+ * Create a repo map instance
+ */
+export declare function createRepoMap(config: RepoMapConfig): RepoMap;
+/**
+ * Quick function to get repo tree
+ */
+export declare function getRepoTree(rootPath: string, maxDepth?: number): Promise<string>;