blokctl 0.6.21 → 1.0.0

package/dist/commands/dev/index.js

@@ -1,9 +1,12 @@
 import { spawn } from "node:child_process";
+import child_process from "node:child_process";
 import path from "node:path";
+import util from "node:util";
 import fsExtra from "fs-extra";
 import { waitForGrpcPort } from "../../services/health-probe.js";
 import { detectRr } from "../../services/runtime-detector.js";
-import { readProjectConfig, validateProjectRuntimes } from "../../services/runtime-setup.js";
+import { generateCSharpNodeRegistry, generateGoNodeRegistry, generateJavaNodeRegistry, generateRustNodeRegistry, readProjectConfig, validateProjectRuntimes, } from "../../services/runtime-setup.js";
+const exec = util.promisify(child_process.exec);
 const runningProcesses = [];
 function spawnProcess(cmd, args, name, currentPath, cwd, env) {
     const child = spawn(cmd, args, {
@@ -98,6 +101,42 @@ export async function devProject(opts) {
                 HOST: "0.0.0.0",
                 BLOK_TRANSPORT: "grpc",
             };
+            if (rt.kind === "python3" || rt.kind === "ruby" || rt.kind === "php") {
+                env.BLOK_NODES_DIR = path.resolve(currentPath, "runtimes", rt.kind, "nodes");
+            }
+            if (rt.kind === "go") {
+                try {
+                    generateGoNodeRegistry(currentPath);
+                }
+                catch (err) {
+                    console.log(`  Warning: Go user-node codegen failed: ${err.message}`);
+                }
+            }
+            if (rt.kind === "rust") {
+                try {
+                    generateRustNodeRegistry(currentPath);
+                }
+                catch (err) {
+                    console.log(`  Warning: Rust user-node codegen failed: ${err.message}`);
+                }
+            }
+            if (rt.kind === "csharp") {
+                try {
+                    generateCSharpNodeRegistry(currentPath);
+                }
+                catch (err) {
+                    console.log(`  Warning: C# user-node codegen failed: ${err.message}`);
+                }
+            }
+            if (rt.kind === "java") {
+                try {
+                    generateJavaNodeRegistry(currentPath);
+                    await exec("mvn package -q -DskipTests", { cwd: runtimeCwd, timeout: 300000 });
+                }
+                catch (err) {
+                    console.log(`  Warning: Java user-node codegen/build failed: ${err.message}`);
+                }
+            }
             runtimeDefs.push({
                 cmd,
                 args,

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

@@ -7,8 +7,6 @@ type NodeInformation = {
         errors: string[];
         warnings: string[];
         attempts: number;
-        promptVersion?: string;
-        durationMs?: number;
     };
 };
 export type { NodeInformation };

package/dist/commands/generate/NodeGenerator.js

@@ -1,8 +1,6 @@
 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 createFnNodeSystemPrompt from "./prompts/create-fn-node.system.js";
 import createNodeSystemPrompt from "./prompts/create-node.system.js";
 import * as CompilationValidator from "./validators/CompilationValidator.js";
@@ -10,10 +8,6 @@ import * as NodeValidator from "./validators/NodeValidator.js";
 export default class NodeGenerator {
     MAX_VALIDATION_ATTEMPTS = 3;
     async generateNode(nodeName, userPrompt, apiKey, update = false, nodeStyle = "function") {
-        const analytics = GenerationAnalytics.getInstance();
-        const getElapsed = analytics.startTimer();
-        const promptId = nodeStyle === "function" ? "create-fn-node" : "create-node";
-        const promptVersion = getVersionStamp(promptId);
         const openai = createOpenAI({
             compatibility: "strict",
             apiKey: apiKey,
@@ -21,7 +15,6 @@ export default class NodeGenerator {
         const promptTemplate = nodeStyle === "function" ? createFnNodeSystemPrompt : createNodeSystemPrompt;
         let prompt = promptTemplate.prompt;
         let existingCode = null;
-        registerPromptContent(promptId, prompt);
         if (update) {
             const dirName = nodeName.toLowerCase().replace(/\s+/g, "-");
             const dirPath = process.cwd();
@@ -72,17 +65,6 @@ export default class NodeGenerator {
                 console.log(`⚠️  Validation failed (attempt ${attempts}/${this.MAX_VALIDATION_ATTEMPTS}). Retrying with feedback...`);
             }
         }
-        const durationMs = getElapsed();
-        analytics.recordEvent({
-            type: "node",
-            subtype: nodeStyle,
-            name: nodeName,
-            success: isValid,
-            attempts,
-            durationMs,
-            errors: allErrors,
-            promptVersion,
-        });
         return {
             nodeName,
             userPrompt,
@@ -92,8 +74,6 @@ export default class NodeGenerator {
                 errors: validationErrors,
                 warnings: validationWarnings,
                 attempts,
-                promptVersion,
-                durationMs,
             },
         };
     }

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

@@ -11,8 +11,6 @@ export type RuntimeInformation = {
         errors: string[];
         warnings: string[];
         attempts: number;
-        promptVersion?: string;
-        durationMs?: number;
     };
 };
 declare const SUPPORTED_LANGUAGES: readonly ["go", "java", "rust", "python", "csharp", "php", "ruby"];

package/dist/commands/generate/RuntimeGenerator.js

@@ -1,8 +1,6 @@
 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 createRuntimeSystemPrompt from "./prompts/create-runtime.system.js";
 const SUPPORTED_LANGUAGES = ["go", "java", "rust", "python", "csharp", "php", "ruby"];
 export function isSupportedLanguage(lang) {
@@ -11,15 +9,11 @@ export function isSupportedLanguage(lang) {
 export default class RuntimeGenerator {
     MAX_VALIDATION_ATTEMPTS = 3;
     async generateRuntime(language, userPrompt, apiKey, update = false, existingPath) {
-        const analytics = GenerationAnalytics.getInstance();
-        const getElapsed = analytics.startTimer();
-        const promptVersion = getVersionStamp("create-runtime");
         const openai = createOpenAI({
             compatibility: "strict",
             apiKey: apiKey,
         });
         let prompt = createRuntimeSystemPrompt.prompt;
-        registerPromptContent("create-runtime", prompt);
         if (update && existingPath) {
             const existingContent = this.readExistingRuntime(existingPath);
             prompt = `${createRuntimeSystemPrompt.updatePrompt}\n\n${existingContent}`;
@@ -54,17 +48,6 @@ export default class RuntimeGenerator {
             }
         }
         const files = this.parseFiles(generatedCode, language);
-        const durationMs = getElapsed();
-        analytics.recordEvent({
-            type: "node",
-            subtype: `runtime-${language}`,
-            name: `runtime-${language}`,
-            success: isValid,
-            attempts,
-            durationMs,
-            errors: allErrors,
-            promptVersion,
-        });
         return {
             language,
             userPrompt,
@@ -75,8 +58,6 @@ export default class RuntimeGenerator {
                 errors: validationErrors,
                 warnings: validationWarnings,
                 attempts,
-                promptVersion,
-                durationMs,
             },
         };
     }

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

@@ -6,7 +6,6 @@ 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", () => {
@@ -15,7 +14,6 @@ describe("RuntimeGenerator", () => {
         generator = new RuntimeGenerator();
         vi.clearAllMocks();
         vi.spyOn(console, "log").mockImplementation(() => { });
-        GenerationAnalytics.resetInstance();
     });
     afterEach(() => {
         vi.restoreAllMocks();
@@ -433,39 +431,12 @@ func main() {
             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", () => {

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

@@ -8,8 +8,6 @@ export type TriggerInformation = {
         errors: string[];
         warnings: string[];
         attempts: number;
-        promptVersion?: string;
-        durationMs?: number;
     };
 };
 export default class TriggerGenerator {

package/dist/commands/generate/TriggerGenerator.js

@@ -1,22 +1,16 @@
 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}`;
@@ -58,17 +52,6 @@ export default class TriggerGenerator {
                 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,
@@ -79,8 +62,6 @@ export default class TriggerGenerator {
                 errors: validationErrors,
                 warnings: validationWarnings,
                 attempts,
-                promptVersion,
-                durationMs,
             },
         };
     }

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

@@ -8,8 +8,6 @@ export type WorkflowInformation = {
         errors: string[];
         warnings: string[];
         attempts: number;
-        promptVersion?: string;
-        durationMs?: number;
     };
 };
 export default class WorkflowGenerator {

package/dist/commands/generate/WorkflowGenerator.js

@@ -1,22 +1,16 @@
 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}`;
@@ -50,17 +44,6 @@ export default class WorkflowGenerator {
                 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,
@@ -71,8 +54,6 @@ export default class WorkflowGenerator {
                 errors: validationErrors,
                 warnings: validationWarnings,
                 attempts,
-                promptVersion,
-                durationMs,
             },
         };
     }
@@ -120,11 +101,11 @@ export default class WorkflowGenerator {
             "```",
             "",
             "Please fix these errors and regenerate the workflow JSON. Common fixes:",
-            "- Ensure every step name has a matching entry in the nodes object",
+            "- Ensure every step has a unique `id` and a `use` (or a `branch`) — inputs live inline; there is NO `nodes` map",
             "- 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",
+            "- Ensure branch `when` is a raw `ctx.*` expression (never `js/` or `$.`)",
+            "- Reference earlier outputs with `$.state.<id>` and request data with `$.req.*`",
+            "- Use a single step with `branch: { when, then, else }` for conditionals (not a `conditions` array)",
         ].join("\n");
         return feedback;
     }

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

@@ -70,8 +70,8 @@ describe("WorkflowGenerator", () => {
         });
         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");
+            expect(result).toContain("unique `id`");
+            expect(result).toContain("branch: { when, then, else }");
         });
     });
 });

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

@@ -115,18 +115,6 @@ describe("NodeGenerator E2E", () => {
             const callArgs = mockedGenerateText.mock.calls[0][0];
             expect(callArgs.temperature).toBe(0.2);
         });
-        it("should include prompt version in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_FUNCTION_FIRST_NODE });
-            mockValidPass();
-            const result = await generator.generateNode("test-node", "Create a test node", "test-api-key", false, "function");
-            expect(result.validationResult.promptVersion).toContain("create-fn-node@");
-        });
-        it("should include duration in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_FUNCTION_FIRST_NODE });
-            mockValidPass();
-            const result = await generator.generateNode("test-node", "Create a test node", "test-api-key", false, "function");
-            expect(result.validationResult.durationMs).toBeGreaterThanOrEqual(0);
-        });
     });
     describe("validation feedback loop", () => {
         it("should retry with feedback on first failure and succeed on second attempt", async () => {

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

@@ -645,18 +645,6 @@ describe("RuntimeGenerator E2E", () => {
             expect(mockedGenerateText).toHaveBeenCalledTimes(1);
         });
     });
-    describe("analytics integration", () => {
-        it("should include prompt version in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_GO_RUNTIME });
-            const result = await generator.generateRuntime("go", "Create a runtime", "test-api-key");
-            expect(result.validationResult.promptVersion).toContain("create-runtime@");
-        });
-        it("should include duration in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_GO_RUNTIME });
-            const result = await generator.generateRuntime("go", "Create a runtime", "test-api-key");
-            expect(result.validationResult.durationMs).toBeGreaterThanOrEqual(0);
-        });
-    });
     describe("multi-file parsing", () => {
         it("should parse files separated by // FILE: markers", async () => {
             const code = [

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

@@ -278,18 +278,4 @@ describe("TriggerGenerator E2E", () => {
             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/prompts/create-fn-node.system.js

@@ -9,7 +9,7 @@ What to return:
   1. Proper imports:
      * \`z\` from \`zod\`
      * \`Context\` from \`@blokjs/shared\`
-     * \`defineNode\` from \`@blokjs/runner\`
+     * \`defineNode\` from \`@blokjs/core\`
   2. A clear and structured \`input\` schema using Zod (z.object with proper types).
   3. A matching \`output\` schema using Zod.
   4. A single exported node instance created via \`defineNode\` with:
@@ -26,11 +26,11 @@ Constraints:
 * The Zod \`output\` schema must fully describe the object returned by \`execute\`.
 * Inside \`execute(ctx, input)\`:
   * Use the strongly-typed \`input\`, which is automatically inferred from the Zod schema.
-  * Use \`ctx\` to access request data, configuration, and cross-node state when needed:
+  * Use \`ctx\` to access request data, configuration, and logging when needed:
     * \`ctx.request.body\`, \`ctx.request.query\`, \`ctx.request.params\` for HTTP data
-    * \`ctx.vars\` for reading/writing values shared between nodes
     * \`ctx.logger\` for logging
     * \`ctx.env\` for environment variables
+  * Do **not** write to \`ctx.state\`/\`ctx.vars\` from a node — just RETURN your output; the runner auto-persists it to \`ctx.state[<step-id>]\` for downstream steps. Upstream values arrive as \`input.*\` (mapped in the workflow), not by reading \`ctx.vars\`.
   * Do **not** construct or return \`BlokResponse\` here; just return a plain object matching the output schema. The wrapper created by \`defineNode\` will call \`setSuccess\` / \`setError\` and handle \`GlobalError\`.
 * On validation errors or runtime errors, you do NOT manually throw \`GlobalError\`; throw/rethrow normal errors. The \`defineNode\` wrapper will catch them and map them to \`GlobalError\` consistently with proper error codes:
   * Zod validation errors → 400 Bad Request
@@ -52,7 +52,7 @@ Real-World Examples to Guide You:
 \`\`\`typescript
 import type { Context } from "@blokjs/shared";
 import { z } from "zod";
-import { defineNode } from "@blokjs/runner";
+import { defineNode } from "@blokjs/core";
 
 export default defineNode({
 	name: "api-call",
@@ -102,10 +102,6 @@ export default defineNode({
 
 		ctx.logger.log(\`Request completed in \${duration.toFixed(2)}ms with status \${response.status}\`);
 
-		if (ctx.vars) {
-			ctx.vars["api-response"] = { status: response.status, data };
-		}
-
 		return {
 			status: response.status,
 			statusText: response.statusText,
@@ -122,7 +118,7 @@ export default defineNode({
 \`\`\`typescript
 import type { Context } from "@blokjs/shared";
 import { z } from "zod";
-import { defineNode } from "@blokjs/runner";
+import { defineNode } from "@blokjs/core";
 
 export default defineNode({
 	name: "fetch-user",
@@ -149,11 +145,8 @@ export default defineNode({
 		// Simulate database fetch
 		const user = await fetchUserFromDatabase(input.userId, input.includeMetadata);
 
-		// Store in context for downstream nodes
-		if (ctx.vars) {
-			ctx.vars["current-user"] = user;
-		}
-
+		// Just return — the runner persists this to ctx.state["fetch-user"]
+		// for any downstream step that maps it in as an input.
 		return { user };
 	},
 });
@@ -176,7 +169,7 @@ Template to follow (adapt and fill based on the user's request):
 
 import type { Context } from "@blokjs/shared";
 import { z } from "zod";
-import { defineNode } from "@blokjs/runner";
+import { defineNode } from "@blokjs/core";
 
 /**
  * [Brief description of what this node does]
@@ -210,11 +203,11 @@ export default defineNode({
 		//
 		// Common patterns:
 		// - Read HTTP params: const id = ctx.request.params.id;
-		// - Read previous node output: const prev = ctx.vars["previous-node-key"];
-		// - Write for future nodes: ctx.vars["this-node-key"] = someValue;
+		// - Read upstream values via input.* (mapped from prior steps in the workflow) — NOT ctx.vars
 		// - Use input.* fields that match the input schema (TypeScript infers the type automatically)
 		// - Log messages: ctx.logger.log("Processing request");
 		// - Access environment: const apiKey = ctx.env.API_KEY;
+		// - Do NOT write ctx.state/ctx.vars here — just return; the runner persists your output.
 
 		// TODO: Implement business logic here