@lhi/n8m 0.1.2 → 0.2.0

package/dist/services/doc.service.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Service for generating workflow documentation and diagrams.
+ */
+export declare class DocService {
+    private static instance;
+    private aiService;
+    private constructor();
+    static getInstance(): DocService;
+    /**
+     * Generates a Mermaid.js flowchart diagram from an n8n workflow JSON.
+     */
+    generateMermaid(workflowJson: any): string;
+    /**
+     * Generates an AI-driven README/Summary for the workflow.
+     */
+    generateReadme(workflowJson: any): Promise<string>;
+    /**
+     * Generates a folder-safe slug from a name.
+     */
+    generateSlug(name: string): string;
+    /**
+     * Uses AI to suggest a concise, professional project title for the workflow.
+     */
+    generateProjectTitle(workflowJson: any): Promise<string>;
+    private toID;
+}

package/dist/services/doc.service.js

@@ -0,0 +1,92 @@
+import { AIService } from "./ai.service.js";
+/**
+ * Service for generating workflow documentation and diagrams.
+ */
+export class DocService {
+    static instance;
+    aiService;
+    constructor() {
+        this.aiService = AIService.getInstance();
+    }
+    static getInstance() {
+        if (!DocService.instance) {
+            DocService.instance = new DocService();
+        }
+        return DocService.instance;
+    }
+    /**
+     * Generates a Mermaid.js flowchart diagram from an n8n workflow JSON.
+     */
+    generateMermaid(workflowJson) {
+        const nodes = workflowJson.nodes || [];
+        const connections = workflowJson.connections || {};
+        let mermaid = "graph TD\n";
+        // 1. Define Nodes
+        nodes.forEach((node) => {
+            // Escape node names for Mermaid
+            const safeName = node.name.replace(/"/g, "'");
+            // Use different shapes/styles based on node type if desired
+            // Simple box for now: nodeName["Display Text"]
+            mermaid += `  ${this.toID(node.name)}["${safeName}"]\n`;
+        });
+        // 2. Define Connections
+        for (const [sourceName, sourceConns] of Object.entries(connections)) {
+            if (sourceConns && sourceConns.main) {
+                sourceConns.main.forEach((targets) => {
+                    targets.forEach((target) => {
+                        mermaid += `  ${this.toID(sourceName)} --> ${this.toID(target.node)}\n`;
+                    });
+                });
+            }
+        }
+        return mermaid;
+    }
+    /**
+     * Generates an AI-driven README/Summary for the workflow.
+     */
+    async generateReadme(workflowJson) {
+        const prompt = `You are a technical writer for n8n.
+    Generate a concise, professional README for the following n8n workflow.
+    
+    Workflow JSON:
+    ${JSON.stringify(workflowJson, null, 2)}
+    
+    The README should include:
+    1. A clear Title.
+    2. A brief 1-2 sentence Summary of what the workflow does.
+    3. A "Nodes Used" section listing the key nodes.
+    4. An "Execution Flow" section explaining the logic.
+    
+    Output in Markdown format.
+    `;
+        return await this.aiService.generateContent(prompt) || "Failed to generate documentation.";
+    }
+    /**
+     * Generates a folder-safe slug from a name.
+     */
+    generateSlug(name) {
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    /**
+     * Uses AI to suggest a concise, professional project title for the workflow.
+     */
+    async generateProjectTitle(workflowJson) {
+        const prompt = `Based on the following n8n workflow JSON, suggest a concise, professional project title (3-5 words).
+    
+    Workflow JSON Snippet:
+    ${JSON.stringify({
+            name: workflowJson.name,
+            nodes: (workflowJson.nodes || []).map((n) => ({ name: n.name, type: n.type }))
+        }, null, 2)}
+    
+    Output ONLY the title string. No quotes. No commentary.`;
+        const title = await this.aiService.generateContent(prompt);
+        return title?.trim() || workflowJson.name || 'Untitled Workflow';
+    }
+    toID(name) {
+        return name.replace(/[^a-zA-Z0-9]/g, "_");
+    }
+}

package/dist/services/mcp.service.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP Service for exposing n8m agentic capabilities as tools.
+ */
+export declare class MCPService {
+    private server;
+    constructor();
+    private setupTools;
+    start(): Promise<void>;
+}

package/dist/services/mcp.service.js

@@ -0,0 +1,110 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { runAgenticWorkflow } from "../agentic/graph.js";
+import { theme } from "../utils/theme.js";
+/**
+ * MCP Service for exposing n8m agentic capabilities as tools.
+ */
+export class MCPService {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: "n8m-agent",
+            version: "0.1.0",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupTools();
+    }
+    setupTools() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "create_workflow",
+                        description: "Generate an n8n workflow from a natural language description.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                goal: {
+                                    type: "string",
+                                    description: "Natural language description of the workflow goals",
+                                },
+                            },
+                            required: ["goal"],
+                        },
+                    },
+                    {
+                        name: "test_workflow",
+                        description: "Validate and repair a workflow JSON by deploying it ephemerally to n8n.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                workflowJson: {
+                                    type: "object",
+                                    description: "The workflow JSON to test",
+                                },
+                                goal: {
+                                    type: "string",
+                                    description: "The original goal or context for testing",
+                                },
+                            },
+                            required: ["workflowJson", "goal"],
+                        },
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                if (name === "create_workflow") {
+                    const goal = String(args.goal);
+                    // Run agentic workflow without interactive approval for MCP
+                    const result = await runAgenticWorkflow(goal);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(result.workflowJson || result, null, 2),
+                            },
+                        ],
+                    };
+                }
+                else if (name === "test_workflow") {
+                    const workflowJson = args.workflowJson;
+                    const goal = String(args.goal);
+                    const result = await runAgenticWorkflow(goal, { workflowJson });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(result, null, 2),
+                            },
+                        ],
+                    };
+                }
+                throw new Error(`Tool not found: ${name}`);
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: ${error.message}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        });
+    }
+    async start() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error(theme.done("n8m MCP Server started (stdio transport)"));
+    }
+}

package/dist/services/node-definitions.service.d.ts

@@ -15,6 +15,11 @@ export declare class NodeDefinitionsService {
      * In a real app, we might cache this to a file.
      */
     loadDefinitions(): Promise<void>;
+    private loadFallback;
+    /**
+     * Get the human-readable static reference document
+     */
+    getStaticReference(): string;
     /**
      * Search for nodes relevant to the query.
      * Simple keyword matching for now.

package/dist/services/node-definitions.service.js

@@ -1,13 +1,17 @@
 import { N8nClient } from '../utils/n8nClient.js';
 import { ConfigManager } from '../utils/config.js';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 export class NodeDefinitionsService {
     static instance;
     definitions = [];
     client;
     constructor() {
-        const n8nUrl = process.env.N8N_API_URL;
-        const n8nKey = process.env.N8N_API_KEY;
-        this.client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
+        // Will be overridden in loadDefinitions() once config is available
+        this.client = new N8nClient();
     }
     static getInstance() {
         if (!NodeDefinitionsService.instance) {
@@ -26,18 +30,70 @@ export class NodeDefinitionsService {
         try {
             // Re-initialize client if env vars changed (e.g. after config load)
             const config = await ConfigManager.load();
-            if (config.n8nUrl && config.n8nKey) {
-                this.client = new N8nClient({ apiUrl: config.n8nUrl, apiKey: config.n8nKey });
+            // Env vars take priority over stored config
+            const apiUrl = process.env.N8N_API_URL || config.n8nUrl;
+            const apiKey = process.env.N8N_API_KEY || config.n8nKey;
+            if (apiUrl && apiKey) {
+                this.client = new N8nClient({ apiUrl, apiKey });
             }
             this.definitions = await this.client.getNodeTypes();
-            console.log(`Loaded ${this.definitions.length} node definitions.`);
+            if (this.definitions.length === 0) {
+                console.warn("No node definitions returned from n8n instance. Attempting fallback...");
+                this.loadFallback();
+            }
+            else {
+                console.log(`Loaded ${this.definitions.length} node definitions.`);
+            }
+        }
+        catch {
+            console.error("Failed to load node definitions from n8n instance (fetch failed).");
+            this.loadFallback();
+        }
+    }
+    loadFallback() {
+        try {
+            // Check multiple potential locations (dist vs src)
+            const paths = [
+                path.join(__dirname, '..', 'resources', 'node-definitions-fallback.json'), // dist
+                path.join(__dirname, '..', '..', 'src', 'resources', 'node-definitions-fallback.json') // src (dev)
+            ];
+            let fallbackPath = '';
+            for (const p of paths) {
+                if (fs.existsSync(p)) {
+                    fallbackPath = p;
+                    break;
+                }
+            }
+            if (fallbackPath) {
+                const fallbackData = fs.readFileSync(fallbackPath, 'utf8');
+                this.definitions = JSON.parse(fallbackData);
+                console.log(`Loaded ${this.definitions.length} node definitions (from fallback at ${path.basename(path.dirname(fallbackPath))}).`);
+            }
+            else {
+                console.warn("Fallback node definitions file not found in searched locations.");
+                this.definitions = [];
+            }
         }
-        catch (error) {
-            console.error("Failed to load node definitions:", error);
-            // Fallback to empty to allow process to continue without RAG
+        catch (fallbackError) {
+            console.error("Failed to load fallback node definitions:", fallbackError);
             this.definitions = [];
         }
     }
+    /**
+     * Get the human-readable static reference document
+     */
+    getStaticReference() {
+        try {
+            const docPath = path.join(__dirname, '..', '..', 'docs', 'N8N_NODE_REFERENCE.md');
+            if (fs.existsSync(docPath)) {
+                return fs.readFileSync(docPath, 'utf8');
+            }
+        }
+        catch (e) {
+            console.error("Failed to read N8N_NODE_REFERENCE.md", e);
+        }
+        return "";
+    }
     /**
      * Search for nodes relevant to the query.
      * Simple keyword matching for now.

package/dist/utils/n8nClient.d.ts

@@ -25,6 +25,10 @@ export declare class N8nClient {
     private apiKey;
     private headers;
     constructor(config?: N8nClientConfig);
+    /**
+     * Assert that an API response is OK, throwing an actionable error for 401/403.
+     */
+    private assertOk;
     /**
      * Activate a workflow
      */
@@ -53,6 +57,10 @@ export declare class N8nClient {
      * Get workflow by ID
      */
     getWorkflow(workflowId: string): Promise<unknown>;
+    /**
+     * Strip invalid timezone from workflow settings so n8n activation never 400s.
+     */
+    private sanitizeSettings;
     /**
      * Create a new workflow
      */
@@ -60,16 +68,8 @@ export declare class N8nClient {
         id: string;
     }>;
     /**
-     * Get all installed node types via Probe Workflow (Webhook)
-     *
-     * Strategy:
-     * 1. Create a workflow with Webhook -> HTTP Request (Internal API)
-     * 2. Activate it
-     * 3. Call the webhook -> Returns the node types
-     */
-    /**
-     * Get all installed node types via Probe Workflow (Webhook)
-     * Returns full node type objects including parameters, not just names.
+     * Get all installed node types directly from the n8n REST API.
+     * Handles paginated responses and returns the full node type objects.
      */
     getNodeTypes(): Promise<any[]>;
     /**