@lhi/n8m 0.1.2 → 0.2.0

package/dist/commands/doc.js

@@ -0,0 +1,136 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { theme } from '../utils/theme.js';
+import { N8nClient } from '../utils/n8nClient.js';
+import { ConfigManager } from '../utils/config.js';
+import { DocService } from '../services/doc.service.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { existsSync } from 'fs';
+import inquirer from 'inquirer';
+export default class Doc extends Command {
+    static args = {
+        workflow: Args.string({
+            description: 'Path or Name of the workflow to document',
+            required: false,
+        }),
+    };
+    static description = 'Generate visual and text documentation for n8n workflows';
+    static flags = {
+        output: Flags.string({
+            char: 'o',
+            description: 'Output directory for documentation (defaults to ./docs)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Doc);
+        this.log(theme.brand());
+        this.log(theme.header('WORKFLOW DOCUMENTATION'));
+        // 1. Load Credentials & Client
+        const config = await ConfigManager.load();
+        const n8nUrl = config.n8nUrl || process.env.N8N_API_URL;
+        const n8nKey = config.n8nKey || process.env.N8N_API_KEY;
+        if (!n8nUrl || !n8nKey) {
+            this.error('Credentials missing. Configure environment via \'n8m config\'.');
+        }
+        const client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
+        const docService = DocService.getInstance();
+        // 2. Resolve Workflow
+        let workflowData;
+        let workflowName = 'Untitled';
+        let localPath = null;
+        if (args.workflow && existsSync(args.workflow)) {
+            const content = await fs.readFile(args.workflow, 'utf-8');
+            workflowData = JSON.parse(content);
+            workflowName = workflowData.name || path.basename(args.workflow, '.json');
+            localPath = path.resolve(args.workflow);
+        }
+        else {
+            this.log(theme.info('Searching for local and remote workflows...'));
+            const localChoices = [];
+            const workflowsDir = path.join(process.cwd(), 'workflows');
+            if (existsSync(workflowsDir)) {
+                // Scan for loose files AND directory-based workflows
+                const entries = await fs.readdir(workflowsDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isFile() && entry.name.endsWith('.json')) {
+                        localChoices.push({
+                            name: `${theme.value('[LOCAL]')} ${entry.name}`,
+                            value: { type: 'local', path: path.join(workflowsDir, entry.name) }
+                        });
+                    }
+                    else if (entry.isDirectory()) {
+                        const subPath = path.join(workflowsDir, entry.name, 'workflow.json');
+                        if (existsSync(subPath)) {
+                            localChoices.push({
+                                name: `${theme.value('[LOCAL]')} ${entry.name}/workflow.json`,
+                                value: { type: 'local', path: subPath }
+                            });
+                        }
+                    }
+                }
+            }
+            const remoteWorkflows = await client.getWorkflows();
+            const remoteChoices = remoteWorkflows
+                .map(w => ({
+                name: `${theme.info('[n8n]')} ${w.name} (${w.id}) ${w.active ? '[Active]' : ''}`,
+                value: { type: 'remote', id: w.id, data: w }
+            }));
+            const choices = [
+                ...(localChoices.length > 0 ? [new inquirer.Separator('--- Local Files ---'), ...localChoices] : []),
+                ...(remoteChoices.length > 0 ? [new inquirer.Separator('--- n8n Instance ---'), ...remoteChoices] : []),
+            ];
+            if (choices.length === 0)
+                this.error('No workflows found sequence.');
+            const { selection } = await inquirer.prompt([{
+                    type: 'select',
+                    name: 'selection',
+                    message: 'Select a workflow to document:',
+                    choices,
+                    pageSize: 15
+                }]);
+            if (selection.type === 'local') {
+                const content = await fs.readFile(selection.path, 'utf-8');
+                workflowData = JSON.parse(content);
+                workflowName = workflowData.name || path.basename(selection.path, '.json');
+                localPath = selection.path;
+            }
+            else {
+                workflowData = await client.getWorkflow(selection.id);
+                workflowName = workflowData.name || 'Remote Workflow';
+            }
+        }
+        // 3. Prepare Folder Structure
+        const slug = docService.generateSlug(workflowName);
+        const workflowsDir = path.join(process.cwd(), 'workflows');
+        const targetDir = path.join(workflowsDir, slug);
+        const targetJsonPath = path.join(targetDir, 'workflow.json');
+        const targetReadmePath = path.join(targetDir, 'README.md');
+        await fs.mkdir(targetDir, { recursive: true });
+        // Move or Save JSON
+        if (localPath) {
+            if (path.resolve(localPath) !== path.resolve(targetJsonPath)) {
+                this.log(theme.info(`Moving workflow to: ${theme.value(targetJsonPath)}`));
+                await fs.writeFile(targetJsonPath, JSON.stringify(workflowData, null, 2));
+                // Only delete if it's a loose file in workflows/ or provided path
+                if (path.resolve(localPath) !== path.resolve(targetJsonPath)) {
+                    await fs.unlink(localPath);
+                }
+            }
+        }
+        else {
+            this.log(theme.info(`Saving remote workflow to: ${theme.value(targetJsonPath)}`));
+            await fs.writeFile(targetJsonPath, JSON.stringify(workflowData, null, 2));
+        }
+        // 4. Generate & Save Documentation
+        this.log(theme.agent(`Generating diagrams and summary for: "${workflowName}"...`));
+        const mermaid = docService.generateMermaid(workflowData);
+        const readme = await docService.generateReadme(workflowData);
+        const fullDoc = `# ${workflowName}\n\n## Visual Flow\n\n\`\`\`mermaid\n${mermaid}\`\`\`\n\n${readme}`;
+        await fs.writeFile(targetReadmePath, fullDoc);
+        this.log(theme.success(`✔ Documentation Generated & Organized.`));
+        this.log(`${theme.label('Folder')} ${theme.value(targetDir)}`);
+        this.log(theme.divider());
+        this.log(theme.subHeader('Mermaid Diagram Preview:'));
+        this.log(theme.muted(mermaid));
+    }
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class MCP extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/mcp.js

@@ -0,0 +1,25 @@
+import { Command } from '@oclif/core';
+import { theme } from '../utils/theme.js';
+import { MCPService } from '../services/mcp.service.js';
+export default class MCP extends Command {
+    static description = 'Launch the n8m MCP (Model Context Protocol) server';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        this.log(theme.brand());
+        this.log(theme.info('Starting n8m MCP Server...'));
+        try {
+            const mcpService = new MCPService();
+            await mcpService.start();
+            // Wait for interrupt (Process will stay alive due to stdio transport)
+            process.on('SIGINT', () => {
+                this.log(theme.info('\nStopping MCP Server...'));
+                process.exit(0);
+            });
+        }
+        catch (error) {
+            this.error(`Failed to start MCP Server: ${error.message}`);
+        }
+    }
+}

package/dist/commands/modify.js

@@ -20,7 +20,7 @@ export default class Modify extends Command {
             required: false,
         }),
     };
-    static description = 'Modify existing n8n workflows using Gemini AI Agent';
+    static description = 'Modify existing n8n workflows using an AI Agent';
     static flags = {
         multiline: Flags.boolean({
             char: 'm',

package/dist/commands/resume.js

@@ -21,8 +21,47 @@ export default class Resume extends Command {
             return;
         }
         this.log(theme.info(`Workflow is paused at: ${next.join(', ')}`));
-        this.log(theme.agent("Resuming..."));
         try {
+            if (next.includes('engineer')) {
+                const state = snapshot.values;
+                if (state.strategies && state.strategies.length > 0) {
+                    this.log(theme.header('\nPAUSED STRATEGIES:'));
+                    state.strategies.forEach((s, i) => {
+                        this.log(`${i === 0 ? theme.success('  [Primary]') : theme.info('  [Alternative]')} ${theme.value(s.suggestedName)}`);
+                        this.log(`  Description: ${s.description}`);
+                        if (s.nodes && s.nodes.length > 0) {
+                            this.log(`  Proposed Nodes: ${s.nodes.map((n) => n.type.split('.').pop()).join(', ')}`);
+                        }
+                        this.log('');
+                    });
+                    const { action } = await (await import('inquirer')).default.prompt([{
+                            type: 'list',
+                            name: 'action',
+                            message: 'How would you like to proceed?',
+                            choices: [
+                                { name: 'Approve and Generate Workflow', value: 'approve' },
+                                { name: 'Provide Feedback / Refine Strategy', value: 'feedback' },
+                                { name: 'Exit', value: 'exit' }
+                            ]
+                        }]);
+                    if (action === 'approve') {
+                        this.log(theme.agent("Approve! Resuming..."));
+                        await graph.updateState({ configurable: { thread_id: threadId } }, { userFeedback: undefined }, 'engineer');
+                    }
+                    else if (action === 'feedback') {
+                        const { feedback } = await (await import('inquirer')).default.prompt([{
+                                type: 'input',
+                                name: 'feedback',
+                                message: 'Enter your feedback/instructions:',
+                            }]);
+                        await graph.updateState({ configurable: { thread_id: threadId } }, { userFeedback: feedback }, 'engineer');
+                    }
+                    else {
+                        return;
+                    }
+                }
+            }
+            this.log(theme.agent("Resuming..."));
             const result = await resumeAgenticWorkflow(threadId);
             if (result.validationStatus === 'passed') {
                 this.log(theme.success("Workflow completed successfully!"));

package/dist/commands/test.d.ts

@@ -9,6 +9,7 @@ export default class Test extends Command {
         'keep-on-fail': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'no-brand': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'validate-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'ai-scenarios': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     /**

package/dist/commands/test.js

@@ -3,6 +3,8 @@ import { Args, Command, Flags } from '@oclif/core';
 import { theme } from '../utils/theme.js';
 import { N8nClient } from '../utils/n8nClient.js';
 import { ConfigManager } from '../utils/config.js';
+import { AIService } from '../services/ai.service.js';
+import { DocService } from '../services/doc.service.js';
 import { runAgenticWorkflow, graph, resumeAgenticWorkflow } from '../agentic/graph.js';
 import * as path from 'path';
 import * as fs from 'fs/promises';
@@ -35,6 +37,10 @@ export default class Test extends Command {
             hidden: true,
             description: 'Execute test but do not prompt for deploy/save actions',
         }),
+        'ai-scenarios': Flags.boolean({
+            default: false,
+            description: 'Generate 3 diverse AI test scenarios (happy path, edge case, error)',
+        }),
     };
     async run() {
         const { args, flags } = await this.parse(Test);
@@ -50,6 +56,7 @@ export default class Test extends Command {
             this.error('Credentials missing. Configure environment via \'n8m config\'.');
         }
         const client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
+        const aiService = AIService.getInstance();
         // 1a. Fetch Valid Node Types (New)
         let validNodeTypes = [];
         try {
@@ -354,12 +361,19 @@ export default class Test extends Command {
             this.log(theme.subHeader('AGENTIC VALIDATION'));
             this.log(theme.agent("Initializing Agentic Workflow to validate/repair this workflow..."));
             const goal = `Validate and fix the workflow named "${workflowName}"`;
+            let testScenarios = [];
+            if (flags['ai-scenarios']) {
+                this.log(theme.agent("Generating AI test scenarios..."));
+                testScenarios = await aiService.generateTestScenarios(workflowData, goal);
+                this.log(theme.muted(`Generated ${testScenarios.length} scenarios.`));
+            }
             const initialState = {
                 userGoal: goal,
                 messages: [],
                 validationErrors: [],
                 workflowJson: workflowData,
-                availableNodeTypes: validNodeTypes
+                availableNodeTypes: validNodeTypes,
+                testScenarios: testScenarios
             };
             // We need to route the graph logger to our CLI logger if possible, or just let it print to stdout
             // The graph uses console.log currently, which is fine.
@@ -540,20 +554,38 @@ export default class Test extends Command {
             }]);
         if (!save)
             return;
+        const docService = DocService.getInstance();
         for (const [, def] of deployedDefinitions.entries()) {
             const cleanData = this.sanitizeWorkflow(this.stripShim(def.data));
-            cleanData.name = def.name;
-            const targetPath = originalPath && def.type === 'root' ? originalPath : path.join(process.cwd(), 'workflows', `${def.name.replace(/[^a-z0-9]/gi, '_').toLowerCase()}.json`);
+            // Use AI to suggest title if it looks like a temporary name
+            let workflowName = def.name;
+            if (workflowName.startsWith('[n8m:test]') || workflowName.includes('Agentic_Test')) {
+                this.log(theme.agent("Suggesting professional project title..."));
+                workflowName = await docService.generateProjectTitle(cleanData);
+            }
+            cleanData.name = workflowName;
+            const slug = docService.generateSlug(workflowName);
+            const targetDir = path.join(process.cwd(), 'workflows', slug);
+            const targetPath = path.join(targetDir, 'workflow.json');
             const { confirmPath } = await inquirer.prompt([{
                     type: 'input',
                     name: 'confirmPath',
-                    message: `Save '${def.name}' to:`,
+                    message: `Save '${workflowName}' to:`,
                     default: targetPath
                 }]);
             try {
                 await fs.mkdir(path.dirname(confirmPath), { recursive: true });
                 await fs.writeFile(confirmPath, JSON.stringify(cleanData, null, 2));
                 this.log(theme.success(`Saved to ${confirmPath}`));
+                // Optionally generate doc if it's a new directory
+                const readmePath = path.join(path.dirname(confirmPath), 'README.md');
+                if (!existsSync(readmePath)) {
+                    this.log(theme.agent("Generating initial documentation..."));
+                    const mermaid = docService.generateMermaid(cleanData);
+                    const readmeContent = await docService.generateReadme(cleanData);
+                    const fullDoc = `# ${workflowName}\n\n## Visual Flow\n\n\`\`\`mermaid\n${mermaid}\`\`\`\n\n${readmeContent}`;
+                    await fs.writeFile(readmePath, fullDoc);
+                }
             }
             catch (e) {
                 this.log(theme.fail(`Failed to save: ${e.message}`));

package/dist/resources/node-definitions-fallback.json

@@ -0,0 +1,213 @@
+[
+  {
+    "name": "n8n-nodes-base.start",
+    "displayName": "Manual Trigger",
+    "description": "The starting point for manual execution.",
+    "properties": []
+  },
+  {
+    "name": "n8n-nodes-base.httpRequest",
+    "displayName": "HTTP Request",
+    "description": "Send HTTP requests to any API",
+    "properties": [
+      {
+        "name": "method",
+        "displayName": "Method",
+        "type": "options",
+        "default": "GET",
+        "options": [
+          { "name": "GET", "value": "GET" },
+          { "name": "POST", "value": "POST" },
+          { "name": "PUT", "value": "PUT" },
+          { "name": "DELETE", "value": "DELETE" }
+        ]
+      },
+      {
+        "name": "url",
+        "displayName": "URL",
+        "type": "string",
+        "default": "",
+        "description": "The URL to send the request to"
+      },
+      {
+        "name": "authentication",
+        "displayName": "Authentication",
+        "type": "options",
+        "default": "none",
+        "options": [
+          { "name": "None", "value": "none" },
+          { "name": "Predefined Credential Type", "value": "predefinedCredentialType" }
+        ]
+      },
+      {
+        "name": "sendBody",
+        "displayName": "Send Body",
+        "type": "boolean",
+        "default": false
+      },
+      {
+        "name": "body",
+        "displayName": "Body",
+        "type": "json",
+        "default": ""
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.slack",
+    "displayName": "Slack",
+    "description": "Interact with Slack",
+    "properties": [
+      {
+        "name": "resource",
+        "displayName": "Resource",
+        "type": "options",
+        "default": "message",
+        "options": [
+          { "name": "Message", "value": "message" },
+          { "name": "Channel", "value": "channel" }
+        ]
+      },
+      {
+        "name": "operation",
+        "displayName": "Operation",
+        "type": "options",
+        "default": "post",
+        "options": [
+          { "name": "Post", "value": "post" },
+          { "name": "Update", "value": "update" }
+        ]
+      },
+      {
+        "name": "channel",
+        "displayName": "Channel",
+        "type": "string",
+        "default": ""
+      },
+      {
+        "name": "text",
+        "displayName": "Text",
+        "type": "string",
+        "default": ""
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.googleSheets",
+    "displayName": "Google Sheets",
+    "description": "Interact with Google Sheets",
+    "properties": [
+      {
+        "name": "resource",
+        "displayName": "Resource",
+        "type": "options",
+        "default": "sheet",
+        "options": [
+          { "name": "Sheet", "value": "sheet" }
+        ]
+      },
+      {
+        "name": "operation",
+        "displayName": "Operation",
+        "type": "options",
+        "default": "append",
+        "options": [
+          { "name": "Append", "value": "append" },
+          { "name": "Read", "value": "read" },
+          { "name": "Update", "value": "update" }
+        ]
+      },
+      {
+        "name": "sheetId",
+        "displayName": "Sheet ID",
+        "type": "string",
+        "default": ""
+      },
+      {
+        "name": "range",
+        "displayName": "Range",
+        "type": "string",
+        "default": "Sheet1!A:Z"
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.if",
+    "displayName": "IF",
+    "description": "Conditional logic: True/False",
+    "properties": [
+      {
+        "name": "conditions",
+        "displayName": "Conditions",
+        "type": "json",
+        "default": {}
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.set",
+    "displayName": "Set",
+    "description": "Set variables or values",
+    "properties": [
+      {
+        "name": "values",
+        "displayName": "Values",
+        "type": "fixedCollection",
+        "default": {}
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.webhook",
+    "displayName": "Webhook",
+    "description": "Receive HTTP requests",
+    "properties": [
+      {
+        "name": "httpMethod",
+        "displayName": "HTTP Method",
+        "type": "options",
+        "default": "GET",
+        "options": [
+          { "name": "GET", "value": "GET" },
+          { "name": "POST", "value": "POST" }
+        ]
+      },
+      {
+        "name": "path",
+        "displayName": "Path",
+        "type": "string",
+        "default": ""
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.code",
+    "displayName": "Code",
+    "description": "Run JavaScript/TypeScript",
+    "properties": [
+      {
+        "name": "jsCode",
+        "displayName": "JS Code",
+        "type": "string",
+        "default": "// Your code here\nreturn items;"
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.merge",
+    "displayName": "Merge",
+    "description": "Merge data from multiple inputs",
+    "properties": [
+      {
+        "name": "mode",
+        "displayName": "Mode",
+        "type": "options",
+        "default": "append",
+        "options": [
+          { "name": "Append", "value": "append" },
+          { "name": "Merge by Index", "value": "mergeByIndex" }
+        ]
+      }
+    ]
+  }
+]

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

@@ -1,64 +1,55 @@
 export interface GenerateOptions {
     model?: string;
+    provider?: string;
     temperature?: number;
 }
+export interface WorkflowSpec {
+    suggestedName: string;
+    description: string;
+    nodes: {
+        type: string;
+        purpose: string;
+        config?: any;
+    }[];
+    questions?: string[];
+    strategyName?: string;
+    aiModel?: string;
+    aiProvider?: string;
+}
+export declare const PROVIDER_PRESETS: Record<string, {
+    baseURL?: string;
+    defaultModel: string;
+    models: string[];
+}>;
 export declare class AIService {
     private static instance;
-    private client;
+    private clients;
+    private defaultProvider;
     private model;
+    private apiKey;
+    private baseURL?;
     private constructor();
+    private getClient;
     static getInstance(): AIService;
-    /**
-     * Core generation method — works with any OpenAI-compatible API
-     */
+    private callAnthropicNative;
     generateContent(prompt: string, options?: GenerateOptions): Promise<string>;
-    /**
-     * Generate an n8n workflow from a description
-     */
-    generateWorkflow(description: string): Promise<any>;
-    /**
-     * Generate a Workflow Specification from a description
-     */
-    generateSpec(description: string): Promise<any>;
-    /**
-     * Refine a Specification based on user feedback
-     */
-    refineSpec(spec: any, feedback: string): Promise<any>;
-    /**
-     * Generate workflow JSONs from an approved Specification
-     */
-    generateWorkflowFromSpec(spec: any): Promise<any>;
-    /**
-     * Generate mock data for a workflow execution
-     */
-    generateMockData(context: string, previousFailures?: string[]): Promise<any>;
-    /**
-     * Diagnostic Repair: Fix a workflow based on execution error
-     */
-    generateWorkflowFix(workflowJson: any, errorContext: string, model?: string, _useSearch?: boolean, validNodeTypes?: string[]): Promise<any>;
-    /**
-     * Auto-correct common n8n node type hallucinations
-     */
-    private fixHallucinatedNodes;
-    /**
-     * Force-fix connection structure to prevent "object is not iterable" errors
-     */
-    private fixN8nConnections;
-    /**
-     * Generate an alternative workflow specification with a different approach to the same goal.
-     * Used by the Architect node to produce a second strategy for parallel Engineer execution.
-     */
-    generateAlternativeSpec(goal: string, primarySpec: any): Promise<any>;
-    /**
-     * Evaluate multiple workflow candidates and select the best one for the given goal.
-     * Used by the Supervisor node to choose between parallel Engineer outputs.
-     */
+    getAlternativeModel(): string;
+    getDefaultModel(): string;
+    getDefaultProvider(): string;
+    generateSpec(goal: string): Promise<WorkflowSpec>;
+    generateWorkflow(goal: string): Promise<any>;
+    generateAlternativeSpec(goal: string, primarySpec: WorkflowSpec): Promise<WorkflowSpec>;
+    generateWorkflowFix(workflow: any, error: string, model?: string, _stream?: boolean, validNodeTypes?: string[]): Promise<any>;
+    validateAndShim(workflow: any, validNodeTypes?: string[], explicitlyInvalid?: string[]): any;
+    fixHallucinatedNodes(workflow: any): any;
+    fixN8nConnections(workflow: any): any;
+    generateMockData(context: string): Promise<any>;
     evaluateCandidates(goal: string, candidates: any[]): Promise<{
         selectedIndex: number;
         reason: string;
     }>;
     /**
-     * Validate against real node types and shim unknown ones
+     * Generates 3-5 diverse test scenarios (input payloads) for a workflow.
      */
-    validateAndShim(workflow: any, validNodeTypes?: string[], explicitlyInvalid?: string[]): any;
+    generateTestScenarios(workflowJson: any, goal: string): Promise<any[]>;
 }