@lhi/n8m 0.1.0

package/dist/agentic/nodes/architect.js

@@ -0,0 +1,51 @@
+import { AIService } from "../../services/ai.service.js";
+export const architectNode = async (state) => {
+    const aiService = AIService.getInstance();
+    if (!state.userGoal) {
+        throw new Error("User goal is missing from state.");
+    }
+    // Pass-through if we already have a workflow (Repairs/Testing mode)
+    // BUT if we have a goal that implies modification, we should probably still generate a spec?
+    // For now, let's allow spec generation even if workflowJson exists, so the Engineer can use the spec + old workflow to make new one.
+    // The logic in Architect assumes "generateSpec" creates a NEW spec from scratch.
+    // We might need a "modifySpec" or just rely on the Engineer to interpret the goal + existing workflow.
+    // If we skip the architect, we go straight to Engineer?
+    // The graph edges are: START -> architect -> engineer.
+    // If we return empty here, 'spec' is undefined in state.
+    // Engineer checks state.spec.
+    // If we want to support modification, the Architect should probably analyze the request vs the current workflow.
+    // However, for the first MVP, if we return empty, the Engineer will run.
+    // Does Engineer handle "no spec" but "has workflowJson" + "userGoal"?
+    // Let's assume we want the Architect to generate a plan (Spec) for the modification.
+    // So we REMOVE this early return, or condition it on "isRepair" vs "isModify".
+    // Since we don't have an explicit flag, we can just let it run.
+    // The prompt for generateSpec might need to know about the existing workflow?
+    // Currently generateSpec only sees the goal.
+    // Let's comment it out for now to allow Architect to run.
+    // if (state.workflowJson) {
+    //     return {};
+    // }
+    try {
+        const spec = await aiService.generateSpec(state.userGoal);
+        // Check if the spec requires clarification
+        const questions = spec.questions;
+        const needsClarification = questions && questions.length > 0;
+        // For parallelism, we can create a secondary "Alternative" strategy
+        // In a real scenario, the LLM would generate these explicitly.
+        // Here we simulate it by wrapping the single spec into a strategy list.
+        const strategies = [
+            { ...spec, name: "Primary Strategy" },
+            // We could ask AI for an alternative here, but for now let's keep it simple to save tokens
+            // { ...spec, name: "Alternative Strategy (Robust)" } 
+        ];
+        return {
+            spec, // Keep backward compatibility for single-path
+            strategies,
+            needsClarification,
+        };
+    }
+    catch (error) {
+        console.error("Architect failed:", error);
+        throw error;
+    }
+};

package/dist/agentic/nodes/engineer.d.ts

@@ -0,0 +1,11 @@
+import { TeamState } from "../state.js";
+export declare const engineerNode: (state: typeof TeamState.State) => Promise<{
+    workflowJson: any;
+    candidates?: undefined;
+} | {
+    workflowJson?: undefined;
+    candidates?: undefined;
+} | {
+    workflowJson: any;
+    candidates: any[];
+}>;

package/dist/agentic/nodes/engineer.js

@@ -0,0 +1,182 @@
+import { AIService } from "../../services/ai.service.js";
+import { NodeDefinitionsService } from "../../services/node-definitions.service.js";
+export const engineerNode = async (state) => {
+    const aiService = AIService.getInstance();
+    // RAG: Load and Search Node Definitions
+    const nodeService = NodeDefinitionsService.getInstance();
+    await nodeService.loadDefinitions();
+    // Extract keywords from goal + spec
+    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)}`
+        : "";
+    if (relevantDefs.length > 0) {
+        console.log(`[Engineer] RAG: Found ${relevantDefs.length} relevant node schemas.`);
+    }
+    // Self-Correction Loop Check
+    if (state.validationErrors && state.validationErrors.length > 0) {
+        console.log("🔧 Engineer is fixing the workflow based on QA feedback...");
+        try {
+            // 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 || []);
+            return {
+                workflowJson: fixedWorkflow,
+                // validationErrors will be overwritten by next QA run
+            };
+        }
+        catch (error) {
+            console.error("Engineer failed to fix workflow:", error);
+            throw error;
+        }
+    }
+    // Pass-through if workflow exists and no errors (Initial pass for existing workflow)
+    if (state.workflowJson) {
+        return {};
+    }
+    // Standard Creation Flow
+    // console.log("⚙️  Engineer is building the workflow...");
+    if (!state.spec) {
+        throw new Error("Workflow specification is missing.");
+    }
+    try {
+        const prompt = `You are an n8n Workflow Engineer.
+       Generate the valid n8n workflow JSON(s) based on the following approved Specification.
+       
+       Specification:
+       ${JSON.stringify(state.spec, null, 2)}
+       ${ragContext}
+       
+       IMPORTANT:
+       1. Desciptive Naming: Name nodes descriptively (e.g. "Fetch Bitcoin Price" instead of "HTTP Request").
+       2. Multi-Workflow: If the spec requires multiple workflows (e.g. Main + Sub-workflow), generate them all.
+       3. Linking: If one workflow calls another (using an 'Execute Workflow' node), use the "suggestedName" of the target workflow as the 'workflowId' parameter value. Do NOT use generic IDs like "SUBWORKFLOW_ID".
+       4. Consistency: Ensure the "name" field in each workflow matches one of the suggestedNames from the spec.
+       5. Standard Node Types: Use valid n8n-nodes-base types. 
+          - Use "n8n-nodes-base.rssFeedRead" for RSS reading (NOT "rssFeed").
+          - Use "n8n-nodes-base.httpRequest" for API calls.
+          - Use "n8n-nodes-base.openAi" for OpenAI.
+          - Use "n8n-nodes-base.googleGemini" for Google Gemini.
+          - Use "n8n-nodes-base.htmlExtract" for HTML/Cheerio extraction.
+       6. Connections Structure: The "connections" object keys MUST BE THE SOURCE NODE NAME. The "node" field inside the connection array MUST BE THE TARGET NODE NAME.
+       7. Connection Nesting: Ensure the correct n8n connection structure: "SourceNodeName": { "main": [ [ { "node": "TargetNodeName", "type": "main", "index": 0 } ] ] }.
+
+       Output a JSON object with this structure:
+       {
+          "workflows": [
+              { "name": "Workflow Name", "nodes": [...], "connections": {...} }
+          ]
+       }
+       
+       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);
+        let cleanJson = response || "{}";
+        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, "").trim();
+        let result;
+        try {
+            result = JSON.parse(cleanJson);
+        }
+        catch (e) {
+            console.error("Failed to parse workflow JSON from spec", e);
+            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));
+        }
+        return {
+            workflowJson: result,
+            // For parallel execution, push to candidates
+            candidates: [result],
+        };
+    }
+    catch (error) {
+        console.error("Engineer failed:", error);
+        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;
+}

package/dist/agentic/nodes/qa.d.ts

@@ -0,0 +1,5 @@
+import { TeamState } from "../state.js";
+export declare const qaNode: (state: typeof TeamState.State) => Promise<{
+    validationStatus: string;
+    validationErrors: string[];
+}>;

package/dist/agentic/nodes/qa.js

@@ -0,0 +1,151 @@
+import { AIService } from "../../services/ai.service.js";
+import { ConfigManager } from "../../utils/config.js";
+import { N8nClient } from "../../utils/n8nClient.js";
+import { theme } from "../../utils/theme.js";
+export const qaNode = async (state) => {
+    const aiService = AIService.getInstance();
+    const workflowJson = state.workflowJson;
+    if (!workflowJson) {
+        throw new Error("No workflow JSON found in state to test.");
+    }
+    // 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;
+    if (!n8nUrl || !n8nKey) {
+        throw new Error('Credentials missing. Configure environment via \'n8m config\'.');
+    }
+    const client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
+    let createdWorkflowId = null;
+    const validationErrors = [];
+    try {
+        // 2. Prepare Workflow Data (Extract from state structure)
+        // engineerNode returns { workflows: [ { name, nodes, connections } ] }
+        // Or it might just return the single workflow object if that's how it was implemented.
+        // Based on engineer.ts logic: it returns { workflowJson: result } where result matches { workflows: [...] } structure.
+        let targetWorkflow = workflowJson;
+        if (workflowJson.workflows && Array.isArray(workflowJson.workflows) && workflowJson.workflows.length > 0) {
+            targetWorkflow = workflowJson.workflows[0];
+        }
+        const workflowName = targetWorkflow.name || 'Agentic_Test_Workflow';
+        const rootPayload = {
+            nodes: targetWorkflow.nodes,
+            connections: targetWorkflow.connections,
+            settings: targetWorkflow.settings || {},
+            staticData: targetWorkflow.staticData || {},
+            name: `[n8m:test] ${workflowName}`,
+        };
+        // Shim trigger if needed (reusing logic from test.ts)
+        // CRITICAL: We MUST have a proper Webhook for automated testing to working.
+        // Manual Triggers cannot be "activated" via API, and we need activation for validation.
+        // So we inject a webhook shim even if a Manual Trigger exists.
+        const hasWebhook = rootPayload.nodes.some((n) => n.type === 'n8n-nodes-base.webhook' && !n.disabled);
+        if (!hasWebhook) {
+            const shimmed = client.injectManualTrigger(rootPayload);
+            rootPayload.nodes = shimmed.nodes;
+            rootPayload.connections = shimmed.connections;
+        }
+        // 3. Deploy Ephemeral Workflow
+        console.log(theme.agent(`Deploying ephemeral root: ${rootPayload.name}...`));
+        const result = await client.createWorkflow(rootPayload.name, rootPayload);
+        createdWorkflowId = result.id;
+        // 4. Generate Mock Data
+        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}`);
+                }
+            }
+        }
+        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.
+        // In the future, the QA agent could generate this script on the fly.
+        if (state.customTools && state.customTools['validationScript']) {
+            console.log("🛠️  QA is running custom validation script...");
+            const script = state.customTools['validationScript'];
+            const sandboxResult = (await import('../../utils/sandbox.js')).Sandbox.run(script, {
+                workflowJson,
+                validationErrors
+            });
+            if (sandboxResult === false) {
+                validationErrors.push("Custom validation script failed.");
+            }
+        }
+    }
+    catch (error) {
+        const errorMsg = error.message;
+        console.error(theme.error(`QA Node Error: ${errorMsg}`));
+        validationErrors.push(errorMsg);
+    }
+    finally {
+        // Cleanup
+        if (createdWorkflowId) {
+            try {
+                await client.deleteWorkflow(createdWorkflowId);
+                console.log(theme.info(`Purged temporary workflow ${createdWorkflowId}`));
+            }
+            catch { /* intentionally empty */ }
+        }
+    }
+    return {
+        validationStatus: 'failed',
+        validationErrors,
+    };
+};

package/dist/agentic/nodes/reviewer.d.ts

@@ -0,0 +1,5 @@
+import { TeamState } from "../state.js";
+export declare const reviewerNode: (state: typeof TeamState.State) => Promise<{
+    validationStatus: string;
+    validationErrors: string[];
+}>;

package/dist/agentic/nodes/reviewer.js

@@ -0,0 +1,111 @@
+import { theme } from "../../utils/theme.js";
+export const reviewerNode = async (state) => {
+    const workflowJson = state.workflowJson;
+    const validationErrors = [];
+    if (!workflowJson) {
+        return {
+            validationStatus: 'failed',
+            validationErrors: ["No workflow JSON found to review."]
+        };
+    }
+    // Helper to get nodes from potentially nested structure
+    let nodes = [];
+    let targetWorkflow = workflowJson;
+    if (workflowJson.workflows && Array.isArray(workflowJson.workflows) && workflowJson.workflows.length > 0) {
+        targetWorkflow = workflowJson.workflows[0];
+    }
+    if (targetWorkflow.nodes && Array.isArray(targetWorkflow.nodes)) {
+        nodes = targetWorkflow.nodes;
+    }
+    // 1. Check for hallucinated node types
+    const knownHallucinations = [
+        "rssFeed", "n8n-nodes-base.rssFeed",
+        "n8n-nodes-base.gpt", "n8n-nodes-base.openai", "openai",
+        "n8n-nodes-base.gemini",
+        "cheerioHtml", "n8n-nodes-base.cheerioHtml"
+    ];
+    nodes.forEach(node => {
+        if (knownHallucinations.includes(node.type)) {
+            console.log(theme.warn(`[Reviewer] Detected hallucinated node type: ${node.type}`));
+            validationErrors.push(`Hallucinated node type detected: "${node.type}". Use standard n8n-nodes-base types.`);
+        }
+        // Check for empty names
+        if (!node.name || node.name.trim() === "") {
+            validationErrors.push(`Node with type "${node.type}" has an empty name.`);
+        }
+        // 1.1 Strict Type Check (if available)
+        if (state.availableNodeTypes && state.availableNodeTypes.length > 0) {
+            if (!state.availableNodeTypes.includes(node.type)) {
+                // Double check it's not a known exception or recent core node
+                if (!node.type.startsWith('n8n-nodes-base.stick')) { // generic bypass for sticky notes etc if needed
+                    console.log(theme.warn(`[Reviewer] Node type not found in instance: ${node.type}`));
+                    validationErrors.push(`Node type "${node.type}" is not available on your n8n instance.`);
+                }
+            }
+        }
+    });
+    // 2. Check for disconnected nodes (Orphans)
+    // Build adjacency list (which nodes are destinations?)
+    const destinations = new Set();
+    const connections = targetWorkflow.connections || {};
+    for (const sourceNode in connections) {
+        const outputConfig = connections[sourceNode];
+        // iterate over outputs (main, ai_tool, etc)
+        for (const outputType in outputConfig) {
+            const routes = outputConfig[outputType];
+            routes.forEach((route) => {
+                route.forEach((connection) => {
+                    if (connection.node) {
+                        destinations.add(connection.node);
+                    }
+                });
+            });
+        }
+    }
+    // Iterate nodes to find orphans (non-trigger nodes with no incoming connections)
+    // 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) => {
+        const lower = type.toLowerCase();
+        return lower.includes('trigger') ||
+            lower.includes('webhook') ||
+            lower.includes('n8n-nodes-base.start') ||
+            lower.includes('n8n-nodes-base.poll');
+    };
+    nodes.forEach(node => {
+        // 2.1 Orphan Check
+        if (!destinations.has(node.name) && !isTrigger(node.type)) {
+            // It's an orphan unless it's a known trigger-like node
+            // 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.`);
+                }
+            }
+        }
+        // 2.2 Sub-Workflow Validation
+        if (node.type === 'n8n-nodes-base.executeWorkflow') {
+            const workflowId = node.parameters?.workflowId;
+            const mode = node.parameters?.mode || 'id'; // default is often ID
+            if (!workflowId && mode === 'id') {
+                validationErrors.push(`Node "${node.name}" (Execute Workflow) is missing a 'workflowId' parameter.`);
+            }
+        }
+    });
+    // 3. Credentials Check
+    // If we see an OpenAI node, warn if no credential ID is placeholder? (Skip for now)
+    if (validationErrors.length > 0) {
+        return {
+            validationStatus: 'failed',
+            validationErrors: validationErrors,
+        };
+    }
+    // console.log(theme.success("Reviewer passed the blueprint."));
+    return {
+        validationStatus: 'passed',
+        // Clear errors from previous runs
+        validationErrors: []
+    };
+};

package/dist/agentic/nodes/supervisor.d.ts

@@ -0,0 +1,6 @@
+import { TeamState } from "../state.js";
+export declare const supervisorNode: (state: typeof TeamState.State) => Promise<{
+    workflowJson?: undefined;
+} | {
+    workflowJson: any;
+}>;

package/dist/agentic/nodes/supervisor.js

@@ -0,0 +1,18 @@
+import { theme } from "../../utils/theme.js";
+export const supervisorNode = async (state) => {
+    const candidates = state.candidates;
+    if (!candidates || candidates.length === 0) {
+        // Fallback: use existing workflowJson if available
+        return {};
+    }
+    console.log(theme.agent(`Supervisor found ${candidates.length} candidates.`));
+    // In a real agentic system, we would have an LLM evaluate them.
+    // For now, we'll pick the first one (or the one with the most nodes? or custom logic?).
+    // Let's simulate "Selection":
+    const bestCandidate = candidates[0];
+    console.log(theme.success(`Supervisor selected: ${bestCandidate.name || "Unnamed Workflow"}`));
+    // We set the chosen one as the canonical 'workflowJson' for the rest of the flow (QA, etc)
+    return {
+        workflowJson: bestCandidate
+    };
+};

package/dist/agentic/state.d.ts

@@ -0,0 +1,51 @@
+import { BaseMessage } from "@langchain/core/messages";
+export declare const TeamState: import("@langchain/langgraph").AnnotationRoot<{
+    userGoal: {
+        (): 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>;
+    };
+    spec: {
+        (): 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>;
+    };
+    workflowJson: {
+        (): 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>;
+    };
+    validationErrors: {
+        (): 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>;
+    };
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[], BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[]>;
+    needsClarification: {
+        (): import("@langchain/langgraph").LastValue<boolean>;
+        (annotation: import("@langchain/langgraph").SingleReducer<boolean, boolean>): import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    validationStatus: {
+        (): import("@langchain/langgraph").LastValue<"passed" | "failed">;
+        (annotation: import("@langchain/langgraph").SingleReducer<"passed" | "failed", "passed" | "failed">): import("@langchain/langgraph").BinaryOperatorAggregate<"passed" | "failed", "passed" | "failed">;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    availableNodeTypes: {
+        (): 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>;
+    };
+    revisionCount: {
+        (): import("@langchain/langgraph").LastValue<number>;
+        (annotation: import("@langchain/langgraph").SingleReducer<number, number>): import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    strategies: {
+        (): 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>;
+    };
+    candidates: import("@langchain/langgraph").BinaryOperatorAggregate<any[], any[]>;
+    customTools: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
+}>;

package/dist/agentic/state.js

@@ -0,0 +1,26 @@
+import { Annotation } from "@langchain/langgraph";
+export const TeamState = Annotation.Root({
+    userGoal: (Annotation),
+    spec: (Annotation),
+    workflowJson: (Annotation),
+    validationErrors: (Annotation),
+    messages: Annotation({
+        reducer: (x, y) => x.concat(y),
+        default: () => [],
+    }),
+    needsClarification: (Annotation),
+    validationStatus: (Annotation),
+    availableNodeTypes: (Annotation),
+    revisionCount: (Annotation),
+    // Parallel Execution Support
+    strategies: (Annotation),
+    candidates: Annotation({
+        reducer: (x, y) => x.concat(y),
+        default: () => [],
+    }),
+    // Dynamic Tools
+    customTools: Annotation({
+        reducer: (x, y) => ({ ...x, ...y }),
+        default: () => ({}),
+    }),
+});

package/dist/commands/config.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Config extends Command {
+    static description: string;
+    static flags: {
+        'n8n-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'n8n-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'ai-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'ai-provider': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'ai-model': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'ai-base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}