blokctl 0.2.0

package/dist/commands/generate/TriggerGenerator.js

@@ -0,0 +1,220 @@
+import * as fs from "node:fs";
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText } from "ai";
+import { GenerationAnalytics } from "./GenerationAnalytics.js";
+import { getVersionStamp, registerPromptContent } from "./PromptVersioning.js";
+import createTriggerSystemPrompt from "./prompts/create-trigger.system.js";
+import * as CompilationValidator from "./validators/CompilationValidator.js";
+export default class TriggerGenerator {
+    MAX_VALIDATION_ATTEMPTS = 3;
+    async generateTrigger(triggerName, triggerType, userPrompt, apiKey, update = false, existingTriggerPath) {
+        const analytics = GenerationAnalytics.getInstance();
+        const getElapsed = analytics.startTimer();
+        const promptVersion = getVersionStamp("create-trigger");
+        const openai = createOpenAI({
+            compatibility: "strict",
+            apiKey: apiKey,
+        });
+        let prompt = createTriggerSystemPrompt.prompt;
+        registerPromptContent("create-trigger", prompt);
+        if (update && existingTriggerPath) {
+            const existingContent = fs.readFileSync(existingTriggerPath, "utf8");
+            prompt = `${createTriggerSystemPrompt.updatePrompt}\n\n${existingContent}`;
+        }
+        const enhancedPrompt = this.buildEnhancedPrompt(userPrompt, triggerType, triggerName);
+        let attempts = 0;
+        let generatedCode = "";
+        let validationErrors = [];
+        let validationWarnings = [];
+        let isValid = false;
+        const allErrors = [];
+        while (attempts < this.MAX_VALIDATION_ATTEMPTS && !isValid) {
+            attempts++;
+            let finalPrompt = enhancedPrompt;
+            if (attempts > 1 && validationErrors.length > 0) {
+                finalPrompt = this.createFeedbackPrompt(enhancedPrompt, generatedCode, validationErrors);
+            }
+            const { text } = await generateText({
+                model: openai("gpt-4o"),
+                system: prompt,
+                prompt: finalPrompt,
+                temperature: 0.2,
+            });
+            generatedCode = text.replace(/^```typescript\s*([\s\S]*?)\s*```$/gm, "$1").trim();
+            const compilationResult = CompilationValidator.validateCode(generatedCode, `${triggerName}-trigger.ts`);
+            validationErrors = compilationResult.errors;
+            validationWarnings = compilationResult.warnings;
+            isValid = compilationResult.success;
+            if (isValid) {
+                const structureResult = this.validateTriggerStructure(generatedCode);
+                if (!structureResult.valid) {
+                    isValid = false;
+                    validationErrors.push(...structureResult.errors);
+                    validationWarnings.push(...structureResult.warnings);
+                }
+            }
+            allErrors.push(...validationErrors);
+            if (!isValid && attempts < this.MAX_VALIDATION_ATTEMPTS) {
+                console.log(`⚠️  Trigger validation failed (attempt ${attempts}/${this.MAX_VALIDATION_ATTEMPTS}). Retrying with feedback...`);
+            }
+        }
+        const durationMs = getElapsed();
+        analytics.recordEvent({
+            type: "trigger",
+            subtype: triggerType,
+            name: triggerName,
+            success: isValid,
+            attempts,
+            durationMs,
+            errors: allErrors,
+            promptVersion,
+        });
+        return {
+            triggerName,
+            triggerType,
+            userPrompt,
+            code: generatedCode,
+            validationResult: {
+                valid: isValid,
+                errors: validationErrors,
+                warnings: validationWarnings,
+                attempts,
+                promptVersion,
+                durationMs,
+            },
+        };
+    }
+    validateTriggerStructure(code) {
+        const errors = [];
+        const warnings = [];
+        if (!code.includes("extends TriggerBase") && !code.includes("extends") && !code.includes("TriggerBase")) {
+            errors.push("Trigger must extend TriggerBase");
+        }
+        if (!code.includes("TriggerBase") && !code.includes("@blok/runner")) {
+            errors.push("Missing TriggerBase import from @blok/runner");
+        }
+        if (!code.includes("loadNodes")) {
+            errors.push("Missing loadNodes() method");
+        }
+        if (!code.includes("loadWorkflows")) {
+            errors.push("Missing loadWorkflows() method");
+        }
+        if (!code.includes("createContext")) {
+            errors.push("Must use this.createContext() to create workflow context");
+        }
+        if (!code.includes(".request") ||
+            (!code.includes("ctx.request") && !code.includes("context.request") && !code.includes(".request ="))) {
+            warnings.push("Should populate ctx.request with event data");
+        }
+        if (!code.includes("export default")) {
+            warnings.push("Consider exporting the trigger class as default");
+        }
+        if (code.includes("constructor") && !code.includes("super()")) {
+            errors.push("Constructor must call super()");
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    buildEnhancedPrompt(userPrompt, triggerType, triggerName) {
+        const parts = [
+            `Create a trigger named "${triggerName}" of type "${triggerType}" with the following requirements:`,
+            "",
+            userPrompt,
+            "",
+            `IMPORTANT: This trigger MUST handle the "${triggerType}" trigger type.`,
+        ];
+        switch (triggerType) {
+            case "queue":
+                parts.push("The trigger should connect to a message queue broker (Kafka, RabbitMQ, SQS, or Redis/BullMQ).");
+                parts.push("It should consume messages, match them to workflows, create context, and execute workflows.");
+                parts.push("Include proper ack/nack handling and dead letter queue support.");
+                break;
+            case "pubsub":
+                parts.push("The trigger should connect to a pub/sub provider (GCP, AWS SNS, or Azure Service Bus).");
+                parts.push("It should subscribe to topics, receive messages, and execute matching workflows.");
+                parts.push("Include proper acknowledgment and message filtering.");
+                break;
+            case "cron":
+                parts.push("The trigger should schedule recurring jobs using cron expressions.");
+                parts.push("Include timezone support, overlap prevention, and manual trigger capability.");
+                break;
+            case "webhook":
+                parts.push("The trigger should expose HTTP endpoints for receiving webhook events.");
+                parts.push("Include signature verification for common providers (GitHub, Stripe, Shopify).");
+                parts.push("Support event type filtering with wildcards.");
+                break;
+            case "websocket":
+                parts.push("The trigger should create a WebSocket server for real-time bidirectional communication.");
+                parts.push("Include room/channel management, connection tracking, and authentication middleware.");
+                break;
+            case "sse":
+                parts.push("The trigger should create SSE (Server-Sent Events) endpoints.");
+                parts.push("Include channel management, event formatting, Last-Event-ID replay support, and heartbeat.");
+                break;
+            default:
+                parts.push(`Implement a custom trigger for the "${triggerType}" event source.`);
+                break;
+        }
+        return parts.join("\n");
+    }
+    createFeedbackPrompt(originalPrompt, previousCode, errors) {
+        const analyzedErrors = errors.map((err, i) => {
+            const guidance = this.getSemanticGuidance(err);
+            return `${i + 1}. ${err}${guidance ? `\n   Fix: ${guidance}` : ""}`;
+        });
+        const feedback = [
+            originalPrompt,
+            "",
+            "❌ The previous generation had validation errors. Here's what went wrong and how to fix it:",
+            "",
+            ...analyzedErrors,
+            "",
+            "Previous code:",
+            "```typescript",
+            previousCode,
+            "```",
+            "",
+            "Please fix ALL the errors listed above and regenerate the complete trigger code.",
+            "Make sure to:",
+            "- Extend TriggerBase from @blok/runner",
+            "- Include loadNodes() and loadWorkflows() methods",
+            "- Use this.createContext() to create Context objects",
+            "- Call super() in the constructor",
+            "- Populate ctx.request with event data before executing workflows",
+            "- Export the class as default: export default class <Name>Trigger extends TriggerBase",
+            "- Use Object.keys(workflowModel.trigger) to extract trigger config",
+        ].join("\n");
+        return feedback;
+    }
+    getSemanticGuidance(error) {
+        const errorLower = error.toLowerCase();
+        if (errorLower.includes("triggerbase") && (errorLower.includes("extend") || errorLower.includes("missing"))) {
+            return "import { TriggerBase } from '@blok/runner'; class MyTrigger extends TriggerBase { ... }";
+        }
+        if (errorLower.includes("loadnodes") && errorLower.includes("missing")) {
+            return "Add: private loadNodes(): void { this.nodeMap.nodes = new NodeMap(); ... }";
+        }
+        if (errorLower.includes("loadworkflows") && errorLower.includes("missing")) {
+            return "Add: private loadWorkflows(): void { this.nodeMap.workflows = workflows; }";
+        }
+        if (errorLower.includes("createcontext")) {
+            return "Use this.createContext(undefined, workflowModel.path) to create context for each workflow execution";
+        }
+        if (errorLower.includes("super()")) {
+            return "Add super(); as the first line in constructor()";
+        }
+        if (errorLower.includes("ctx.request") || errorLower.includes("event data")) {
+            return "Set ctx.request = { body: messageData, headers: {}, query: {}, params: {} } before executing workflow";
+        }
+        if (errorLower.includes("cannot find module") || errorLower.includes("module not found")) {
+            return "Use '@blok/runner' for TriggerBase, Runner, NodeMap and '@blok/shared' for Context, DefaultLogger";
+        }
+        if (errorLower.includes("export") && errorLower.includes("default")) {
+            return "Use: export default class <Name>Trigger extends TriggerBase { ... }";
+        }
+        return null;
+    }
+}

package/dist/commands/generate/TriggerGenerator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate/TriggerGenerator.test.js

@@ -0,0 +1,209 @@
+import { describe, expect, it } from "vitest";
+import TriggerGenerator from "./TriggerGenerator.js";
+describe("TriggerGenerator", () => {
+    describe("validateTriggerStructure (via reflection)", () => {
+        const generator = new TriggerGenerator();
+        const validate = (code) => generator.validateTriggerStructure(code);
+        it("should pass for valid trigger code", () => {
+            const validCode = `
+import TriggerBase from "@blok/runner/TriggerBase";
+import { NodeMap } from "@blok/runner";
+
+export default class MyTrigger extends TriggerBase {
+  constructor() {
+    super();
+    this.loadNodes();
+    this.loadWorkflows();
+  }
+
+  private loadNodes() {
+    // load nodes
+  }
+
+  private loadWorkflows() {
+    // load workflows
+  }
+
+  async start() {
+    const ctx = this.createContext();
+    ctx.request = { body: {} };
+  }
+}
+      `;
+            const result = validate(validCode);
+            expect(result.valid).toBe(true);
+            expect(result.errors.length).toBe(0);
+        });
+        it("should fail for trigger not extending TriggerBase", () => {
+            const code = `
+export default class MyTrigger {
+  constructor() {
+    this.loadNodes();
+    this.loadWorkflows();
+  }
+
+  private loadNodes() {}
+  private loadWorkflows() {}
+
+  async start() {
+    const ctx = this.createContext();
+  }
+}
+      `;
+            const result = validate(code);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("TriggerBase"))).toBe(true);
+        });
+        it("should fail for trigger missing loadNodes", () => {
+            const code = `
+import TriggerBase from "@blok/runner/TriggerBase";
+
+export default class MyTrigger extends TriggerBase {
+  constructor() {
+    super();
+    this.loadWorkflows();
+  }
+
+  private loadWorkflows() {}
+
+  async start() {
+    const ctx = this.createContext();
+  }
+}
+      `;
+            const result = validate(code);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("loadNodes"))).toBe(true);
+        });
+        it("should fail for trigger missing loadWorkflows", () => {
+            const code = `
+import TriggerBase from "@blok/runner/TriggerBase";
+
+export default class MyTrigger extends TriggerBase {
+  constructor() {
+    super();
+    this.loadNodes();
+  }
+
+  private loadNodes() {}
+
+  async start() {
+    const ctx = this.createContext();
+  }
+}
+      `;
+            const result = validate(code);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("loadWorkflows"))).toBe(true);
+        });
+        it("should fail for trigger missing createContext", () => {
+            const code = `
+import TriggerBase from "@blok/runner/TriggerBase";
+
+export default class MyTrigger extends TriggerBase {
+  constructor() {
+    super();
+    this.loadNodes();
+    this.loadWorkflows();
+  }
+
+  private loadNodes() {}
+  private loadWorkflows() {}
+
+  async start() {
+    // does not build context
+  }
+}
+      `;
+            const result = validate(code);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("createContext"))).toBe(true);
+        });
+        it("should fail for constructor without super()", () => {
+            const code = `
+import TriggerBase from "@blok/runner/TriggerBase";
+
+export default class MyTrigger extends TriggerBase {
+  constructor() {
+    this.loadNodes();
+    this.loadWorkflows();
+  }
+
+  private loadNodes() {}
+  private loadWorkflows() {}
+
+  async start() {
+    const ctx = this.createContext();
+  }
+}
+      `;
+            const result = validate(code);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("super()"))).toBe(true);
+        });
+        it("should warn when request data is not populated on context", () => {
+            const code = `
+import TriggerBase from "@blok/runner/TriggerBase";
+
+export default class MyTrigger extends TriggerBase {
+  constructor() {
+    super();
+    this.loadNodes();
+    this.loadWorkflows();
+  }
+
+  private loadNodes() {}
+  private loadWorkflows() {}
+
+  async start() {
+    const c = this.createContext();
+    // does not set request data
+  }
+}
+      `;
+            const result = validate(code);
+            expect(result.valid).toBe(true);
+            expect(result.warnings.some((w) => w.includes("ctx.request") || w.includes("event data"))).toBe(true);
+        });
+    });
+    describe("buildEnhancedPrompt (via reflection)", () => {
+        const generator = new TriggerGenerator();
+        const buildPrompt = (userPrompt, triggerType, triggerName) => generator.buildEnhancedPrompt(userPrompt, triggerType, triggerName);
+        it("should include trigger type in prompt", () => {
+            const result = buildPrompt("Process user events", "queue", "user-queue");
+            expect(result).toContain("queue");
+            expect(result).toContain("user-queue");
+            expect(result).toContain("Process user events");
+        });
+        it("should include queue-specific guidance for queue type", () => {
+            const result = buildPrompt("Process messages", "queue", "my-queue");
+            expect(result).toContain("message queue broker");
+            expect(result).toContain("ack/nack");
+        });
+        it("should include pubsub-specific guidance for pubsub type", () => {
+            const result = buildPrompt("Process events", "pubsub", "my-pubsub");
+            expect(result).toContain("pub/sub provider");
+        });
+        it("should include cron-specific guidance for cron type", () => {
+            const result = buildPrompt("Run daily", "cron", "daily-job");
+            expect(result).toContain("cron expressions");
+            expect(result).toContain("timezone");
+        });
+        it("should include webhook-specific guidance for webhook type", () => {
+            const result = buildPrompt("Handle webhooks", "webhook", "github-webhook");
+            expect(result).toContain("signature verification");
+        });
+        it("should include websocket-specific guidance for websocket type", () => {
+            const result = buildPrompt("Real-time chat", "websocket", "chat-ws");
+            expect(result).toContain("WebSocket server");
+        });
+        it("should include sse-specific guidance for sse type", () => {
+            const result = buildPrompt("Stream events", "sse", "event-stream");
+            expect(result).toContain("SSE");
+        });
+        it("should handle custom trigger types", () => {
+            const result = buildPrompt("Custom trigger", "custom", "my-custom");
+            expect(result).toContain("custom");
+        });
+    });
+});

package/dist/commands/generate/WorkflowGenerator.d.ts

@@ -0,0 +1,20 @@
+export type WorkflowInformation = {
+    workflowName: string;
+    userPrompt: string;
+    json: string;
+    triggerType: string;
+    validationResult?: {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+        attempts: number;
+        promptVersion?: string;
+        durationMs?: number;
+    };
+};
+export default class WorkflowGenerator {
+    private readonly MAX_VALIDATION_ATTEMPTS;
+    generateWorkflow(workflowName: string, userPrompt: string, apiKey: string, triggerType: string, update?: boolean, existingWorkflowPath?: string): Promise<WorkflowInformation>;
+    private buildEnhancedPrompt;
+    private createFeedbackPrompt;
+}

package/dist/commands/generate/WorkflowGenerator.js

@@ -0,0 +1,131 @@
+import * as fs from "node:fs";
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText } from "ai";
+import { GenerationAnalytics } from "./GenerationAnalytics.js";
+import { getVersionStamp, registerPromptContent } from "./PromptVersioning.js";
+import createWorkflowSystemPrompt from "./prompts/create-workflow.system.js";
+import * as WorkflowValidator from "./validators/WorkflowValidator.js";
+export default class WorkflowGenerator {
+    MAX_VALIDATION_ATTEMPTS = 3;
+    async generateWorkflow(workflowName, userPrompt, apiKey, triggerType, update = false, existingWorkflowPath) {
+        const analytics = GenerationAnalytics.getInstance();
+        const getElapsed = analytics.startTimer();
+        const promptVersion = getVersionStamp("create-workflow");
+        const openai = createOpenAI({
+            compatibility: "strict",
+            apiKey: apiKey,
+        });
+        let prompt = createWorkflowSystemPrompt.prompt;
+        registerPromptContent("create-workflow", prompt);
+        if (update && existingWorkflowPath) {
+            const existingContent = fs.readFileSync(existingWorkflowPath, "utf8");
+            prompt = `${createWorkflowSystemPrompt.updatePrompt}\n\n${existingContent}`;
+        }
+        const enhancedPrompt = this.buildEnhancedPrompt(userPrompt, triggerType, workflowName);
+        let attempts = 0;
+        let generatedJson = "";
+        let validationErrors = [];
+        let validationWarnings = [];
+        let isValid = false;
+        const allErrors = [];
+        while (attempts < this.MAX_VALIDATION_ATTEMPTS && !isValid) {
+            attempts++;
+            let finalPrompt = enhancedPrompt;
+            if (attempts > 1 && validationErrors.length > 0) {
+                finalPrompt = this.createFeedbackPrompt(enhancedPrompt, generatedJson, validationErrors);
+            }
+            const { text } = await generateText({
+                model: openai("gpt-4o"),
+                system: prompt,
+                prompt: finalPrompt,
+                temperature: 0.2,
+            });
+            generatedJson = text.replace(/^```json\s*([\s\S]*?)\s*```$/gm, "$1").trim();
+            const result = WorkflowValidator.validateWorkflow(generatedJson);
+            validationErrors = result.errors;
+            validationWarnings = result.warnings;
+            isValid = result.valid;
+            allErrors.push(...validationErrors);
+            if (!isValid && attempts < this.MAX_VALIDATION_ATTEMPTS) {
+                console.log(`⚠️  Workflow validation failed (attempt ${attempts}/${this.MAX_VALIDATION_ATTEMPTS}). Retrying with feedback...`);
+            }
+        }
+        const durationMs = getElapsed();
+        analytics.recordEvent({
+            type: "workflow",
+            subtype: triggerType,
+            name: workflowName,
+            success: isValid,
+            attempts,
+            durationMs,
+            errors: allErrors,
+            promptVersion,
+        });
+        return {
+            workflowName,
+            userPrompt,
+            json: generatedJson,
+            triggerType,
+            validationResult: {
+                valid: isValid,
+                errors: validationErrors,
+                warnings: validationWarnings,
+                attempts,
+                promptVersion,
+                durationMs,
+            },
+        };
+    }
+    buildEnhancedPrompt(userPrompt, triggerType, workflowName) {
+        const parts = [`Create a workflow named "${workflowName}" with the following requirements:`, "", userPrompt];
+        if (triggerType && triggerType !== "auto") {
+            parts.push("");
+            parts.push(`IMPORTANT: This workflow MUST use the "${triggerType}" trigger type.`);
+            switch (triggerType) {
+                case "http":
+                    parts.push("Configure the HTTP trigger with appropriate method, path, and accept settings.");
+                    break;
+                case "queue":
+                    parts.push("Configure the queue trigger with appropriate provider, topic, and consumer group settings.");
+                    break;
+                case "pubsub":
+                    parts.push("Configure the pub/sub trigger with appropriate provider, topic, and subscription settings.");
+                    break;
+                case "cron":
+                    parts.push("Configure the cron trigger with appropriate schedule expression and timezone.");
+                    break;
+                case "webhook":
+                    parts.push("Configure the webhook trigger with appropriate source, events, and optional secret.");
+                    break;
+                case "websocket":
+                    parts.push("Configure the WebSocket trigger with appropriate events and connection settings.");
+                    break;
+                case "sse":
+                    parts.push("Configure the SSE trigger with appropriate events and channel settings.");
+                    break;
+            }
+        }
+        return parts.join("\n");
+    }
+    createFeedbackPrompt(originalPrompt, previousJson, errors) {
+        const feedback = [
+            originalPrompt,
+            "",
+            "❌ The previous generation had validation errors:",
+            ...errors.map((err, i) => `${i + 1}. ${err}`),
+            "",
+            "Previous workflow JSON:",
+            "```json",
+            previousJson,
+            "```",
+            "",
+            "Please fix these errors and regenerate the workflow JSON. Common fixes:",
+            "- Ensure every step name has a matching entry in the nodes object",
+            "- Ensure the trigger has exactly one trigger type with valid configuration",
+            "- Ensure condition expressions use ctx.* properties",
+            "- Ensure all conditional branches have name, node, and type fields",
+            "- Add an else branch to conditional routing for error handling",
+        ].join("\n");
+        return feedback;
+    }
+}

package/dist/commands/generate/WorkflowGenerator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate/WorkflowGenerator.test.js

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import WorkflowGenerator from "./WorkflowGenerator.js";
+describe("WorkflowGenerator", () => {
+    describe("buildEnhancedPrompt (via reflection)", () => {
+        const generator = new WorkflowGenerator();
+        const buildPrompt = (userPrompt, triggerType, workflowName) => generator.buildEnhancedPrompt(userPrompt, triggerType, workflowName);
+        it("should include workflow name and user prompt", () => {
+            const result = buildPrompt("Fetch user data from API", "http", "user-api");
+            expect(result).toContain("user-api");
+            expect(result).toContain("Fetch user data from API");
+        });
+        it("should include http trigger guidance for http type", () => {
+            const result = buildPrompt("Handle REST requests", "http", "rest-api");
+            expect(result).toContain("http");
+            expect(result).toContain("HTTP trigger");
+        });
+        it("should include queue trigger guidance for queue type", () => {
+            const result = buildPrompt("Process messages", "queue", "message-processor");
+            expect(result).toContain("queue");
+            expect(result).toContain("queue trigger");
+        });
+        it("should include pubsub trigger guidance for pubsub type", () => {
+            const result = buildPrompt("Process events", "pubsub", "event-handler");
+            expect(result).toContain("pubsub");
+            expect(result).toContain("pub/sub trigger");
+        });
+        it("should include cron trigger guidance for cron type", () => {
+            const result = buildPrompt("Run hourly job", "cron", "hourly-job");
+            expect(result).toContain("cron");
+            expect(result).toContain("cron trigger");
+        });
+        it("should include webhook trigger guidance for webhook type", () => {
+            const result = buildPrompt("Handle GitHub events", "webhook", "github-handler");
+            expect(result).toContain("webhook");
+            expect(result).toContain("webhook trigger");
+        });
+        it("should include websocket trigger guidance for websocket type", () => {
+            const result = buildPrompt("Real-time updates", "websocket", "realtime");
+            expect(result).toContain("websocket");
+            expect(result).toContain("WebSocket trigger");
+        });
+        it("should include sse trigger guidance for sse type", () => {
+            const result = buildPrompt("Stream updates", "sse", "event-stream");
+            expect(result).toContain("sse");
+            expect(result).toContain("SSE trigger");
+        });
+        it("should skip trigger-specific guidance for auto type", () => {
+            const result = buildPrompt("Do something", "auto", "auto-workflow");
+            expect(result).not.toContain("MUST use the");
+        });
+    });
+    describe("createFeedbackPrompt (via reflection)", () => {
+        const generator = new WorkflowGenerator();
+        const createFeedback = (originalPrompt, previousJson, errors) => generator.createFeedbackPrompt(originalPrompt, previousJson, errors);
+        it("should include original prompt in feedback", () => {
+            const result = createFeedback("Build a user API", "{}", ["Missing name field"]);
+            expect(result).toContain("Build a user API");
+        });
+        it("should include all validation errors", () => {
+            const errors = ["Missing name field", "Invalid trigger type", "Step has no matching node"];
+            const result = createFeedback("Test", "{}", errors);
+            for (const error of errors) {
+                expect(result).toContain(error);
+            }
+        });
+        it("should include previous JSON for reference", () => {
+            const previousJson = '{"name": "test", "version": "1.0.0"}';
+            const result = createFeedback("Test", previousJson, ["Error"]);
+            expect(result).toContain(previousJson);
+        });
+        it("should include common fix suggestions", () => {
+            const result = createFeedback("Test", "{}", ["Missing node entry"]);
+            expect(result).toContain("step name has a matching entry");
+            expect(result).toContain("else branch");
+        });
+    });
+});

package/dist/commands/generate/e2e/NodeGenerator.e2e.test.d.ts

@@ -0,0 +1 @@
+export {};