@lhi/n8m 0.1.2 → 0.2.0

package/dist/agentic/nodes/engineer.js

@@ -1,5 +1,6 @@
 import { AIService } from "../../services/ai.service.js";
 import { NodeDefinitionsService } from "../../services/node-definitions.service.js";
+import { jsonrepair } from "jsonrepair";
 export const engineerNode = async (state) => {
     const aiService = AIService.getInstance();
     // RAG: Load and Search Node Definitions
@@ -9,8 +10,9 @@ export const engineerNode = async (state) => {
     const queryText = (state.userGoal + (state.spec ? ` ${state.spec.suggestedName} ${state.spec.description}` : "")).replace(/\n/g, " ");
     // Search for relevant nodes (limit 8 to save context)
     const relevantDefs = nodeService.search(queryText, 8);
-    const ragContext = relevantDefs.length > 0
-        ? `\n\n[AVAILABLE NODE SCHEMAS - USE THESE EXACT PARAMETERS]\n${nodeService.formatForLLM(relevantDefs)}`
+    const staticRef = nodeService.getStaticReference();
+    const ragContext = (relevantDefs.length > 0 || staticRef)
+        ? `\n\n[N8N NODE REFERENCE GUIDE]\n${staticRef}\n\n[AVAILABLE NODE SCHEMAS - USE THESE EXACT PARAMETERS]\n${nodeService.formatForLLM(relevantDefs)}`
         : "";
     if (relevantDefs.length > 0) {
         console.log(`[Engineer] RAG: Found ${relevantDefs.length} relevant node schemas.`);
@@ -22,7 +24,8 @@ export const engineerNode = async (state) => {
             // We pass the entire list of errors as context
             const errorContext = state.validationErrors.join('\n');
             // Use the robust fix logic from AIService
-            const fixedWorkflow = await aiService.generateWorkflowFix(state.workflowJson, errorContext, undefined, false, state.availableNodeTypes || []);
+            const fixedWorkflow = await aiService.generateWorkflowFix(state.workflowJson, errorContext, state.spec?.aiModel, // Pass model if available
+            false, state.availableNodeTypes || []);
             return {
                 workflowJson: fixedWorkflow,
                 // validationErrors will be overwritten by next QA run
@@ -49,6 +52,7 @@ export const engineerNode = async (state) => {
        Specification:
        ${JSON.stringify(state.spec, null, 2)}
        ${ragContext}
+       ${state.userFeedback ? `\n\nUSER FEEDBACK / REFINEMENTS:\n${state.userFeedback}\n(Incorporate this feedback into the generation process)` : ""}
        
        IMPORTANT:
        1. Desciptive Naming: Name nodes descriptively (e.g. "Fetch Bitcoin Price" instead of "HTTP Request").
@@ -74,23 +78,27 @@ export const engineerNode = async (state) => {
        Output ONLY valid JSON. No commentary. No markdown.
        `;
         // Using AIService just for the LLM call to keep auth logic dry
-        const response = await aiService.generateContent(prompt);
+        const response = await aiService.generateContent(prompt, {
+            provider: state.spec.aiProvider,
+            model: state.spec.aiModel
+        });
         let cleanJson = response || "{}";
         cleanJson = cleanJson.replace(/```json\n?|\n?```/g, "").trim();
         let result;
         try {
-            result = JSON.parse(cleanJson);
+            result = JSON.parse(jsonrepair(cleanJson));
         }
-        catch (e) {
-            console.error("Failed to parse workflow JSON from spec", e);
+        catch (e2) {
+            console.error("Failed to parse workflow JSON from spec", e2);
             throw new Error("AI generated invalid JSON for workflow from spec");
         }
         if (result.workflows && Array.isArray(result.workflows)) {
-            result.workflows = result.workflows.map((wf) => fixHallucinatedNodes(wf));
+            result.workflows = result.workflows.map((wf) => aiService.fixHallucinatedNodes(wf));
         }
         return {
-            workflowJson: result,
-            // For parallel execution, push to candidates
+            // Only push to candidates — the Supervisor sets workflowJson after fan-in.
+            // Writing workflowJson here would cause a LastValue conflict when two
+            // Engineers run in parallel via Send().
             candidates: [result],
         };
     }
@@ -99,84 +107,4 @@ export const engineerNode = async (state) => {
         throw error;
     }
 };
-/**
- * Auto-correct common n8n node type hallucinations
- */
-function fixHallucinatedNodes(workflow) {
-    if (!workflow.nodes || !Array.isArray(workflow.nodes))
-        return workflow;
-    const corrections = {
-        "n8n-nodes-base.rssFeed": "n8n-nodes-base.rssFeedRead",
-        "rssFeed": "n8n-nodes-base.rssFeedRead",
-        "n8n-nodes-base.gpt": "n8n-nodes-base.openAi",
-        "n8n-nodes-base.openai": "n8n-nodes-base.openAi",
-        "openai": "n8n-nodes-base.openAi",
-        "n8n-nodes-base.openAiChat": "n8n-nodes-base.openAi",
-        "n8n-nodes-base.openAIChat": "n8n-nodes-base.openAi",
-        "n8n-nodes-base.openaiChat": "n8n-nodes-base.openAi",
-        "n8n-nodes-base.gemini": "n8n-nodes-base.googleGemini",
-        "n8n-nodes-base.cheerioHtml": "n8n-nodes-base.htmlExtract",
-        "cheerioHtml": "n8n-nodes-base.htmlExtract",
-        "n8n-nodes-base.schedule": "n8n-nodes-base.scheduleTrigger",
-        "schedule": "n8n-nodes-base.scheduleTrigger",
-        "n8n-nodes-base.cron": "n8n-nodes-base.scheduleTrigger",
-        "n8n-nodes-base.googleCustomSearch": "n8n-nodes-base.googleGemini",
-        "googleCustomSearch": "n8n-nodes-base.googleGemini"
-    };
-    workflow.nodes = workflow.nodes.map((node) => {
-        if (node.type && corrections[node.type]) {
-            node.type = corrections[node.type];
-        }
-        // Ensure base prefix if missing
-        if (node.type && !node.type.startsWith('n8n-nodes-base.') && !node.type.includes('.')) {
-            node.type = `n8n-nodes-base.${node.type}`;
-        }
-        return node;
-    });
-    return fixN8nConnections(workflow);
-}
-/**
- * Force-fix connection structure to prevent "object is not iterable" errors
- */
-function fixN8nConnections(workflow) {
-    if (!workflow.connections || typeof workflow.connections !== 'object')
-        return workflow;
-    const fixedConnections = {};
-    for (const [sourceNode, targets] of Object.entries(workflow.connections)) {
-        if (!targets || typeof targets !== 'object')
-            continue;
-        const targetObj = targets;
-        // 2. Ensure "main" exists and is an array
-        if (targetObj.main) {
-            let mainArr = targetObj.main;
-            if (!Array.isArray(mainArr))
-                mainArr = [[{ node: String(mainArr), type: 'main', index: 0 }]];
-            const fixedMain = mainArr.map((segment) => {
-                if (!segment)
-                    return [];
-                if (!Array.isArray(segment)) {
-                    // Wrap in array if it's a single object
-                    return [segment];
-                }
-                return segment.map((conn) => {
-                    if (!conn)
-                        return { node: 'Unknown', type: 'main', index: 0 };
-                    if (typeof conn === 'string')
-                        return { node: conn, type: 'main', index: 0 };
-                    return {
-                        node: String(conn.node || 'Unknown'),
-                        type: conn.type || 'main',
-                        index: conn.index || 0
-                    };
-                });
-            });
-            fixedConnections[sourceNode] = { main: fixedMain };
-        }
-        else {
-            // If it's just raw data like { "Source": { "node": "Target" } }, wrap it
-            fixedConnections[sourceNode] = targetObj;
-        }
-    }
-    workflow.connections = fixedConnections;
-    return workflow;
-}
+// Local helpers removed, using AIService methods instead.

package/dist/agentic/nodes/qa.js

@@ -10,8 +10,9 @@ export const qaNode = async (state) => {
     }
     // 1. Load Credentials
     const config = await ConfigManager.load();
-    const n8nUrl = config.n8nUrl || process.env.N8N_API_URL;
-    const n8nKey = config.n8nKey || process.env.N8N_API_KEY;
+    // Env vars take priority over stored config so a fresh key in .env is always used
+    const n8nUrl = process.env.N8N_API_URL || config.n8nUrl;
+    const n8nKey = process.env.N8N_API_KEY || config.n8nKey;
     if (!n8nUrl || !n8nKey) {
         throw new Error('Credentials missing. Configure environment via \'n8m config\'.');
     }
@@ -28,10 +29,21 @@ export const qaNode = async (state) => {
             targetWorkflow = workflowJson.workflows[0];
         }
         const workflowName = targetWorkflow.name || 'Agentic_Test_Workflow';
+        // Drop timezone — sanitizeSettings in N8nClient strips it unconditionally
+        const rawSettings = { ...(targetWorkflow.settings || {}) };
+        delete rawSettings.timezone;
+        // Strip credentials from all nodes — n8n 2.x refuses to activate ("publish")
+        // a workflow that references credentials that don't exist on the instance.
+        // Structural validation can still run; only live execution of credentialed
+        // nodes will be skipped/fail, which is expected for an ephemeral test.
+        const strippedNodes = targetWorkflow.nodes.map((node) => {
+            const { credentials: _creds, ...rest } = node;
+            return rest;
+        });
         const rootPayload = {
-            nodes: targetWorkflow.nodes,
+            nodes: strippedNodes,
             connections: targetWorkflow.connections,
-            settings: targetWorkflow.settings || {},
+            settings: rawSettings,
             staticData: targetWorkflow.staticData || {},
             name: `[n8m:test] ${workflowName}`,
         };
@@ -49,70 +61,69 @@ export const qaNode = async (state) => {
         console.log(theme.agent(`Deploying ephemeral root: ${rootPayload.name}...`));
         const result = await client.createWorkflow(rootPayload.name, rootPayload);
         createdWorkflowId = result.id;
-        // 4. Generate Mock Data
+        // 4. Determine Test Scenarios
+        let scenarios = state.testScenarios;
+        if (!scenarios || scenarios.length === 0) {
+            // Fallback to generating a single mock payload for efficiency if no scenarios provided
+            const nodeNames = targetWorkflow.nodes.map((n) => n.name).join(', ');
+            const context = `Workflow Name: "${targetWorkflow.name}"
+        Nodes: ${nodeNames}
+        Goal: "${state.userGoal}"
+        Generate a SINGLE JSON object payload that effectively tests this workflow.`;
+            const mockPayload = await aiService.generateMockData(context);
+            scenarios = [{ name: "Default Test", payload: mockPayload }];
+        }
         const webhookNode = rootPayload.nodes.find((n) => n.type === 'n8n-nodes-base.webhook');
-        let triggerSuccess = false;
         if (webhookNode) {
             const path = webhookNode.parameters?.path;
             if (path) {
                 // Activate for webhook testing
                 await client.activateWorkflow(createdWorkflowId);
-                const nodeNames = targetWorkflow.nodes.map((n) => n.name).join(', ');
-                const context = `Workflow Name: "${targetWorkflow.name}"
-            Nodes: ${nodeNames}
-            Goal: "${state.userGoal}"
-            Generate a SINGLE JSON object payload that effectively tests this workflow.`;
-                const mockPayload = await aiService.generateMockData(context);
                 const baseUrl = new URL(n8nUrl).origin;
                 const webhookUrl = `${baseUrl}/webhook/${path}`;
-                const response = await fetch(webhookUrl, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(mockPayload)
-                });
-                if (response.ok) {
-                    triggerSuccess = true;
-                }
-                else {
-                    throw new Error(`Webhook trigger failed with status ${response.status}`);
+                for (const scenario of scenarios) {
+                    console.log(theme.info(`🧪 Running Scenario: ${theme.value(scenario.name)}...`));
+                    const response = await fetch(webhookUrl, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(scenario.payload)
+                    });
+                    if (!response.ok) {
+                        validationErrors.push(`Scenario "${scenario.name}" failed to trigger: ${response.status}`);
+                        continue;
+                    }
+                    // 5. Verify Execution for this scenario
+                    const executionStartTime = Date.now();
+                    let executionFound = false;
+                    const maxPoll = 15;
+                    for (let i = 0; i < maxPoll; i++) {
+                        await new Promise(r => setTimeout(r, 2000));
+                        const executions = await client.getWorkflowExecutions(createdWorkflowId);
+                        const recentExec = executions.find((e) => new Date(e.startedAt).getTime() > (executionStartTime - 5000));
+                        if (recentExec) {
+                            executionFound = true;
+                            const fullExec = await client.getExecution(recentExec.id);
+                            if (fullExec.status === 'success') {
+                                console.log(theme.success(`   ✔ Passed`));
+                            }
+                            else {
+                                const errorMsg = fullExec.data?.resultData?.error?.message || "Unknown flow failure";
+                                validationErrors.push(`Scenario "${scenario.name}" Failed: ${errorMsg}`);
+                                console.log(theme.error(`   ✘ Failed: ${errorMsg}`));
+                            }
+                            break;
+                        }
+                    }
+                    if (!executionFound) {
+                        validationErrors.push(`Scenario "${scenario.name}": No execution detected after trigger.`);
+                        console.log(theme.warn(`   ⚠ No execution detected.`));
+                    }
                 }
             }
         }
         else {
             // Just execute if no webhook (manual trigger)
             await client.executeWorkflow(createdWorkflowId);
-            triggerSuccess = true;
-        }
-        // 5. Verify Execution
-        // Wait for execution to appear
-        if (triggerSuccess) {
-            const executionStartTime = Date.now();
-            let executionFound = false;
-            const maxPoll = 20; // shorter poll for agent
-            for (let i = 0; i < maxPoll; i++) {
-                await new Promise(r => setTimeout(r, 2000));
-                const executions = await client.getWorkflowExecutions(createdWorkflowId);
-                const recentExec = executions.find((e) => new Date(e.startedAt).getTime() > (executionStartTime - 5000));
-                if (recentExec) {
-                    executionFound = true;
-                    const fullExec = await client.getExecution(recentExec.id);
-                    if (fullExec.status === 'success') {
-                        return {
-                            validationStatus: 'passed',
-                            validationErrors: [],
-                        };
-                    }
-                    else {
-                        const errorMsg = fullExec.data?.resultData?.error?.message || "Unknown flow failure";
-                        validationErrors.push(`Execution Failed: ${errorMsg}`);
-                        console.log(theme.error(`Execution Failed: ${errorMsg}`));
-                        break;
-                    }
-                }
-            }
-            if (!executionFound) {
-                validationErrors.push("No execution detected after trigger.");
-            }
         }
         // 6. Dynamic Tool Execution (Sandbox)
         // If the Agent has defined a custom validation script, run it now.
@@ -145,7 +156,7 @@ export const qaNode = async (state) => {
         }
     }
     return {
-        validationStatus: 'failed',
+        validationStatus: validationErrors.length === 0 ? 'passed' : 'failed',
         validationErrors,
     };
 };

package/dist/agentic/nodes/reviewer.js

@@ -66,6 +66,8 @@ export const reviewerNode = async (state) => {
     // Triggers usually have no input.
     // We use a broader check: any node with "trigger" or "webhook" in the name, plus generic start types.
     const isTrigger = (type) => {
+        if (!type)
+            return false;
         const lower = type.toLowerCase();
         return lower.includes('trigger') ||
             lower.includes('webhook') ||
@@ -79,9 +81,9 @@ export const reviewerNode = async (state) => {
             // Sticky notes and Merge nodes can be tricky, but generally Merge needs input.
             if (!node.type.includes('StickyNote')) {
                 // Double check for "On Execution" (custom trigger name sometimes used)
-                if (!node.name.toLowerCase().includes('trigger') && !node.name.toLowerCase().includes('webhook')) {
-                    console.log(theme.warn(`[Reviewer] Validated disconnection: Node "${node.name}" has no incoming connections.`));
-                    validationErrors.push(`Node "${node.name}" (${node.type}) is disconnected (orphaned). Connect it or remove it.`);
+                if (!node.name || (!node.name.toLowerCase().includes('trigger') && !node.name.toLowerCase().includes('webhook'))) {
+                    console.log(theme.warn(`[Reviewer] Validated disconnection: Node "${node.name || 'Unnamed'}" has no incoming connections.`));
+                    validationErrors.push(`Node "${node.name || 'Unnamed'}" (${node.type || 'unknown type'}) is disconnected (orphaned). Connect it or remove it.`);
                 }
             }
         }

package/dist/agentic/state.d.ts

@@ -49,4 +49,14 @@ export declare const TeamState: import("@langchain/langgraph").AnnotationRoot<{
     candidates: import("@langchain/langgraph").BinaryOperatorAggregate<any[], any[]>;
     customTools: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     collaborationLog: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    userFeedback: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    testScenarios: {
+        (): import("@langchain/langgraph").LastValue<any[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<any[], any[]>): import("@langchain/langgraph").BinaryOperatorAggregate<any[], any[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
 }>;

package/dist/agentic/state.js

@@ -28,4 +28,6 @@ export const TeamState = Annotation.Root({
         reducer: (x, y) => x.concat(y),
         default: () => [],
     }),
+    userFeedback: (Annotation),
+    testScenarios: (Annotation),
 });

package/dist/commands/create.js

@@ -3,11 +3,11 @@ import { theme } from '../utils/theme.js';
 import { runAgenticWorkflowStream } from '../agentic/graph.js';
 import * as path from 'node:path';
 import * as fs from 'node:fs/promises';
-import { existsSync } from 'node:fs';
 import inquirer from 'inquirer';
 import { randomUUID } from 'node:crypto';
 import { graph, resumeAgenticWorkflow } from '../agentic/graph.js';
 import { promptMultiline } from '../utils/multilinePrompt.js';
+import { DocService } from '../services/doc.service.js';
 export default class Create extends Command {
     static args = {
         description: Args.string({
@@ -15,7 +15,7 @@ export default class Create extends Command {
             required: false,
         }),
     };
-    static description = 'Generate n8n workflows from natural language using Gemini AI Agent';
+    static description = 'Generate n8n workflows from natural language using an AI Agent';
     static examples = [
         '<%= config.bin %> <%= command.id %> "Send a telegram alert when I receive an email"',
         'echo "Slack to Discord sync" | <%= config.bin %> <%= command.id %>',
@@ -85,9 +85,17 @@ export default class Create extends Command {
                 const stateUpdate = event[nodeName];
                 if (nodeName === 'architect') {
                     this.log(theme.agent(`🏗️  Architect: Blueprint designed.`));
-                    if (stateUpdate.spec?.suggestedName) {
-                        this.log(`   Goal: ${theme.value(stateUpdate.spec.suggestedName)}`);
-                        lastSpec = stateUpdate.spec;
+                    if (stateUpdate.strategies && stateUpdate.strategies.length > 0) {
+                        lastSpec = stateUpdate.strategies[0]; // Default to primary
+                        this.log(theme.header('\nPROPOSED STRATEGIES:'));
+                        stateUpdate.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('');
+                        });
                     }
                 }
                 else if (nodeName === 'engineer') {
@@ -111,36 +119,98 @@ export default class Create extends Command {
                 }
             }
             // Check for interrupt/pause
-            const snapshot = await graph.getState({ configurable: { thread_id: threadId } });
-            if (snapshot.next.length > 0) {
-                this.log(theme.warn(`\n⏸️  Workflow Paused at step: ${snapshot.next.join(', ')}`));
-                const { resume } = await inquirer.prompt([{
-                        type: 'confirm',
-                        name: 'resume',
-                        message: 'Review completed. Resume workflow execution?',
-                        default: true
-                    }]);
-                if (resume) {
-                    this.log(theme.agent("Resuming..."));
-                    // Resume recursively/iteratively? 
-                    // For now, simple resume call. ideally we'd stream again.
-                    // But wait, resumeAgenticWorkflow returns the FINAL result, not a stream.
-                    // We should probably loop if we want to stream again, but let's just create a simple resume handling here.
-                    // Or we can just call resumeAgenticWorkflow and print the final result.
-                    const result = await resumeAgenticWorkflow(threadId);
-                    if (result.validationStatus === 'passed') {
-                        this.log(theme.success(`🧪 QA (Resumed): Validation Passed!`));
-                        if (result.workflowJson)
-                            lastWorkflowJson = result.workflowJson;
+            let snapshot = await graph.getState({ configurable: { thread_id: threadId } });
+            while (snapshot.next.length > 0) {
+                const nextNode = snapshot.next[0];
+                this.log(theme.warn(`\n⏸️  Workflow Paused at step: ${nextNode}`));
+                if (nextNode === 'engineer') {
+                    const { action } = await inquirer.prompt([{
+                            type: 'list',
+                            name: 'action',
+                            message: 'How would you like to proceed with the Blueprint?',
+                            choices: [
+                                { name: 'Approve and Generate Workflow', value: 'approve' },
+                                { name: 'Provide Feedback / Refine Strategy', value: 'feedback' },
+                                { name: 'Exit and Resume Later', value: 'exit' }
+                            ]
+                        }]);
+                    if (action === 'approve') {
+                        this.log(theme.agent("Approve! Proceeding to engineering..."));
+                        await graph.updateState({ configurable: { thread_id: threadId } }, { userFeedback: undefined }, nextNode);
+                        const stream = await graph.stream(null, { configurable: { thread_id: threadId } });
+                        for await (const event of stream) {
+                            const nodeName = Object.keys(event)[0];
+                            const stateUpdate = event[nodeName];
+                            if (nodeName === 'engineer') {
+                                this.log(theme.agent(`⚙️  Engineer: Workflow code generated/updated.`));
+                                if (stateUpdate.workflowJson)
+                                    lastWorkflowJson = stateUpdate.workflowJson;
+                            }
+                            else if (nodeName === 'qa') {
+                                const status = stateUpdate.validationStatus;
+                                if (status === 'passed')
+                                    this.log(theme.success(`🧪 QA: Validation Passed!`));
+                                else
+                                    this.log(theme.fail(`🧪 QA: Validation Failed.`));
+                            }
+                        }
+                    }
+                    else if (action === 'feedback') {
+                        const { feedback } = await inquirer.prompt([{
+                                type: 'input',
+                                name: 'feedback',
+                                message: 'Enter your feedback/instructions:',
+                            }]);
+                        this.log(theme.agent("Updating strategy with your feedback..."));
+                        // In a real implementation, we'd loop back to Architect or update the goal.
+                        // For now, let's update userFeedback and resume. 
+                        // To actually RE-ARCHITECT, we might need to jump back.
+                        // LangGraph can handle this by updating state and using a conditional edge.
+                        await graph.updateState({ configurable: { thread_id: threadId } }, { userFeedback: feedback }, nextNode);
+                        // For now, just resume and let Engineer see the feedback.
+                        const stream = await graph.stream(null, { configurable: { thread_id: threadId } });
+                        for await (const event of stream) {
+                            const nodeName = Object.keys(event)[0];
+                            const stateUpdate = event[nodeName];
+                            if (nodeName === 'engineer') {
+                                this.log(theme.agent(`⚙️  Engineer: Workflow code generated/updated (Feedback incorporated).`));
+                                if (stateUpdate.workflowJson)
+                                    lastWorkflowJson = stateUpdate.workflowJson;
+                            }
+                            else if (nodeName === 'qa') {
+                                if (stateUpdate.validationStatus === 'passed')
+                                    this.log(theme.success(`🧪 QA: Validation Passed!`));
+                            }
+                        }
                     }
                     else {
-                        this.log(theme.fail(`🧪 QA (Resumed): Final Status: ${result.validationStatus}`));
+                        this.log(theme.info(`Session persisted. Resume later with: n8m resume ${threadId}`));
+                        return;
                     }
                 }
                 else {
-                    this.log(theme.info(`Session persisted. Resume later with: n8m resume ${threadId}`));
-                    return;
+                    // Handle other interrupts (like QA)
+                    const { resume } = await inquirer.prompt([{
+                            type: 'confirm',
+                            name: 'resume',
+                            message: `Review completed for ${nextNode}. Resume workflow execution?`,
+                            default: true
+                        }]);
+                    if (resume) {
+                        this.log(theme.agent("Resuming..."));
+                        const result = await resumeAgenticWorkflow(threadId);
+                        if (result.validationStatus === 'passed') {
+                            this.log(theme.success(`🧪 QA (Resumed): Validation Passed!`));
+                            if (result.workflowJson)
+                                lastWorkflowJson = result.workflowJson;
+                        }
+                    }
+                    else {
+                        this.log(theme.info(`Session persisted. Resume later with: n8m resume ${threadId}`));
+                        return;
+                    }
                 }
+                snapshot = await graph.getState({ configurable: { thread_id: threadId } });
             }
         }
         catch (error) {
@@ -153,28 +223,25 @@ export default class Create extends Command {
         // Normalize to array
         const workflows = lastWorkflowJson.workflows || [lastWorkflowJson];
         const savedResources = [];
+        const docService = DocService.getInstance();
         for (const workflow of workflows) {
             const workflowName = workflow.name || (lastSpec && lastSpec.suggestedName) || 'generated-workflow';
-            const sanitizedName = workflowName.replace(/[^a-z0-9]+/gi, '-').replace(/^-+|-+$/g, '').toLowerCase();
-            let targetFile = flags.output;
-            // If multiple workflows and output provided, append name to avoid overwrite, unless it's a directory
-            if (workflows.length > 1 && targetFile && !targetFile.endsWith('.json')) {
-                targetFile = path.join(targetFile, `${sanitizedName}.json`);
-            }
-            else if (workflows.length > 1 && targetFile) {
-                // If specific file given but we have multiple, suffix it
-                targetFile = targetFile.replace('.json', `-${sanitizedName}.json`);
-            }
-            else if (!targetFile) {
-                const targetDir = path.join(process.cwd(), 'workflows');
-                if (!existsSync(targetDir)) {
-                    await fs.mkdir(targetDir, { recursive: true });
-                }
-                targetFile = path.join(targetDir, `${sanitizedName}.json`);
-            }
+            const projectTitle = await docService.generateProjectTitle(workflow);
+            workflow.name = projectTitle; // Standardize name
+            const slug = docService.generateSlug(projectTitle);
+            const workflowsDir = path.join(process.cwd(), 'workflows');
+            const targetDir = path.join(workflowsDir, slug);
+            const targetFile = path.join(targetDir, 'workflow.json');
+            await fs.mkdir(targetDir, { recursive: true });
             await fs.writeFile(targetFile, JSON.stringify(workflow, null, 2));
-            savedResources.push({ path: targetFile, name: workflowName, original: workflow });
-            this.log(theme.success(`\nWorkflow saved to: ${targetFile}`));
+            this.log(theme.success(`\nWorkflow organized at: ${targetDir}`));
+            // Auto-Generate Documentation
+            this.log(theme.agent("Generating initial documentation..."));
+            const mermaid = docService.generateMermaid(workflow);
+            const readmeContent = await docService.generateReadme(workflow);
+            const fullDoc = `# ${projectTitle}\n\n## Visual Flow\n\n\`\`\`mermaid\n${mermaid}\`\`\`\n\n${readmeContent}`;
+            await fs.writeFile(path.join(targetDir, 'README.md'), fullDoc);
+            savedResources.push({ path: targetFile, name: projectTitle, original: workflow });
         }
         this.log(theme.done('Agentic Workflow Complete.'));
         process.exit(0);

package/dist/commands/doc.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class Doc extends Command {
+    static args: {
+        workflow: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}