blokctl 0.6.20 → 0.7.0

package/dist/commands/generate/PromptVersioning.js

@@ -1,71 +0,0 @@
-export const PROMPT_VERSIONS = {
-    "create-fn-node": {
-        id: "create-fn-node",
-        version: "2.0.0",
-        changelog: "Function-first defineNode pattern with Zod schemas, 2 real-world examples",
-        createdAt: "2026-01-28T00:00:00Z",
-        contentHash: "",
-    },
-    "create-node": {
-        id: "create-node",
-        version: "1.0.0",
-        changelog: "Class-based BlokService pattern with GlobalError handling",
-        createdAt: "2026-01-27T00:00:00Z",
-        contentHash: "",
-    },
-    "create-workflow": {
-        id: "create-workflow",
-        version: "2.0.0",
-        changelog: "7 trigger types (HTTP, Queue, Pub/Sub, Cron, Webhook, WebSocket, SSE), 4 examples",
-        createdAt: "2026-01-28T00:00:00Z",
-        contentHash: "",
-    },
-    "create-trigger": {
-        id: "create-trigger",
-        version: "2.0.0",
-        changelog: "TriggerBase architecture, 6 trigger type examples, context creation pattern",
-        createdAt: "2026-01-28T00:00:00Z",
-        contentHash: "",
-    },
-    "create-runtime": {
-        id: "create-runtime",
-        version: "1.0.0",
-        changelog: "Runtime SDK generation for Go, Java, Rust, Python, C#, PHP, Ruby with HTTP protocol",
-        createdAt: "2026-01-28T00:00:00Z",
-        contentHash: "",
-    },
-};
-export function computeContentHash(content) {
-    let hash = 0;
-    for (let i = 0; i < content.length; i++) {
-        const char = content.charCodeAt(i);
-        hash = ((hash << 5) - hash + char) | 0;
-    }
-    return Math.abs(hash).toString(36);
-}
-export function getPromptVersion(promptId) {
-    return PROMPT_VERSIONS[promptId];
-}
-export function getAllPromptVersions() {
-    return Object.values(PROMPT_VERSIONS);
-}
-export function getVersionStamp(promptId) {
-    const version = PROMPT_VERSIONS[promptId];
-    if (!version)
-        return `${promptId}@unknown`;
-    return `${version.id}@${version.version}`;
-}
-export function registerPromptContent(promptId, content) {
-    const version = PROMPT_VERSIONS[promptId];
-    if (version) {
-        version.contentHash = computeContentHash(content);
-    }
-}
-export default {
-    PROMPT_VERSIONS,
-    getPromptVersion,
-    getAllPromptVersions,
-    getVersionStamp,
-    computeContentHash,
-    registerPromptContent,
-};

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

@@ -1,120 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { PROMPT_VERSIONS, computeContentHash, getAllPromptVersions, getPromptVersion, getVersionStamp, registerPromptContent, } from "./PromptVersioning.js";
-describe("PromptVersioning", () => {
-    describe("PROMPT_VERSIONS registry", () => {
-        it("should have entries for all prompt types", () => {
-            expect(PROMPT_VERSIONS["create-fn-node"]).toBeDefined();
-            expect(PROMPT_VERSIONS["create-node"]).toBeDefined();
-            expect(PROMPT_VERSIONS["create-workflow"]).toBeDefined();
-            expect(PROMPT_VERSIONS["create-trigger"]).toBeDefined();
-        });
-        it("should have valid version strings for all entries", () => {
-            for (const [id, version] of Object.entries(PROMPT_VERSIONS)) {
-                expect(version.version).toMatch(/^\d+\.\d+\.\d+$/);
-                expect(version.id).toBe(id);
-                expect(version.changelog).toBeTruthy();
-                expect(version.createdAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-            }
-        });
-        it("should have function-first node at v2.0.0 with defineNode pattern", () => {
-            const fnNode = PROMPT_VERSIONS["create-fn-node"];
-            expect(fnNode.version).toBe("2.0.0");
-            expect(fnNode.changelog).toContain("defineNode");
-        });
-        it("should have workflow prompt at v2.0.0 with trigger types", () => {
-            const workflow = PROMPT_VERSIONS["create-workflow"];
-            expect(workflow.version).toBe("2.0.0");
-            expect(workflow.changelog).toContain("trigger");
-        });
-        it("should have trigger prompt at v2.0.0 with TriggerBase", () => {
-            const trigger = PROMPT_VERSIONS["create-trigger"];
-            expect(trigger.version).toBe("2.0.0");
-            expect(trigger.changelog).toContain("TriggerBase");
-        });
-    });
-    describe("getPromptVersion", () => {
-        it("should return version for known prompt ID", () => {
-            const version = getPromptVersion("create-fn-node");
-            expect(version).toBeDefined();
-            expect(version.id).toBe("create-fn-node");
-        });
-        it("should return undefined for unknown prompt ID", () => {
-            const version = getPromptVersion("nonexistent-prompt");
-            expect(version).toBeUndefined();
-        });
-    });
-    describe("getAllPromptVersions", () => {
-        it("should return all registered prompt versions", () => {
-            const versions = getAllPromptVersions();
-            expect(versions.length).toBeGreaterThanOrEqual(4);
-        });
-        it("should include all known prompt IDs", () => {
-            const versions = getAllPromptVersions();
-            const ids = versions.map((v) => v.id);
-            expect(ids).toContain("create-fn-node");
-            expect(ids).toContain("create-node");
-            expect(ids).toContain("create-workflow");
-            expect(ids).toContain("create-trigger");
-        });
-    });
-    describe("getVersionStamp", () => {
-        it("should return formatted version stamp for known prompt", () => {
-            const stamp = getVersionStamp("create-fn-node");
-            expect(stamp).toBe("create-fn-node@2.0.0");
-        });
-        it("should return unknown stamp for unregistered prompt", () => {
-            const stamp = getVersionStamp("unknown-prompt");
-            expect(stamp).toBe("unknown-prompt@unknown");
-        });
-        it("should return stamps in id@version format", () => {
-            for (const [id, version] of Object.entries(PROMPT_VERSIONS)) {
-                const stamp = getVersionStamp(id);
-                expect(stamp).toBe(`${id}@${version.version}`);
-            }
-        });
-    });
-    describe("computeContentHash", () => {
-        it("should return a non-empty string", () => {
-            const hash = computeContentHash("test content");
-            expect(hash).toBeTruthy();
-            expect(typeof hash).toBe("string");
-        });
-        it("should return consistent hash for same content", () => {
-            const hash1 = computeContentHash("hello world");
-            const hash2 = computeContentHash("hello world");
-            expect(hash1).toBe(hash2);
-        });
-        it("should return different hashes for different content", () => {
-            const hash1 = computeContentHash("content A");
-            const hash2 = computeContentHash("content B");
-            expect(hash1).not.toBe(hash2);
-        });
-        it("should handle empty string", () => {
-            const hash = computeContentHash("");
-            expect(hash).toBe("0");
-        });
-        it("should handle long content", () => {
-            const longContent = "a".repeat(10000);
-            const hash = computeContentHash(longContent);
-            expect(hash).toBeTruthy();
-        });
-    });
-    describe("registerPromptContent", () => {
-        it("should compute and store content hash for known prompt", () => {
-            registerPromptContent("create-fn-node", "test prompt content");
-            const version = getPromptVersion("create-fn-node");
-            expect(version.contentHash).toBeTruthy();
-            expect(version.contentHash).toBe(computeContentHash("test prompt content"));
-        });
-        it("should not throw for unknown prompt ID", () => {
-            expect(() => registerPromptContent("nonexistent", "content")).not.toThrow();
-        });
-        it("should update hash when content changes", () => {
-            registerPromptContent("create-node", "content v1");
-            const hash1 = getPromptVersion("create-node").contentHash;
-            registerPromptContent("create-node", "content v2");
-            const hash2 = getPromptVersion("create-node").contentHash;
-            expect(hash1).not.toBe(hash2);
-        });
-    });
-});