blokctl 0.2.0

package/dist/commands/generate/validators/CompilationValidator.test.js

@@ -0,0 +1,161 @@
+import { describe, expect, it } from "vitest";
+import { validateCode } from "./CompilationValidator.js";
+describe("CompilationValidator", () => {
+    describe("validateCode", () => {
+        it("should pass for valid function-first node", () => {
+            const validCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "test-node",
+  description: "A test node",
+
+  input: z.object({
+    userId: z.string(),
+  }),
+
+  output: z.object({
+    user: z.object({
+      id: z.string(),
+      name: z.string(),
+    }),
+  }),
+
+  async execute(ctx, input) {
+    return {
+      user: {
+        id: input.userId,
+        name: "Test User",
+      },
+    };
+  },
+});
+      `;
+            const result = validateCode(validCode, "test-node");
+            expect(result.success).toBe(true);
+            expect(result.errors.length).toBe(0);
+        });
+        it("should pass for code with missing imports (type checking limitations)", () => {
+            const invalidCode = `
+export default defineNode({
+  name: "broken-node",
+  description: "Missing imports",
+
+  input: z.object({
+    userId: z.string(),
+  }),
+
+  output: z.string(),
+
+  async execute(ctx, input) {
+    return input.userId;
+  },
+});
+      `;
+            const result = validateCode(invalidCode, "broken-node");
+            expect(result.success).toBe(true);
+        });
+        it("should pass for code with type errors (type checking limitations)", () => {
+            const invalidCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "type-error-node",
+  description: "Has type errors",
+
+  input: z.object({
+    userId: z.string(),
+  }),
+
+  output: z.object({
+    count: z.number(),
+  }),
+
+  async execute(ctx, input) {
+    // Return string instead of number - type error
+    return {
+      count: "not a number",
+    };
+  },
+});
+      `;
+            const result = validateCode(invalidCode, "type-error-node");
+            expect(result.success).toBe(true);
+        });
+        it("should document syntax validation limitations", () => {
+            const invalidCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "syntax-error-node",
+  description: "Has syntax errors",
+
+  input: z.object({
+    userId: z.string()
+  }),
+
+  output: z.string(),
+
+  async execute(ctx, input) {
+    return input.userId;
+  // Missing closing brace
+});
+      `;
+            const result = validateCode(invalidCode, "syntax-error-node");
+            expect(result).toBeDefined();
+            expect(typeof result.success).toBe("boolean");
+        });
+        it("should pass for code with proper async/await usage", () => {
+            const validCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "async-node",
+  description: "Uses async/await properly",
+
+  input: z.object({
+    url: z.string().url(),
+  }),
+
+  output: z.object({
+    data: z.unknown(),
+  }),
+
+  async execute(ctx, input) {
+    const response = await fetch(input.url);
+    const data = await response.json();
+    return { data };
+  },
+});
+      `;
+            const result = validateCode(validCode, "async-node");
+            expect(result.success).toBe(true);
+        });
+    });
+    describe("validateFile", () => {
+        it("should validate code using file path for context", () => {
+            const validCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "file-test",
+  description: "Testing file validation",
+
+  input: z.string(),
+  output: z.string(),
+
+  async execute(ctx, input) {
+    return input.toUpperCase();
+  },
+});
+      `;
+            const result = validateCode(validCode, "file-test");
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/dist/commands/generate/validators/NodeValidator.d.ts

@@ -0,0 +1,18 @@
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    suggestions: string[];
+}
+export interface NodeValidationContext {
+    filePath: string;
+    nodeStyle: "function" | "class";
+    content: string;
+}
+export declare function validate(context: NodeValidationContext): Promise<ValidationResult>;
+export declare function validateCompilation(context: NodeValidationContext): ValidationResult;
+export declare function validateFunctionFirstStructure(context: NodeValidationContext): ValidationResult;
+export declare function validateClassBasedStructure(context: NodeValidationContext): ValidationResult;
+export declare function validateExports(context: NodeValidationContext): ValidationResult;
+export declare function quickValidate(filePath: string): Promise<boolean>;
+export declare function formatResult(result: ValidationResult): string;

package/dist/commands/generate/validators/NodeValidator.js

@@ -0,0 +1,217 @@
+import * as fs from "node:fs";
+import * as ts from "typescript";
+export async function validate(context) {
+    const result = {
+        valid: true,
+        errors: [],
+        warnings: [],
+        suggestions: [],
+    };
+    if (!fs.existsSync(context.filePath)) {
+        result.valid = false;
+        result.errors.push(`File does not exist: ${context.filePath}`);
+        return result;
+    }
+    const compilationResult = validateCompilation(context);
+    result.errors.push(...compilationResult.errors);
+    result.warnings.push(...compilationResult.warnings);
+    if (!compilationResult.valid) {
+        result.valid = false;
+    }
+    if (context.nodeStyle === "function") {
+        const structureResult = validateFunctionFirstStructure(context);
+        result.errors.push(...structureResult.errors);
+        result.warnings.push(...structureResult.warnings);
+        result.suggestions.push(...structureResult.suggestions);
+        if (!structureResult.valid) {
+            result.valid = false;
+        }
+    }
+    else {
+        const structureResult = validateClassBasedStructure(context);
+        result.errors.push(...structureResult.errors);
+        result.warnings.push(...structureResult.warnings);
+        if (!structureResult.valid) {
+            result.valid = false;
+        }
+    }
+    const exportsResult = validateExports(context);
+    result.errors.push(...exportsResult.errors);
+    result.warnings.push(...exportsResult.warnings);
+    if (!exportsResult.valid) {
+        result.valid = false;
+    }
+    return result;
+}
+export function validateCompilation(context) {
+    const result = {
+        valid: true,
+        errors: [],
+        warnings: [],
+        suggestions: [],
+    };
+    try {
+        const compilerOptions = {
+            target: ts.ScriptTarget.ES2020,
+            module: ts.ModuleKind.CommonJS,
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            noEmit: true,
+        };
+        const program = ts.createProgram([context.filePath], compilerOptions);
+        const diagnostics = [...program.getSyntacticDiagnostics(), ...program.getSemanticDiagnostics()];
+        for (const diagnostic of diagnostics) {
+            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+            if (diagnostic.category === ts.DiagnosticCategory.Error) {
+                result.valid = false;
+                result.errors.push(`TypeScript Error: ${message}`);
+            }
+            else if (diagnostic.category === ts.DiagnosticCategory.Warning) {
+                result.warnings.push(`TypeScript Warning: ${message}`);
+            }
+        }
+        if (result.valid) {
+            result.suggestions.push("✅ TypeScript compilation successful");
+        }
+    }
+    catch (error) {
+        result.valid = false;
+        result.errors.push(`Compilation check failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+export function validateFunctionFirstStructure(context) {
+    const result = {
+        valid: true,
+        errors: [],
+        warnings: [],
+        suggestions: [],
+    };
+    const content = context.content;
+    if (!content.includes("import") || !content.includes("defineNode")) {
+        result.valid = false;
+        result.errors.push("Missing 'defineNode' import from '@blok/runner'");
+    }
+    if (!content.includes("import") || !content.includes("zod")) {
+        result.valid = false;
+        result.errors.push("Missing 'zod' import - required for schema validation");
+    }
+    if (!content.includes("defineNode({")) {
+        result.valid = false;
+        result.errors.push("Missing 'defineNode()' call");
+    }
+    const requiredProps = ["name:", "description:", "input:", "output:", "execute"];
+    for (const prop of requiredProps) {
+        if (!content.includes(prop)) {
+            result.valid = false;
+            result.errors.push(`Missing required property: ${prop.replace(":", "")}`);
+        }
+    }
+    if (!content.includes("z.object(")) {
+        result.warnings.push("No Zod schema detected - ensure input/output use z.object()");
+    }
+    if (!content.includes("async execute") && !content.includes("async (ctx")) {
+        result.warnings.push("Execute function should be async for consistent error handling");
+    }
+    if (!content.includes("Context") && !content.includes("ctx")) {
+        result.warnings.push("Context parameter (ctx) not found in execute function");
+    }
+    if (result.valid) {
+        result.suggestions.push("✅ Function-first structure looks good");
+    }
+    return result;
+}
+export function validateClassBasedStructure(context) {
+    const result = {
+        valid: true,
+        errors: [],
+        warnings: [],
+        suggestions: [],
+    };
+    const content = context.content;
+    if (!content.includes("BlokService")) {
+        result.valid = false;
+        result.errors.push("Missing 'BlokService' import from '@blok/runner'");
+    }
+    if (!content.includes("class ") || !content.includes("extends BlokService")) {
+        result.valid = false;
+        result.errors.push("Missing class declaration extending BlokService");
+    }
+    if (!content.includes("async handle(")) {
+        result.valid = false;
+        result.errors.push("Missing 'async handle()' method");
+    }
+    if (!content.includes("inputSchema") || !content.includes("outputSchema")) {
+        result.warnings.push("Missing inputSchema or outputSchema in constructor");
+    }
+    if (result.valid) {
+        result.suggestions.push("✅ Class-based structure looks good");
+        result.suggestions.push("💡 Consider migrating to function-first pattern for better DX");
+    }
+    return result;
+}
+export function validateExports(context) {
+    const result = {
+        valid: true,
+        errors: [],
+        warnings: [],
+        suggestions: [],
+    };
+    const content = context.content;
+    if (!content.includes("export default")) {
+        result.valid = false;
+        result.errors.push("Missing default export");
+    }
+    if (result.valid) {
+        result.suggestions.push("✅ Export structure is correct");
+    }
+    return result;
+}
+export async function quickValidate(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const context = {
+            filePath,
+            nodeStyle: content.includes("defineNode") ? "function" : "class",
+            content,
+        };
+        const result = await validate(context);
+        return result.valid;
+    }
+    catch {
+        return false;
+    }
+}
+export function formatResult(result) {
+    const lines = [];
+    if (result.errors.length > 0) {
+        lines.push("❌ Errors:");
+        for (const err of result.errors) {
+            lines.push(`  - ${err}`);
+        }
+        lines.push("");
+    }
+    if (result.warnings.length > 0) {
+        lines.push("⚠️  Warnings:");
+        for (const warn of result.warnings) {
+            lines.push(`  - ${warn}`);
+        }
+        lines.push("");
+    }
+    if (result.suggestions.length > 0) {
+        lines.push("💡 Suggestions:");
+        for (const sug of result.suggestions) {
+            lines.push(`  - ${sug}`);
+        }
+        lines.push("");
+    }
+    if (result.valid) {
+        lines.push("✅ Validation passed!");
+    }
+    else {
+        lines.push("❌ Validation failed. Please fix the errors above.");
+    }
+    return lines.join("\n");
+}

package/dist/commands/generate/validators/NodeValidator.test.d.ts

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

package/dist/commands/generate/validators/NodeValidator.test.js

@@ -0,0 +1,281 @@
+import { describe, expect, it } from "vitest";
+import { validateExports, validateFunctionFirstStructure } from "./NodeValidator.js";
+describe("NodeValidator", () => {
+    describe("validateFunctionFirstStructure", () => {
+        it("should pass for valid function-first node", () => {
+            const validCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "test-node",
+  description: "A test node",
+
+  input: z.object({
+    userId: z.string(),
+  }),
+
+  output: z.string(),
+
+  async execute(ctx, input) {
+    return input.userId;
+  },
+});
+      `;
+            const context = {
+                filePath: "/tmp/test-node.ts",
+                nodeStyle: "function",
+                content: validCode,
+            };
+            const result = validateFunctionFirstStructure(context);
+            expect(result.valid).toBe(true);
+            expect(result.errors.length).toBe(0);
+        });
+        it("should fail for class-based node (old pattern)", () => {
+            const classBasedCode = `
+import { BlokService } from "@blok/runner";
+
+export default class TestNode extends BlokService {
+  async handle(ctx: any, input: any) {
+    return { success: true };
+  }
+}
+      `;
+            const context = {
+                filePath: "/tmp/class-node.ts",
+                nodeStyle: "function",
+                content: classBasedCode,
+            };
+            const result = validateFunctionFirstStructure(context);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toBeDefined();
+            expect(result.errors.some((err) => err.includes("defineNode"))).toBe(true);
+        });
+        it("should fail for node missing execute function", () => {
+            const incompleteCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "incomplete-node",
+  description: "A node without implementation",
+
+  input: z.string(),
+  output: z.string(),
+});
+      `;
+            const context = {
+                filePath: "/tmp/incomplete-node.ts",
+                nodeStyle: "function",
+                content: incompleteCode,
+            };
+            const result = validateFunctionFirstStructure(context);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toBeDefined();
+            expect(result.errors.some((err) => err.includes("execute"))).toBe(true);
+        });
+        it("should fail for node missing name property", () => {
+            const invalidCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  description: "Missing name property",
+
+  input: z.string(),
+  output: z.string(),
+
+  async execute(ctx, input) {
+    return input;
+  },
+});
+      `;
+            const context = {
+                filePath: "/tmp/no-name-node.ts",
+                nodeStyle: "function",
+                content: invalidCode,
+            };
+            const result = validateFunctionFirstStructure(context);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toBeDefined();
+            expect(result.errors.some((err) => err.includes("name"))).toBe(true);
+        });
+        it("should fail for node missing description property", () => {
+            const invalidCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "no-description",
+
+  input: z.string(),
+  output: z.string(),
+
+  async execute(ctx, input) {
+    return input;
+  },
+});
+      `;
+            const context = {
+                filePath: "/tmp/no-desc-node.ts",
+                nodeStyle: "function",
+                content: invalidCode,
+            };
+            const result = validateFunctionFirstStructure(context);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toBeDefined();
+            expect(result.errors.some((err) => err.includes("description"))).toBe(true);
+        });
+        it("should fail for node missing input schema", () => {
+            const invalidCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "no-input",
+  description: "Missing input schema",
+
+  output: z.string(),
+
+  async execute(ctx, input) {
+    return "test";
+  },
+});
+      `;
+            const context = {
+                filePath: "/tmp/no-input-node.ts",
+                nodeStyle: "function",
+                content: invalidCode,
+            };
+            const result = validateFunctionFirstStructure(context);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toBeDefined();
+            expect(result.errors.some((err) => err.includes("input"))).toBe(true);
+        });
+        it("should fail for node missing output schema", () => {
+            const invalidCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "no-output",
+  description: "Missing output schema",
+
+  input: z.string(),
+
+  async execute(ctx, input) {
+    return input;
+  },
+});
+      `;
+            const context = {
+                filePath: "/tmp/no-output-node.ts",
+                nodeStyle: "function",
+                content: invalidCode,
+            };
+            const result = validateFunctionFirstStructure(context);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toBeDefined();
+            expect(result.errors.some((err) => err.includes("output"))).toBe(true);
+        });
+        it("should pass for node with complex input/output schemas", () => {
+            const validCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "complex-node",
+  description: "Node with complex schemas",
+
+  input: z.object({
+    user: z.object({
+      id: z.string().uuid(),
+      email: z.string().email(),
+      age: z.number().int().positive(),
+    }),
+    filters: z.array(z.string()).optional(),
+    metadata: z.record(z.unknown()),
+  }),
+
+  output: z.union([
+    z.object({
+      success: z.literal(true),
+      data: z.unknown(),
+    }),
+    z.object({
+      success: z.literal(false),
+      error: z.string(),
+    }),
+  ]),
+
+  async execute(ctx, input) {
+    return {
+      success: true,
+      data: input.user,
+    };
+  },
+});
+      `;
+            const context = {
+                filePath: "/tmp/complex-node.ts",
+                nodeStyle: "function",
+                content: validCode,
+            };
+            const result = validateFunctionFirstStructure(context);
+            expect(result.valid).toBe(true);
+        });
+    });
+    describe("validateExports", () => {
+        it("should pass for valid default export", () => {
+            const validCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+export default defineNode({
+  name: "test",
+  description: "Test",
+  input: z.string(),
+  output: z.string(),
+  async execute(ctx, input) {
+    return input;
+  },
+});
+      `;
+            const context = {
+                filePath: "/tmp/export-test.ts",
+                nodeStyle: "function",
+                content: validCode,
+            };
+            const result = validateExports(context);
+            expect(result.valid).toBe(true);
+        });
+        it("should fail for missing default export", () => {
+            const invalidCode = `
+import { defineNode } from "@blok/runner";
+import { z } from "zod";
+
+const myNode = defineNode({
+  name: "test",
+  description: "Test",
+  input: z.string(),
+  output: z.string(),
+  async execute(ctx, input) {
+    return input;
+  },
+});
+
+// No default export
+export { myNode };
+      `;
+            const context = {
+                filePath: "/tmp/no-export-node.ts",
+                nodeStyle: "function",
+                content: invalidCode,
+            };
+            const result = validateExports(context);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toBeDefined();
+            expect(result.errors.some((err) => err.includes("default export"))).toBe(true);
+        });
+    });
+});

package/dist/commands/generate/validators/WorkflowValidator.d.ts

@@ -0,0 +1,6 @@
+export interface WorkflowValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export declare function validateWorkflow(jsonString: string): WorkflowValidationResult;