blokctl 0.2.0

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

@@ -0,0 +1,553 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("@ai-sdk/openai", () => ({
+    createOpenAI: vi.fn(() => vi.fn(() => "mocked-model")),
+}));
+vi.mock("ai", () => ({
+    generateText: vi.fn(),
+}));
+import { generateText } from "ai";
+import { GenerationAnalytics } from "./GenerationAnalytics.js";
+import RuntimeGenerator, { isSupportedLanguage } from "./RuntimeGenerator.js";
+const mockedGenerateText = vi.mocked(generateText);
+describe("RuntimeGenerator", () => {
+    let generator;
+    beforeEach(() => {
+        generator = new RuntimeGenerator();
+        vi.clearAllMocks();
+        vi.spyOn(console, "log").mockImplementation(() => { });
+        GenerationAnalytics.resetInstance();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe("isSupportedLanguage", () => {
+        it("should accept valid languages", () => {
+            expect(isSupportedLanguage("go")).toBe(true);
+            expect(isSupportedLanguage("java")).toBe(true);
+            expect(isSupportedLanguage("rust")).toBe(true);
+            expect(isSupportedLanguage("python")).toBe(true);
+            expect(isSupportedLanguage("csharp")).toBe(true);
+            expect(isSupportedLanguage("php")).toBe(true);
+            expect(isSupportedLanguage("ruby")).toBe(true);
+        });
+        it("should reject unsupported languages", () => {
+            expect(isSupportedLanguage("swift")).toBe(false);
+            expect(isSupportedLanguage("kotlin")).toBe(false);
+            expect(isSupportedLanguage("")).toBe(false);
+            expect(isSupportedLanguage("typescript")).toBe(false);
+        });
+    });
+    describe("validateRuntimeStructure", () => {
+        it("should pass for valid Go runtime code", () => {
+            const code = `
+// FILE: sdk/blok.go
+package blok
+
+type Context struct {}
+type NodeHandler interface {
+	Execute(ctx *Context, config map[string]interface{}) (interface{}, error)
+}
+type NodeRegistry struct {}
+func (r *NodeRegistry) Register(name string, handler NodeHandler) {}
+
+// FILE: server/main.go
+package main
+func main() {
+	http.HandleFunc("/execute", handleExecute)
+	http.HandleFunc("/health", handleHealth)
+}
+
+// FILE: Dockerfile
+FROM golang:1.22
+EXPOSE 8080
+
+// FILE: go.mod
+module github.com/blok/runtime-go
+`;
+            const result = generator.validateRuntimeStructure(code, "go");
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it("should fail when missing /execute endpoint", () => {
+            const code = `
+// FILE: sdk/blok.go
+package blok
+type Context struct {}
+type NodeHandler interface { Execute() }
+type Registry struct { register() }
+
+// FILE: server/main.go
+package main
+func main() {
+	http.HandleFunc("/health", handleHealth)
+}
+`;
+            const result = generator.validateRuntimeStructure(code, "go");
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("/execute"))).toBe(true);
+        });
+        it("should fail when missing /health endpoint", () => {
+            const code = `
+// FILE: sdk/blok.go
+package blok
+type Context struct {}
+type NodeHandler interface { Execute() }
+type Registry struct { register() }
+
+// FILE: server/main.go
+package main
+func main() {
+	http.HandleFunc("/execute", handleExecute)
+}
+`;
+            const result = generator.validateRuntimeStructure(code, "go");
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("/health"))).toBe(true);
+        });
+        it("should fail when missing file markers", () => {
+            const code = `package main
+func main() {
+	http.HandleFunc("/execute", handleExecute)
+	http.HandleFunc("/health", handleHealth)
+}
+type Context struct {}
+type NodeHandler interface { Execute() }
+type Registry struct { register() }
+`;
+            const result = generator.validateRuntimeStructure(code, "go");
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("multiple files"))).toBe(true);
+        });
+        it("should fail when missing NodeHandler", () => {
+            const code = `
+// FILE: sdk/blok.go
+package blok
+type Context struct {}
+type Registry struct {}
+
+// FILE: server/main.go
+package main
+func main() {
+	http.HandleFunc("/something/health", h)
+	http.HandleFunc("/something/execute", e)
+}
+`;
+            const result = generator.validateRuntimeStructure(code, "go");
+            expect(result.errors.length + result.warnings.length).toBeGreaterThanOrEqual(0);
+        });
+        it("should fail when missing Context type", () => {
+            const code = `
+// FILE: sdk/blok.go
+package blok
+type Handler interface { Execute() }
+type Registry struct { register() }
+
+// FILE: server/main.go
+package main
+func main() {
+	http.HandleFunc("/execute", e)
+	http.HandleFunc("/health", h)
+}
+`;
+            const result = generator.validateRuntimeStructure(code, "go");
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("Context"))).toBe(true);
+        });
+        it("should warn when missing Dockerfile", () => {
+            const code = `
+// FILE: sdk/blok.go
+package blok
+type Context struct {}
+type NodeHandler interface { Execute() }
+type Registry struct { register() }
+
+// FILE: server/main.go
+package main
+func main() {
+	http.HandleFunc("/execute", e)
+	http.HandleFunc("/health", h)
+}
+`;
+            const result = generator.validateRuntimeStructure(code, "go");
+            expect(result.warnings.some((w) => w.includes("Dockerfile"))).toBe(true);
+        });
+        it("should validate Java-specific structure", () => {
+            const code = `
+// FILE: src/main/java/com/blok/runtime/Blok.java
+public class Blok {
+	public interface NodeHandler {}
+	public static class Context {}
+}
+
+// FILE: src/main/java/com/blok/runtime/NodeRegistry.java
+public class NodeRegistry {
+	public void register(String name, NodeHandler handler) {}
+}
+
+// FILE: src/main/java/com/blok/server/RuntimeServer.java
+public class RuntimeServer {
+	// /execute and /health endpoints
+}
+
+// FILE: Dockerfile
+FROM eclipse-temurin:21
+
+// FILE: pom.xml
+<project>
+</project>
+`;
+            const result = generator.validateRuntimeStructure(code, "java");
+            expect(result.valid).toBe(true);
+        });
+        it("should warn for Java code missing pom.xml", () => {
+            const code = `
+// FILE: Blok.java
+public class Blok {
+	public interface NodeHandler { Object execute(); }
+	public static class Context {}
+}
+
+// FILE: NodeRegistry.java
+public class NodeRegistry { void register() {} }
+
+// FILE: Server.java
+public class Server {
+	// /execute and /health
+}
+
+// FILE: Dockerfile
+FROM java:21
+`;
+            const result = generator.validateRuntimeStructure(code, "java");
+            expect(result.warnings.some((w) => w.includes("pom.xml") || w.includes("build.gradle"))).toBe(true);
+        });
+        it("should validate Rust-specific structure", () => {
+            const code = `
+// FILE: src/lib.rs
+pub struct Context {}
+pub trait NodeHandler {
+	fn execute(&self, ctx: &Context) -> Result<(), Box<dyn std::error::Error>>;
+}
+pub struct Registry {}
+impl Registry {
+	pub fn register(&mut self) {}
+}
+
+// FILE: src/main.rs
+fn main() {
+	// /execute and /health endpoints
+}
+
+// FILE: Cargo.toml
+[package]
+name = "blok-runtime"
+
+// FILE: Dockerfile
+FROM rust:1.75
+`;
+            const result = generator.validateRuntimeStructure(code, "rust");
+            expect(result.valid).toBe(true);
+        });
+        it("should validate Python-specific structure", () => {
+            const code = `
+// FILE: blok/__init__.py
+class Context:
+    def __init__(self):
+        pass
+
+class NodeHandler:
+    def execute(self, ctx, config):
+        pass
+
+class NodeRegistry:
+    def register(self, name, handler):
+        pass
+
+// FILE: server.py
+from blok import NodeRegistry
+from flask import Flask, request, jsonify
+
+app = Flask(__name__)
+
+@app.route("/execute", methods=["POST"])
+def handle_execute():
+    pass
+
+@app.route("/health", methods=["GET"])
+def handle_health():
+    pass
+
+// FILE: requirements.txt
+flask==3.0.0
+
+// FILE: Dockerfile
+FROM python:3.12
+`;
+            const result = generator.validateRuntimeStructure(code, "python");
+            expect(result.valid).toBe(true);
+        });
+    });
+    describe("parseFiles", () => {
+        it("should parse multiple files from markers", () => {
+            const code = `
+// FILE: sdk/blok.go
+package blok
+
+type Context struct {}
+
+// FILE: server/main.go
+package main
+
+func main() {}
+
+// FILE: Dockerfile
+FROM golang:1.22
+EXPOSE 8080
+`;
+            const files = generator.parseFiles(code, "go");
+            expect(files).toHaveLength(3);
+            expect(files[0].path).toBe("sdk/blok.go");
+            expect(files[0].content).toContain("package blok");
+            expect(files[1].path).toBe("server/main.go");
+            expect(files[1].content).toContain("func main()");
+            expect(files[2].path).toBe("Dockerfile");
+            expect(files[2].content).toContain("FROM golang");
+        });
+        it("should handle single file without markers", () => {
+            const code = `package main
+func main() {}`;
+            const files = generator.parseFiles(code, "go");
+            expect(files).toHaveLength(1);
+            expect(files[0].path).toBe("runtime.go");
+            expect(files[0].content).toContain("package main");
+        });
+        it("should handle empty code", () => {
+            const files = generator.parseFiles("", "go");
+            expect(files).toHaveLength(0);
+        });
+        it("should use correct extension per language", () => {
+            const goFiles = generator.parseFiles("package main", "go");
+            expect(goFiles[0].path).toBe("runtime.go");
+            const javaFiles = generator.parseFiles("public class Main {}", "java");
+            expect(javaFiles[0].path).toBe("runtime.java");
+            const rustFiles = generator.parseFiles("fn main() {}", "rust");
+            expect(rustFiles[0].path).toBe("runtime.rs");
+            const pyFiles = generator.parseFiles("def main(): pass", "python");
+            expect(pyFiles[0].path).toBe("runtime.py");
+            const csFiles = generator.parseFiles("class Main {}", "csharp");
+            expect(csFiles[0].path).toBe("runtime.cs");
+            const phpFiles = generator.parseFiles("<?php echo 1;", "php");
+            expect(phpFiles[0].path).toBe("runtime.php");
+            const rbFiles = generator.parseFiles("def main; end", "ruby");
+            expect(rbFiles[0].path).toBe("runtime.rb");
+        });
+    });
+    describe("generateRuntime (with mocked LLM)", () => {
+        const validGoRuntime = `
+// FILE: sdk/blok.go
+package blok
+
+type Context struct {
+	ID string
+}
+
+type NodeHandler interface {
+	Execute(ctx *Context, config map[string]interface{}) (interface{}, error)
+}
+
+type NodeRegistry struct {
+	handlers map[string]NodeHandler
+}
+
+func (r *NodeRegistry) Register(name string, handler NodeHandler) {
+	r.handlers[name] = handler
+}
+
+// FILE: server/main.go
+package main
+
+import "net/http"
+
+func main() {
+	http.HandleFunc("/execute", handleExecute)
+	http.HandleFunc("/health", handleHealth)
+	http.ListenAndServe(":8080", nil)
+}
+
+func handleExecute(w http.ResponseWriter, r *http.Request) {
+	// Handle execution with success, data, errors response
+}
+
+func handleHealth(w http.ResponseWriter, r *http.Request) {}
+
+// FILE: go.mod
+module github.com/blok/runtime-go
+go 1.22
+
+// FILE: Dockerfile
+FROM golang:1.22 AS builder
+WORKDIR /app
+COPY . .
+RUN go build -o runtime ./server
+
+FROM alpine:3.19
+COPY --from=builder /app/runtime /runtime
+EXPOSE 8080
+CMD ["/runtime"]
+`;
+        it("should generate a valid Go runtime on first attempt", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: validGoRuntime });
+            const result = await generator.generateRuntime("go", "Generate a Go runtime for the Blok framework", "test-api-key");
+            expect(result.language).toBe("go");
+            expect(result.validationResult?.valid).toBe(true);
+            expect(result.validationResult?.attempts).toBe(1);
+            expect(result.files.length).toBeGreaterThan(0);
+            expect(result.files.some((f) => f.path.includes("blok.go"))).toBe(true);
+        });
+        it("should retry on validation failure", async () => {
+            const invalidCode = `
+// FILE: sdk/blok.go
+package blok
+type Context struct {}
+type NodeHandler interface { Execute() }
+type Registry struct { register() }
+
+// FILE: server/main.go
+package main
+func main() {
+	http.HandleFunc("/execute", e)
+}
+`;
+            mockedGenerateText.mockResolvedValueOnce({ text: invalidCode });
+            mockedGenerateText.mockResolvedValueOnce({ text: validGoRuntime });
+            const result = await generator.generateRuntime("go", "Generate a Go runtime", "test-api-key");
+            expect(result.validationResult?.valid).toBe(true);
+            expect(result.validationResult?.attempts).toBe(2);
+            expect(mockedGenerateText).toHaveBeenCalledTimes(2);
+        });
+        it("should exhaust attempts and return invalid result", async () => {
+            const invalidCode = "just some text without any structure";
+            mockedGenerateText.mockResolvedValue({ text: invalidCode });
+            const result = await generator.generateRuntime("go", "Generate something", "test-api-key");
+            expect(result.validationResult?.valid).toBe(false);
+            expect(result.validationResult?.attempts).toBe(3);
+            expect(result.validationResult?.errors.length).toBeGreaterThan(0);
+        });
+        it("should record analytics event", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: validGoRuntime });
+            await generator.generateRuntime("go", "test", "test-key");
+            const analytics = GenerationAnalytics.getInstance();
+            const stats = analytics.getStats();
+            expect(stats.totalGenerations).toBe(1);
+            expect(stats.successCount).toBe(1);
+        });
+        it("should record failed analytics event", async () => {
+            mockedGenerateText.mockResolvedValue({ text: "invalid" });
+            await generator.generateRuntime("java", "test", "test-key");
+            const analytics = GenerationAnalytics.getInstance();
+            const stats = analytics.getStats();
+            expect(stats.totalGenerations).toBe(1);
+            expect(stats.failureCount).toBe(1);
+        });
+        it("should strip markdown fences from LLM output", async () => {
+            const wrappedCode = `\`\`\`go\n${validGoRuntime}\n\`\`\``;
+            mockedGenerateText.mockResolvedValueOnce({ text: wrappedCode });
+            const result = await generator.generateRuntime("go", "test", "test-key");
+            expect(result.validationResult?.valid).toBe(true);
+        });
+        it("should include prompt version in validation result", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: validGoRuntime });
+            const result = await generator.generateRuntime("go", "test", "test-key");
+            expect(result.validationResult?.promptVersion).toBe("create-runtime@1.0.0");
+        });
+        it("should include duration in validation result", async () => {
+            mockedGenerateText.mockResolvedValueOnce({ text: validGoRuntime });
+            const result = await generator.generateRuntime("go", "test", "test-key");
+            expect(result.validationResult?.durationMs).toBeDefined();
+            expect(typeof result.validationResult?.durationMs).toBe("number");
+        });
+    });
+    describe("language-specific validation", () => {
+        it("should warn Go code without go.mod", () => {
+            const code = `
+// FILE: sdk/blok.go
+package blok
+type Context struct {}
+type NodeHandler interface { Execute() }
+type Registry struct { register() }
+
+// FILE: server/main.go
+package main
+func main() {
+	http.HandleFunc("/execute", e)
+	http.HandleFunc("/health", h)
+}
+
+// FILE: Dockerfile
+FROM golang:1.22
+`;
+            const result = generator.validateRuntimeStructure(code, "go");
+            expect(result.warnings.some((w) => w.includes("go.mod"))).toBe(true);
+        });
+        it("should error Go code without package declaration", () => {
+            const code = `
+// FILE: blok.go
+type Context struct {}
+type Handler interface { Execute() }
+type Registry struct { register() }
+
+// FILE: main.go
+func main() {
+	http.HandleFunc("/execute", e)
+	http.HandleFunc("/health", h)
+}
+`;
+            const result = generator.validateRuntimeStructure(code, "go");
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("package"))).toBe(true);
+        });
+        it("should warn Python code without requirements.txt", () => {
+            const code = `
+// FILE: blok/__init__.py
+class Context:
+    pass
+
+class NodeHandler:
+    def execute(self):
+        pass
+
+class NodeRegistry:
+    def register(self, name, handler):
+        pass
+
+// FILE: server.py
+def handle_execute():
+    pass
+
+def handle_health():
+    pass
+
+// FILE: Dockerfile
+FROM python:3.12
+`;
+            const result = generator.validateRuntimeStructure(code, "python");
+            expect(result.warnings.some((w) => w.includes("requirements.txt") || w.includes("pyproject.toml"))).toBe(true);
+        });
+        it("should warn C# code without .csproj", () => {
+            const code = `
+// FILE: Program.cs
+class Program { static void Main() {} }
+Context ctx = new Context();
+var handler = new NodeHandler();
+var registry = new Registry();
+registry.register("test", handler);
+// /execute and /health endpoints
+
+// FILE: Dockerfile
+FROM mcr.microsoft.com/dotnet/sdk:8.0
+`;
+            const result = generator.validateRuntimeStructure(code, "csharp");
+            expect(result.warnings.some((w) => w.includes(".csproj"))).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,22 @@
+export type TriggerInformation = {
+    triggerName: string;
+    triggerType: string;
+    userPrompt: string;
+    code: string;
+    validationResult?: {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+        attempts: number;
+        promptVersion?: string;
+        durationMs?: number;
+    };
+};
+export default class TriggerGenerator {
+    private readonly MAX_VALIDATION_ATTEMPTS;
+    generateTrigger(triggerName: string, triggerType: string, userPrompt: string, apiKey: string, update?: boolean, existingTriggerPath?: string): Promise<TriggerInformation>;
+    private validateTriggerStructure;
+    private buildEnhancedPrompt;
+    private createFeedbackPrompt;
+    private getSemanticGuidance;
+}