@lhi/n8m 0.1.3 → 0.2.0

package/README.md

@@ -1,12 +1,15 @@
 # n8m: The Agentic CLI for n8n
 
-> Generate, modify, test, and deploy n8n workflows from the command line using AI.
+> Generate, modify, test, and deploy n8n workflows from the command line using
+> AI.
 
 [![TypeScript](https://badgen.net/badge/Built%20with/TypeScript/blue)](https://typescriptlang.org/)
 [![oclif](https://badgen.net/badge/CLI/oclif/purple)](https://oclif.io/)
 [![n8n](https://badgen.net/badge/n8n/Compatible/orange)](https://n8n.io)
 
-**Stop clicking. Start shipping.** `n8m` is an open-source CLI that wraps your n8n instance with an agentic AI layer. Describe what you want in plain English — the agent designs, builds, validates, and deploys it.
+**Stop clicking. Start shipping.** `n8m` is an open-source CLI that wraps your
+n8n instance with an agentic AI layer. Describe what you want in plain English —
+the agent designs, builds, validates, and deploys it.
 
 No account. No server. Bring your own AI key and your n8n instance.
 
@@ -26,7 +29,8 @@ npm install -g n8m
 
 ### 1. Configure your AI provider
 
-`n8m` stores credentials in `~/.n8m/config.json` so they persist across sessions — including `npx` invocations.
+`n8m` stores credentials in `~/.n8m/config.json` so they persist across sessions
+— including `npx` invocations.
 
 ```bash
 # OpenAI
@@ -42,13 +46,14 @@ npx n8m config --ai-provider gemini --ai-key AIza...
 npx n8m config --ai-base-url http://localhost:11434/v1 --ai-key ollama --ai-model llama3
 ```
 
-You can also use environment variables or a `.env` file — env vars take priority over stored config:
+You can also use environment variables or a `.env` file — env vars take priority
+over stored config:
 
-| Variable | Description |
-|---|---|
-| `AI_PROVIDER` | Preset: `openai`, `anthropic`, or `gemini` |
-| `AI_API_KEY` | API key for your provider |
-| `AI_MODEL` | Override the model (optional) |
+| Variable      | Description                                              |
+| ------------- | -------------------------------------------------------- |
+| `AI_PROVIDER` | Preset: `openai`, `anthropic`, or `gemini`               |
+| `AI_API_KEY`  | API key for your provider                                |
+| `AI_MODEL`    | Override the model (optional)                            |
 | `AI_BASE_URL` | Custom base URL for any OpenAI-compatible API (optional) |
 
 Default models per provider: `gpt-4o` · `claude-sonnet-4-6` · `gemini-2.5-flash`
@@ -59,7 +64,8 @@ Default models per provider: `gpt-4o` · `claude-sonnet-4-6` · `gemini-2.5-flas
 npx n8m config --n8n-url https://your-n8n.example.com --n8n-key <your-n8n-api-key>
 ```
 
-Credentials are saved locally to `~/.n8m/config.json`. You can also use environment variables `N8N_API_URL` and `N8N_API_KEY` instead.
+Credentials are saved locally to `~/.n8m/config.json`. You can also use
+environment variables `N8N_API_URL` and `N8N_API_KEY` instead.
 
 ---
 
@@ -67,7 +73,8 @@ Credentials are saved locally to `~/.n8m/config.json`. You can also use environm
 
 ### `n8m create` — Generate a workflow
 
-Describe what you want and the agentic pipeline designs, builds, and validates it.
+Describe what you want and the agentic pipeline designs, builds, and validates
+it.
 
 ```bash
 n8m create "Send a Slack message whenever a new row is added to a Google Sheet"
@@ -80,11 +87,17 @@ n8m create --multiline
 ```
 
 The agent runs through three stages:
+
 1. **Architect** — designs the blueprint and identifies required nodes
 2. **Engineer** — generates the workflow JSON
 3. **QA** — validates the result; loops back to Engineer if issues are found
 
-The finished workflow is saved as a local JSON file (default: `./workflows/`).
+The finished workflow is saved as an organized project folder (default:
+`./workflows/<project-slug>/`). Each project folder contains:
+
+- `workflow.json`: The generated n8n workflow.
+- `README.md`: Automatic documentation including a Mermaid.js diagram and an
+  AI-generated summary.
 
 ---
 
@@ -103,13 +116,34 @@ n8m modify
 n8m modify --multiline
 ```
 
-After modification you'll be prompted to save locally, deploy to your instance, or run a test.
+After modification you'll be prompted to save locally (organized into its
+project folder), deploy to your instance, or run a test.
+
+---
+
+### `n8m doc` — Generate documentation
+
+Generate visual and text documentation for existing local or remote workflows.
+
+```bash
+# Document a local workflow file
+n8m doc ./workflows/my-workflow.json
+
+# Browse and select from local files + remote instance
+n8m doc
+```
+
+- Generates a `README.md` in the workflow's project directory.
+- Includes a **Mermaid.js** flowchart of the workflow logic.
+- Includes an **AI-generated summary** of the nodes and execution flow.
+- Automatically organizes loose `.json` files into project folders.
 
 ---
 
 ### `n8m test` — Validate and auto-repair a workflow
 
-Deploys a workflow ephemerally to your instance, validates it, and purges it when done. If validation fails, the repair loop kicks in automatically.
+Deploys a workflow ephemerally to your instance, validates it, and purges it
+when done. If validation fails, the repair loop kicks in automatically.
 
 ```bash
 # Test a local file
@@ -122,6 +156,7 @@ n8m test
 - Resolves and deploys sub-workflow dependencies automatically
 - Patches node IDs after ephemeral deployment
 - After a passing test, prompts to deploy or save the validated/repaired version
+- **Auto-documents**: Generates or updates the project `README.md` upon saving.
 - All temporary assets are deleted on exit
 
 ---
@@ -141,19 +176,22 @@ n8m deploy ./workflows/my-flow.json --activate
 
 ### `n8m resume` — Resume a paused session
 
-The agent can pause mid-run for human review (HITL). Resume it with its thread ID.
+The agent can pause mid-run for human review (HITL). Resume it with its thread
+ID.
 
 ```bash
 n8m resume <thread-id>
 ```
 
-Sessions are persisted to a local SQLite database, so they survive crashes and restarts.
+Sessions are persisted to a local SQLite database, so they survive crashes and
+restarts.
 
 ---
 
 ### `n8m prune` — Clean up your instance
 
-Removes duplicate workflows and leftover test artifacts (`[n8m:test:*]` prefixed names).
+Removes duplicate workflows and leftover test artifacts (`[n8m:test:*]` prefixed
+names).
 
 ```bash
 # Preview what would be deleted
@@ -167,7 +205,8 @@ n8m prune --force
 
 ### `n8m config` — Manage configuration
 
-All credentials are saved to `~/.n8m/config.json` and persist across sessions (including `npx` invocations).
+All credentials are saved to `~/.n8m/config.json` and persist across sessions
+(including `npx` invocations).
 
 ```bash
 # Set AI provider
@@ -209,13 +248,23 @@ Developer → n8m create "..."
         └──────┬──────┘       └─────────────┘
                │ passed
                ▼
-        ./workflows/output.json
+                ▼
+        ./workflows/<slug>/
+           ├── workflow.json
+           └── README.md (with Mermaid diagram)
 ```
 
 - **Local first**: credentials and workflow files live on your machine
+- **Organized Projects**: Workflows are grouped into folders with auto-generated
+  documentation
 - **SQLite persistence**: session state survives interruptions
 - **HITL pauses**: the agent stops for your review before committing
-- **Bring your own AI**: works with OpenAI, Claude, Gemini, Ollama, or any OpenAI-compatible API
+- **Bring your own AI**: works with OpenAI, Claude, Gemini, Ollama, or any
+  OpenAI-compatible API
+
+> **For developers**: See the [Developer Guide](docs/DEVELOPER_GUIDE.md) for a
+> deep-dive into the agentic graph internals, RAG implementation, how to add new
+> agent nodes, and how to extend the CLI.
 
 ---
 
@@ -250,6 +299,12 @@ npm run dev
 - [x] HITL interrupts and resume
 - [x] Sub-workflow dependency resolution in tests
 - [x] Open source — no account required
-- [x] Multi-provider AI support (OpenAI, Claude, Gemini, Ollama, any OpenAI-compatible API)
+- [x] Multi-provider AI support (OpenAI, Claude, Gemini, Ollama, any
+      OpenAI-compatible API)
+- [x] Automatic documentation generation (Mermaid + AI Summary)
+- [x] Project-based folder organization
+- [x] AI-driven test scenario generation (`--ai-scenarios`)
+- [x] Static node type reference & fallback mechanism
+- [x] Multi-workflow project generation support
 - [ ] Native n8n canvas integration
 - [ ] Multi-agent collaboration on a single goal

package/dist/agentic/graph.d.ts

@@ -13,6 +13,8 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
     candidates: any[];
     customTools: Record<string, string>;
     collaborationLog: string[];
+    userFeedback: string;
+    testScenarios: any[];
 }, {
     userGoal?: string | undefined;
     spec?: any;
@@ -27,6 +29,8 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
     candidates?: any[] | undefined;
     customTools?: Record<string, string> | undefined;
     collaborationLog?: string[] | undefined;
+    userFeedback?: string | undefined;
+    testScenarios?: any[] | undefined;
 }, "__start__" | "architect" | "engineer" | "reviewer" | "supervisor" | "qa", {
     userGoal: {
         (): import("@langchain/langgraph").LastValue<string>;
@@ -77,6 +81,16 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
     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>;
+    };
 }, {
     userGoal: {
         (): import("@langchain/langgraph").LastValue<string>;
@@ -127,6 +141,16 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
     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>;
+    };
 }, import("@langchain/langgraph").StateDefinition, {
     architect: {
         spec: import("../services/ai.service.js").WorkflowSpec;
@@ -206,6 +230,16 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
         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>;
+        };
     }>;
     supervisor: {
         workflowJson?: undefined;
@@ -264,6 +298,16 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
         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>;
+        };
     }>;
 }, unknown, unknown>;
 /**
@@ -322,6 +366,16 @@ export declare const runAgenticWorkflow: (goal: string, initialState?: Partial<t
     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>;
+    };
 }>>;
 /**
  * Run the Agentic Workflow with Streaming
@@ -407,6 +461,16 @@ export declare const runAgenticWorkflowStream: (goal: string, threadId?: string)
         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>;
+        };
     }> | undefined;
     supervisor?: {
         workflowJson?: undefined;
@@ -465,6 +529,16 @@ export declare const runAgenticWorkflowStream: (goal: string, threadId?: string)
         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>;
+        };
     }> | undefined;
 }>>;
 /**
@@ -520,4 +594,14 @@ export declare const resumeAgenticWorkflow: (threadId: string, input?: any) => P
     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/graph.js

@@ -53,7 +53,7 @@ const workflow = new StateGraph(TeamState)
 // Compile the graph with persistence and interrupts
 export const graph = workflow.compile({
     checkpointer: checkpointer,
-    interruptBefore: ["qa"],
+    interruptBefore: ["engineer", "qa"],
 });
 /**
  * Run the Agentic Workflow

package/dist/agentic/nodes/engineer.js

@@ -52,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").
@@ -92,7 +93,7 @@ export const engineerNode = async (state) => {
             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 {
             // Only push to candidates — the Supervisor sets workflowJson after fan-in.
@@ -106,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

@@ -61,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.
@@ -157,7 +156,7 @@ export const qaNode = async (state) => {
         }
     }
     return {
-        validationStatus: 'failed',
+        validationStatus: validationErrors.length === 0 ? 'passed' : 'failed',
         validationErrors,
     };
 };

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),
 });