@lhi/n8m 0.1.1 → 0.1.2

package/dist/agentic/graph.d.ts

@@ -12,6 +12,7 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
     strategies: any[];
     candidates: any[];
     customTools: Record<string, string>;
+    collaborationLog: string[];
 }, {
     userGoal?: string | undefined;
     spec?: any;
@@ -25,6 +26,7 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
     strategies?: any[] | undefined;
     candidates?: any[] | undefined;
     customTools?: Record<string, string> | undefined;
+    collaborationLog?: string[] | undefined;
 }, "__start__" | "architect" | "engineer" | "reviewer" | "supervisor" | "qa", {
     userGoal: {
         (): import("@langchain/langgraph").LastValue<string>;
@@ -74,6 +76,7 @@ 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[]>;
 }, {
     userGoal: {
         (): import("@langchain/langgraph").LastValue<string>;
@@ -123,11 +126,13 @@ 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[]>;
 }, import("@langchain/langgraph").StateDefinition, {
     architect: {
         spec: any;
         strategies: any[];
         needsClarification: any;
+        collaborationLog: string[];
     };
     engineer: {
         workflowJson: any;
@@ -188,11 +193,14 @@ 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[]>;
     }>;
     supervisor: {
         workflowJson?: undefined;
+        collaborationLog?: undefined;
     } | {
         workflowJson: any;
+        collaborationLog: string[];
     };
     qa: import("@langchain/langgraph").UpdateType<{
         userGoal: {
@@ -243,6 +251,7 @@ 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[]>;
     }>;
 }, unknown, unknown>;
 /**
@@ -300,6 +309,7 @@ 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[]>;
 }>>;
 /**
  * Run the Agentic Workflow with Streaming
@@ -311,6 +321,7 @@ export declare const runAgenticWorkflowStream: (goal: string, threadId?: string)
         spec: any;
         strategies: any[];
         needsClarification: any;
+        collaborationLog: string[];
     } | undefined;
     engineer?: {
         workflowJson: any;
@@ -371,11 +382,14 @@ 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[]>;
     }> | undefined;
     supervisor?: {
         workflowJson?: undefined;
+        collaborationLog?: undefined;
     } | {
         workflowJson: any;
+        collaborationLog: string[];
     } | undefined;
     qa?: import("@langchain/langgraph").UpdateType<{
         userGoal: {
@@ -426,6 +440,7 @@ 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[]>;
     }> | undefined;
 }>>;
 /**
@@ -480,4 +495,5 @@ 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[]>;
 }>>;

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

@@ -3,4 +3,5 @@ export declare const architectNode: (state: typeof TeamState.State) => Promise<{
     spec: any;
     strategies: any[];
     needsClarification: any;
+    collaborationLog: string[];
 }>;

package/dist/agentic/nodes/architect.js

@@ -30,18 +30,20 @@ export const architectNode = async (state) => {
         // 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.
+        // Multi-agent collaboration: generate an alternative strategy in parallel with the primary.
+        // Both are handed off to separate Engineer agents that run concurrently.
+        const alternativeSpec = await aiService.generateAlternativeSpec(state.userGoal, spec);
         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)" } 
+            { ...spec, strategyName: "Primary Strategy" },
+            { ...alternativeSpec, strategyName: "Alternative Strategy" },
         ];
+        const logEntry = `Architect: Generated 2 strategies — "${strategies[0].suggestedName}" (primary) and "${strategies[1].suggestedName}" (alternative)`;
+        console.log(`[Architect] ${logEntry}`);
         return {
-            spec, // Keep backward compatibility for single-path
+            spec,
             strategies,
             needsClarification,
+            collaborationLog: [logEntry],
         };
     }
     catch (error) {

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

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

package/dist/agentic/nodes/supervisor.js

@@ -1,3 +1,4 @@
+import { AIService } from "../../services/ai.service.js";
 import { theme } from "../../utils/theme.js";
 export const supervisorNode = async (state) => {
     const candidates = state.candidates;
@@ -5,14 +6,15 @@ export const supervisorNode = async (state) => {
         // 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)
+    console.log(theme.agent(`Supervisor evaluating ${candidates.length} candidate(s)...`));
+    const aiService = AIService.getInstance();
+    const evaluation = await aiService.evaluateCandidates(state.userGoal, candidates);
+    const bestCandidate = candidates[evaluation.selectedIndex] ?? candidates[0];
+    const logEntry = `Supervisor: Selected candidate ${evaluation.selectedIndex + 1}/${candidates.length} ("${bestCandidate.name || 'Unnamed'}"). Reason: ${evaluation.reason}`;
+    console.log(theme.success(`Supervisor selected: ${bestCandidate.name || "Unnamed Workflow"} (candidate ${evaluation.selectedIndex + 1})`));
+    console.log(theme.agent(`  → ${evaluation.reason}`));
     return {
-        workflowJson: bestCandidate
+        workflowJson: bestCandidate,
+        collaborationLog: [logEntry],
     };
 };

package/dist/agentic/state.d.ts

@@ -48,4 +48,5 @@ 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[]>;
 }>;

package/dist/agentic/state.js

@@ -23,4 +23,9 @@ export const TeamState = Annotation.Root({
         reducer: (x, y) => ({ ...x, ...y }),
         default: () => ({}),
     }),
+    // Collaboration Log: agents record their reasoning for visibility
+    collaborationLog: Annotation({
+        reducer: (x, y) => x.concat(y),
+        default: () => [],
+    }),
 });

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

@@ -44,6 +44,19 @@ export declare class AIService {
      * Force-fix connection structure to prevent "object is not iterable" errors
      */
     private fixN8nConnections;
+    /**
+     * Generate an alternative workflow specification with a different approach to the same goal.
+     * Used by the Architect node to produce a second strategy for parallel Engineer execution.
+     */
+    generateAlternativeSpec(goal: string, primarySpec: any): Promise<any>;
+    /**
+     * Evaluate multiple workflow candidates and select the best one for the given goal.
+     * Used by the Supervisor node to choose between parallel Engineer outputs.
+     */
+    evaluateCandidates(goal: string, candidates: any[]): Promise<{
+        selectedIndex: number;
+        reason: string;
+    }>;
     /**
      * Validate against real node types and shim unknown ones
      */

package/dist/services/ai.service.js

@@ -370,6 +370,89 @@ export class AIService {
         workflow.connections = fixedConnections;
         return workflow;
     }
+    /**
+     * Generate an alternative workflow specification with a different approach to the same goal.
+     * Used by the Architect node to produce a second strategy for parallel Engineer execution.
+     */
+    async generateAlternativeSpec(goal, primarySpec) {
+        const prompt = `You are an n8n Solutions Architect exploring alternative workflow designs.
+
+A primary solution already exists for this goal. Your task is to design a DIFFERENT approach that achieves the same result.
+
+Goal: ${goal}
+
+Primary Specification (for reference — design something DIFFERENT):
+${JSON.stringify(primarySpec, null, 2)}
+
+Create an alternative approach that:
+- Uses DIFFERENT n8n nodes or integrations where possible
+- May take a simpler, more minimal path OR a more robust, comprehensive one
+- Achieves the SAME end goal
+
+Output ONLY valid JSON with this structure:
+{
+  "goal": "...",
+  "suggestedName": "...",
+  "tasks": [...],
+  "nodes": [...],
+  "assumptions": [...],
+  "questions": [],
+  "strategyType": "alternative"
+}`;
+        const response = await this.generateContent(prompt, { temperature: 0.9 });
+        let cleanJson = response || '{}';
+        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            return JSON.parse(cleanJson);
+        }
+        catch {
+            console.warn('[AIService] Failed to parse alternative spec, falling back to primary variant');
+            return { ...primarySpec, suggestedName: `${primarySpec.suggestedName} (Alt)`, strategyType: 'alternative' };
+        }
+    }
+    /**
+     * Evaluate multiple workflow candidates and select the best one for the given goal.
+     * Used by the Supervisor node to choose between parallel Engineer outputs.
+     */
+    async evaluateCandidates(goal, candidates) {
+        if (candidates.length <= 1) {
+            return { selectedIndex: 0, reason: 'Single candidate — no evaluation needed.' };
+        }
+        const candidateSummaries = candidates.map((c, i) => {
+            const nodeNames = c?.nodes?.map((n) => n.name || n.type).join(', ') || 'unknown nodes';
+            return `Candidate ${i + 1}: "${c?.name || 'Unnamed'}" — Nodes: [${nodeNames}]`;
+        }).join('\n');
+        const prompt = `You are an n8n Solutions Architect evaluating workflow implementations.
+
+Goal: ${goal}
+
+Evaluate these ${candidates.length} candidate workflows and select the BEST one:
+${candidateSummaries}
+
+Select the best candidate based on:
+1. Completeness — does it fully achieve the goal?
+2. Node quality — are the nodes standard and appropriate?
+3. Simplicity — is it appropriately complex (not over-engineered)?
+4. Data flow — is the logic sound?
+
+Output ONLY valid JSON:
+{ "selectedIndex": <0-based integer>, "reason": "<1-2 sentence explanation>" }`;
+        const response = await this.generateContent(prompt, { temperature: 0.3 });
+        let cleanJson = response || '{}';
+        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            const result = JSON.parse(cleanJson);
+            const idx = typeof result.selectedIndex === 'number' ? result.selectedIndex : 0;
+            return {
+                selectedIndex: Math.max(0, Math.min(idx, candidates.length - 1)),
+                reason: result.reason || 'Best overall candidate.',
+            };
+        }
+        catch {
+            console.warn('[AIService] Failed to parse candidate evaluation, defaulting to index 0');
+            return { selectedIndex: 0, reason: 'Evaluation failed, defaulting to first candidate.' };
+        }
+    }
     /**
      * Validate against real node types and shim unknown ones
      */

package/oclif.manifest.json

@@ -327,5 +327,5 @@
       ]
     }
   },
-  "version": "0.1.1"
+  "version": "0.1.2"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lhi/n8m",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Agentic n8n CLI wrapper - A Skill Bridge for n8n workflow automation",
   "author": "Lem Canady",
   "license": "MIT",