blokctl 0.2.0

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

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

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

@@ -0,0 +1,295 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("ai", () => ({
+    generateText: vi.fn(),
+}));
+vi.mock("@ai-sdk/openai", () => ({
+    createOpenAI: vi.fn(() => (model) => ({ model })),
+}));
+vi.mock("../validators/CompilationValidator.js", () => ({
+    validateCode: vi.fn(),
+}));
+import { generateText } from "ai";
+import TriggerGenerator from "../TriggerGenerator.js";
+import * as CompilationValidator from "../validators/CompilationValidator.js";
+const mockedGenerateText = vi.mocked(generateText);
+const mockedValidateCode = vi.mocked(CompilationValidator.validateCode);
+const VALID_QUEUE_TRIGGER = `
+import { TriggerBase, type GlobalOptions, NodeMap, Runner } from "@blok/runner";
+import { type Context, DefaultLogger } from "@blok/shared";
+
+export default class KafkaQueueTrigger extends TriggerBase {
+	private nodeMap: GlobalOptions = <GlobalOptions>{};
+
+	constructor() {
+		super();
+		this.loadNodes();
+		this.loadWorkflows();
+	}
+
+	private loadNodes(): void {
+		this.nodeMap.nodes = new NodeMap();
+	}
+
+	private loadWorkflows(): void {
+		this.nodeMap.workflows = [];
+	}
+
+	async startConsumer(): Promise<void> {
+		const ctx = this.createContext();
+		ctx.request = { body: {}, headers: {} };
+	}
+}
+`;
+const VALID_CRON_TRIGGER = `
+import { TriggerBase, type GlobalOptions, NodeMap } from "@blok/runner";
+
+export default class DailyCronTrigger extends TriggerBase {
+	private nodeMap: GlobalOptions = <GlobalOptions>{};
+
+	constructor() {
+		super();
+		this.loadNodes();
+		this.loadWorkflows();
+	}
+
+	private loadNodes(): void {}
+	private loadWorkflows(): void {}
+
+	async startScheduler(): Promise<void> {
+		const ctx = this.createContext();
+		ctx.request = { body: { scheduledTime: new Date().toISOString() } };
+	}
+}
+`;
+const VALID_WEBHOOK_TRIGGER = `
+import { TriggerBase, type GlobalOptions, NodeMap } from "@blok/runner";
+
+export default class GitHubWebhookTrigger extends TriggerBase {
+	private nodeMap: GlobalOptions = <GlobalOptions>{};
+
+	constructor() {
+		super();
+		this.loadNodes();
+		this.loadWorkflows();
+	}
+
+	private loadNodes(): void {}
+	private loadWorkflows(): void {}
+
+	async listen(): Promise<void> {
+		const ctx = this.createContext();
+		ctx.request = { body: {}, headers: { "x-github-event": "push" }, method: "POST" };
+	}
+}
+`;
+const INVALID_TRIGGER_NO_BASE = `
+export default class BrokenTrigger {
+	constructor() {
+		this.loadNodes();
+		this.loadWorkflows();
+	}
+
+	private loadNodes() {}
+	private loadWorkflows() {}
+
+	async start() {
+		const ctx = this.createContext();
+	}
+}
+`;
+const INVALID_TRIGGER_NO_METHODS = `
+import { TriggerBase } from "@blok/runner";
+
+export default class MinimalTrigger extends TriggerBase {
+	constructor() {
+		super();
+	}
+
+	async start() {
+		const ctx = this.createContext();
+		ctx.request = { body: {} };
+	}
+}
+`;
+const INVALID_TRIGGER_NO_CONTEXT = `
+import { TriggerBase } from "@blok/runner";
+
+export default class NoContextTrigger extends TriggerBase {
+	constructor() {
+		super();
+		this.loadNodes();
+		this.loadWorkflows();
+	}
+
+	private loadNodes() {}
+	private loadWorkflows() {}
+
+	async start() {
+		console.log("Started without context");
+	}
+}
+`;
+describe("TriggerGenerator E2E", () => {
+    let generator;
+    beforeEach(() => {
+        generator = new TriggerGenerator();
+        vi.clearAllMocks();
+        vi.spyOn(console, "log").mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe("successful generation - queue trigger", () => {
+        it("should generate a valid queue trigger on first attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("kafka-queue", "queue", "Create a Kafka queue trigger that consumes user events", "test-api-key");
+            expect(result.triggerName).toBe("kafka-queue");
+            expect(result.triggerType).toBe("queue");
+            expect(result.validationResult).toBeDefined();
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(1);
+            expect(mockedGenerateText).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("successful generation - cron trigger", () => {
+        it("should generate a valid cron trigger on first attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_CRON_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("daily-cron", "cron", "Create a daily cron trigger", "test-api-key");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(1);
+            expect(result.code).toContain("DailyCronTrigger");
+        });
+    });
+    describe("successful generation - webhook trigger", () => {
+        it("should generate a valid webhook trigger on first attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_WEBHOOK_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("github-webhook", "webhook", "Create a GitHub webhook trigger", "test-api-key");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.code).toContain("GitHubWebhookTrigger");
+        });
+    });
+    describe("trigger-specific prompt guidance", () => {
+        it("should include queue-specific guidance in prompt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            await generator.generateTrigger("kafka-trigger", "queue", "Process messages", "test-api-key");
+            const callArgs = mockedGenerateText.mock.calls[0][0];
+            const prompt = callArgs.prompt;
+            expect(prompt).toContain("message queue broker");
+            expect(prompt).toContain("ack/nack");
+        });
+        it("should include cron-specific guidance in prompt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_CRON_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            await generator.generateTrigger("cron-trigger", "cron", "Run daily", "test-api-key");
+            const callArgs = mockedGenerateText.mock.calls[0][0];
+            const prompt = callArgs.prompt;
+            expect(prompt).toContain("cron expressions");
+            expect(prompt).toContain("timezone");
+        });
+        it("should include webhook-specific guidance in prompt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_WEBHOOK_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            await generator.generateTrigger("webhook-trigger", "webhook", "Handle webhooks", "test-api-key");
+            const callArgs = mockedGenerateText.mock.calls[0][0];
+            const prompt = callArgs.prompt;
+            expect(prompt).toContain("signature verification");
+        });
+    });
+    describe("validation feedback loop", () => {
+        it("should retry when trigger fails compilation", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: INVALID_TRIGGER_NO_BASE });
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValueOnce({ success: false, errors: ["Syntax error"], warnings: [] });
+            mockedValidateCode.mockReturnValueOnce({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("kafka-queue", "queue", "Create a queue trigger", "test-api-key");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(2);
+            expect(mockedGenerateText).toHaveBeenCalledTimes(2);
+        });
+        it("should retry when trigger fails structural validation", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: INVALID_TRIGGER_NO_CONTEXT });
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValueOnce({ success: true, errors: [], warnings: [] });
+            mockedValidateCode.mockReturnValueOnce({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("kafka-queue", "queue", "Create a queue trigger", "test-api-key");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(2);
+        });
+        it("should include errors in feedback prompt on retry", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: INVALID_TRIGGER_NO_BASE });
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValueOnce({ success: false, errors: ["Missing TriggerBase import"], warnings: [] });
+            mockedValidateCode.mockReturnValueOnce({ success: true, errors: [], warnings: [] });
+            await generator.generateTrigger("kafka-queue", "queue", "Create a queue trigger", "test-api-key");
+            const secondCallArgs = mockedGenerateText.mock.calls[1][0];
+            const prompt = secondCallArgs.prompt;
+            expect(prompt).toContain("validation errors");
+            expect(prompt).toContain("Missing TriggerBase import");
+        });
+        it("should exhaust all 3 attempts when trigger keeps failing", async () => {
+            mockedGenerateText.mockResolvedValue({ text: INVALID_TRIGGER_NO_CONTEXT });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("broken-trigger", "queue", "Create a broken trigger", "test-api-key");
+            expect(result.validationResult.valid).toBe(false);
+            expect(result.validationResult.attempts).toBe(3);
+            expect(mockedGenerateText).toHaveBeenCalledTimes(3);
+        });
+        it("should succeed on third attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: INVALID_TRIGGER_NO_BASE });
+            mockedGenerateText.mockResolvedValueOnce({ text: INVALID_TRIGGER_NO_METHODS });
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValueOnce({ success: false, errors: ["Missing base class"], warnings: [] });
+            mockedValidateCode.mockReturnValueOnce({ success: false, errors: ["Missing methods"], warnings: [] });
+            mockedValidateCode.mockReturnValueOnce({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("kafka-queue", "queue", "Create a queue trigger", "test-api-key");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(3);
+        });
+    });
+    describe("markdown fence cleanup", () => {
+        it("should strip markdown TypeScript fences from LLM response", async () => {
+            const wrappedCode = "```typescript\n" + VALID_QUEUE_TRIGGER + "\n```";
+            mockedGenerateText.mockResolvedValueOnce({ text: wrappedCode });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("kafka-queue", "queue", "Create a queue trigger", "test-api-key");
+            expect(result.code).not.toContain("```");
+        });
+    });
+    describe("temperature and model configuration", () => {
+        it("should use temperature 0.2 for deterministic output", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            await generator.generateTrigger("test-trigger", "queue", "Create a test trigger", "test-api-key");
+            const callArgs = mockedGenerateText.mock.calls[0][0];
+            expect(callArgs.temperature).toBe(0.2);
+        });
+        it("should use the trigger system prompt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            await generator.generateTrigger("test-trigger", "queue", "Create a test trigger", "test-api-key");
+            const callArgs = mockedGenerateText.mock.calls[0][0];
+            const system = callArgs.system;
+            expect(system).toContain("TriggerBase");
+            expect(system).toContain("createContext");
+            expect(system).toContain("loadNodes");
+        });
+    });
+    describe("analytics integration", () => {
+        it("should include prompt version in validation result", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("test-trigger", "queue", "Create a test trigger", "test-api-key");
+            expect(result.validationResult.promptVersion).toContain("create-trigger@");
+        });
+        it("should include duration in validation result", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
+            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
+            const result = await generator.generateTrigger("test-trigger", "queue", "Create a test trigger", "test-api-key");
+            expect(result.validationResult.durationMs).toBeGreaterThanOrEqual(0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,353 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("ai", () => ({
+    generateText: vi.fn(),
+}));
+vi.mock("@ai-sdk/openai", () => ({
+    createOpenAI: vi.fn(() => (model) => ({ model })),
+}));
+import { generateText } from "ai";
+import WorkflowGenerator from "../WorkflowGenerator.js";
+const mockedGenerateText = vi.mocked(generateText);
+const VALID_HTTP_WORKFLOW = JSON.stringify({
+    name: "User API",
+    description: "Fetches user data from external API",
+    version: "1.0.0",
+    trigger: {
+        http: {
+            method: "GET",
+            path: "/api/users/:id",
+            accept: "application/json",
+        },
+    },
+    steps: [
+        {
+            name: "fetch-user",
+            node: "@blok/api-call",
+            type: "module",
+        },
+    ],
+    nodes: {
+        "fetch-user": {
+            inputs: {
+                url: "https://api.example.com/users/${ctx.request.params.id}",
+                method: "GET",
+                headers: { Authorization: "Bearer ${ctx.env.API_KEY}" },
+            },
+        },
+    },
+}, null, 2);
+const VALID_QUEUE_WORKFLOW = JSON.stringify({
+    name: "Event Processor",
+    description: "Processes events from Kafka queue",
+    version: "1.0.0",
+    trigger: {
+        queue: {
+            provider: "kafka",
+            topic: "user-events",
+            consumerGroup: "event-processor",
+            ack: true,
+        },
+    },
+    steps: [
+        {
+            name: "process-event",
+            node: "event-handler",
+            type: "module",
+        },
+    ],
+    nodes: {
+        "process-event": {
+            inputs: {
+                eventType: "${ctx.request.body.type}",
+                payload: "${ctx.request.body.data}",
+            },
+        },
+    },
+}, null, 2);
+const VALID_CRON_WORKFLOW = JSON.stringify({
+    name: "Daily Report",
+    description: "Generates daily reports every morning",
+    version: "1.0.0",
+    trigger: {
+        cron: {
+            schedule: "0 8 * * *",
+            timezone: "America/New_York",
+            overlap: false,
+        },
+    },
+    steps: [
+        {
+            name: "generate-report",
+            node: "report-generator",
+            type: "module",
+        },
+    ],
+    nodes: {
+        "generate-report": {
+            inputs: {
+                format: "html",
+                recipients: ["admin@example.com"],
+            },
+        },
+    },
+}, null, 2);
+const VALID_WEBHOOK_WORKFLOW = JSON.stringify({
+    name: "GitHub Handler",
+    description: "Handles GitHub webhook events",
+    version: "1.0.0",
+    trigger: {
+        webhook: {
+            source: "github",
+            events: ["push", "pull_request.*"],
+            secret: "${process.env.GITHUB_WEBHOOK_SECRET}",
+        },
+    },
+    steps: [
+        {
+            name: "handle-event",
+            node: "github-event-handler",
+            type: "module",
+        },
+    ],
+    nodes: {
+        "handle-event": {
+            inputs: {
+                event: "${ctx.request.body}",
+                eventType: "${ctx.request.headers['x-github-event']}",
+            },
+        },
+    },
+}, null, 2);
+const INVALID_WORKFLOW_MISSING_STEPS = JSON.stringify({
+    name: "Broken Workflow",
+    version: "1.0.0",
+    trigger: { http: { method: "GET" } },
+    steps: [],
+    nodes: {},
+});
+const INVALID_WORKFLOW_BAD_TRIGGER = JSON.stringify({
+    name: "Bad Trigger Workflow",
+    version: "1.0.0",
+    trigger: { invalid_trigger: {} },
+    steps: [{ name: "step1", node: "node1", type: "module" }],
+    nodes: { step1: { inputs: {} } },
+});
+const INVALID_WORKFLOW_MISMATCHED_NODES = JSON.stringify({
+    name: "Mismatched Workflow",
+    version: "1.0.0",
+    trigger: { http: { method: "GET" } },
+    steps: [
+        { name: "step1", node: "node1", type: "module" },
+        { name: "step2", node: "node2", type: "module" },
+    ],
+    nodes: {
+        step1: { inputs: {} },
+    },
+});
+describe("WorkflowGenerator E2E", () => {
+    let generator;
+    beforeEach(() => {
+        generator = new WorkflowGenerator();
+        vi.clearAllMocks();
+        vi.spyOn(console, "log").mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe("successful generation - HTTP trigger", () => {
+        it("should generate a valid HTTP workflow on first attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({
+                text: VALID_HTTP_WORKFLOW,
+            });
+            const result = await generator.generateWorkflow("user-api", "Create an API that fetches user data", "test-api-key", "http");
+            expect(result.workflowName).toBe("user-api");
+            expect(result.triggerType).toBe("http");
+            expect(result.validationResult).toBeDefined();
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(1);
+            expect(mockedGenerateText).toHaveBeenCalledTimes(1);
+            const parsed = JSON.parse(result.json);
+            expect(parsed.name).toBe("User API");
+            expect(parsed.trigger.http).toBeDefined();
+        });
+    });
+    describe("successful generation - Queue trigger", () => {
+        it("should generate a valid queue workflow on first attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({
+                text: VALID_QUEUE_WORKFLOW,
+            });
+            const result = await generator.generateWorkflow("event-processor", "Process events from Kafka", "test-api-key", "queue");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(1);
+            const parsed = JSON.parse(result.json);
+            expect(parsed.trigger.queue.provider).toBe("kafka");
+            expect(parsed.trigger.queue.topic).toBe("user-events");
+        });
+    });
+    describe("successful generation - Cron trigger", () => {
+        it("should generate a valid cron workflow on first attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({
+                text: VALID_CRON_WORKFLOW,
+            });
+            const result = await generator.generateWorkflow("daily-report", "Generate daily reports at 8am", "test-api-key", "cron");
+            expect(result.validationResult.valid).toBe(true);
+            const parsed = JSON.parse(result.json);
+            expect(parsed.trigger.cron.schedule).toBe("0 8 * * *");
+            expect(parsed.trigger.cron.timezone).toBe("America/New_York");
+        });
+    });
+    describe("successful generation - Webhook trigger", () => {
+        it("should generate a valid webhook workflow on first attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({
+                text: VALID_WEBHOOK_WORKFLOW,
+            });
+            const result = await generator.generateWorkflow("github-handler", "Handle GitHub webhook events for push and PR", "test-api-key", "webhook");
+            expect(result.validationResult.valid).toBe(true);
+            const parsed = JSON.parse(result.json);
+            expect(parsed.trigger.webhook.source).toBe("github");
+            expect(parsed.trigger.webhook.events).toContain("push");
+        });
+    });
+    describe("markdown fence cleanup", () => {
+        it("should strip markdown JSON fences from LLM response", async () => {
+            const wrappedJson = "```json\n" + VALID_HTTP_WORKFLOW + "\n```";
+            mockedGenerateText.mockResolvedValueOnce({
+                text: wrappedJson,
+            });
+            const result = await generator.generateWorkflow("test-workflow", "Create a test workflow", "test-api-key", "http");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.json).not.toContain("```");
+        });
+    });
+    describe("validation feedback loop", () => {
+        it("should retry with feedback on first failure and succeed on second attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({
+                text: INVALID_WORKFLOW_MISSING_STEPS,
+            });
+            mockedGenerateText.mockResolvedValueOnce({
+                text: VALID_HTTP_WORKFLOW,
+            });
+            const result = await generator.generateWorkflow("user-api", "Create a user API", "test-api-key", "http");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(2);
+            expect(mockedGenerateText).toHaveBeenCalledTimes(2);
+        });
+        it("should include validation errors in feedback prompt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({
+                text: INVALID_WORKFLOW_BAD_TRIGGER,
+            });
+            mockedGenerateText.mockResolvedValueOnce({
+                text: VALID_HTTP_WORKFLOW,
+            });
+            await generator.generateWorkflow("test-workflow", "Create a test workflow", "test-api-key", "http");
+            const secondCallArgs = mockedGenerateText.mock.calls[1][0];
+            const prompt = secondCallArgs.prompt;
+            expect(prompt).toContain("validation errors");
+            expect(prompt).toContain("invalid_trigger");
+        });
+        it("should exhaust all 3 attempts when workflow keeps failing", async () => {
+            mockedGenerateText.mockResolvedValue({
+                text: INVALID_WORKFLOW_MISSING_STEPS,
+            });
+            const result = await generator.generateWorkflow("broken-workflow", "Create something broken", "test-api-key", "http");
+            expect(result.validationResult.valid).toBe(false);
+            expect(result.validationResult.attempts).toBe(3);
+            expect(mockedGenerateText).toHaveBeenCalledTimes(3);
+        });
+        it("should fix mismatched nodes on retry", async () => {
+            mockedGenerateText.mockResolvedValueOnce({
+                text: INVALID_WORKFLOW_MISMATCHED_NODES,
+            });
+            mockedGenerateText.mockResolvedValueOnce({
+                text: VALID_HTTP_WORKFLOW,
+            });
+            const result = await generator.generateWorkflow("user-api", "Create a user API", "test-api-key", "http");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(2);
+        });
+    });
+    describe("invalid JSON handling", () => {
+        it("should handle LLM returning invalid JSON", async () => {
+            mockedGenerateText.mockResolvedValue({
+                text: "This is not valid JSON at all {{{",
+            });
+            const result = await generator.generateWorkflow("broken-workflow", "Create something", "test-api-key", "http");
+            expect(result.validationResult.valid).toBe(false);
+            expect(result.validationResult.errors.some((e) => e.includes("Invalid JSON"))).toBe(true);
+            expect(result.validationResult.attempts).toBe(3);
+        });
+    });
+    describe("trigger type enforcement", () => {
+        it("should include trigger type context in prompt for queue", async () => {
+            mockedGenerateText.mockResolvedValueOnce({
+                text: VALID_QUEUE_WORKFLOW,
+            });
+            await generator.generateWorkflow("event-processor", "Process events", "test-api-key", "queue");
+            const callArgs = mockedGenerateText.mock.calls[0][0];
+            const prompt = callArgs.prompt;
+            expect(prompt).toContain("queue");
+            expect(prompt).toContain('MUST use the "queue" trigger type');
+        });
+        it("should not enforce trigger type for auto mode", async () => {
+            mockedGenerateText.mockResolvedValueOnce({
+                text: VALID_HTTP_WORKFLOW,
+            });
+            await generator.generateWorkflow("auto-workflow", "Create an API", "test-api-key", "auto");
+            const callArgs = mockedGenerateText.mock.calls[0][0];
+            const prompt = callArgs.prompt;
+            expect(prompt).not.toContain("MUST use the");
+        });
+    });
+    describe("conditional workflow generation", () => {
+        it("should validate conditional workflows with if-else routing", async () => {
+            const conditionalWorkflow = JSON.stringify({
+                name: "CRUD Router",
+                description: "Routes CRUD operations",
+                version: "1.0.0",
+                trigger: {
+                    http: {
+                        method: "*",
+                        path: "/:function?/:id?",
+                        accept: "application/json",
+                    },
+                },
+                steps: [
+                    {
+                        name: "route-request",
+                        node: "@blok/if-else",
+                        type: "module",
+                    },
+                ],
+                nodes: {
+                    "route-request": {
+                        conditions: [
+                            {
+                                type: "if",
+                                condition: 'ctx.request.method.toLowerCase() === "get"',
+                                steps: [{ name: "get-data", node: "data-fetcher", type: "module" }],
+                            },
+                            {
+                                type: "if",
+                                condition: 'ctx.request.method.toLowerCase() === "post"',
+                                steps: [{ name: "create-data", node: "data-creator", type: "module" }],
+                            },
+                            {
+                                type: "else",
+                                steps: [{ name: "error-handler", node: "error", type: "module" }],
+                            },
+                        ],
+                    },
+                    "get-data": { inputs: {} },
+                    "create-data": { inputs: { body: "${ctx.request.body}" } },
+                    "error-handler": { inputs: { message: "Method not allowed", code: 405 } },
+                },
+            }, null, 2);
+            mockedGenerateText.mockResolvedValueOnce({
+                text: conditionalWorkflow,
+            });
+            const result = await generator.generateWorkflow("crud-router", "Create a CRUD router with conditional routing", "test-api-key", "http");
+            expect(result.validationResult.valid).toBe(true);
+            expect(result.validationResult.attempts).toBe(1);
+        });
+    });
+});

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

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