blokctl 0.2.0

package/dist/commands/generate/NodeFileWriter.js

@@ -0,0 +1,240 @@
+import * as fs from "node:fs";
+import os from "node:os";
+import * as path from "node:path";
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText } from "ai";
+import fsExtra from "fs-extra";
+import color from "picocolors";
+import generateNodeManifestSystemPrompt from "./prompts/create-node-manifest.system.js";
+import generateReadmeFromBlokService from "./prompts/create-readme.system.js";
+export default class NodeFileWriter {
+    nodeDependencies = [
+        "assert",
+        "async_hooks",
+        "buffer",
+        "child_process",
+        "cluster",
+        "console",
+        "constants",
+        "crypto",
+        "dgram",
+        "diagnostics_channel",
+        "dns",
+        "domain",
+        "events",
+        "fs",
+        "fs/promises",
+        "http",
+        "http2",
+        "https",
+        "inspector",
+        "module",
+        "net",
+        "os",
+        "path",
+        "perf_hooks",
+        "process",
+        "punycode",
+        "querystring",
+        "readline",
+        "repl",
+        "stream",
+        "stream/consumers",
+        "stream/promises",
+        "stream/web",
+        "string_decoder",
+        "sys",
+        "timers",
+        "timers/promises",
+        "tls",
+        "trace_events",
+        "tty",
+        "url",
+        "util",
+        "v8",
+        "vm",
+        "wasi",
+        "worker_threads",
+        "zlib",
+    ];
+    typesDependencies = [
+        "express",
+        "lodash",
+        "jest",
+        "mocha",
+        "chai",
+        "sinon",
+        "debug",
+        "cors",
+        "body-parser",
+        "cookie-parser",
+        "jsonwebtoken",
+        "multer",
+        "morgan",
+        "passport",
+        "uuid",
+        "pg",
+        "mysql",
+        "mysql2",
+        "mongodb",
+        "node-fetch",
+        "ws",
+        "socket.io",
+        "redis",
+        "react",
+        "react-dom",
+        "jquery",
+        "next",
+        "yargs",
+        "commander",
+        "dotenv",
+        "formidable",
+        "glob",
+        "jsonwebtoken",
+        "validator",
+        "connect",
+        "request",
+        "supertest",
+        "node-schedule",
+    ];
+    async generateFile(nodeName, nodeType, fileContent, apiKey, nodeStyle = "class") {
+        try {
+            const dirName = nodeName.toLowerCase().replace(/\s+/g, "-");
+            const dirPath = process.cwd();
+            const nodeDir = `${dirPath}/src/nodes`;
+            const HOME_DIR = `${os.homedir()}/.blok`;
+            const GITHUB_REPO_LOCAL = `${HOME_DIR}/blok`;
+            if (!fs.existsSync(nodeDir)) {
+                throw new Error("The nodes directory does not exist. Please ensure you are in the correct project directory.");
+            }
+            const currentDir = `${nodeDir}/${dirName}`;
+            if (!fs.existsSync(currentDir)) {
+                fs.mkdirSync(currentDir, { recursive: true });
+            }
+            const filePath = path.join(currentDir, "index.ts");
+            if (nodeType === "module") {
+                console.log("\n\nCreating required files for a module-type node.");
+                console.log("- index.ts");
+                console.log("- config.json");
+                console.log("- README.md");
+                console.log("- package.json\n");
+                if (nodeStyle === "function") {
+                    fsExtra.copySync(`${GITHUB_REPO_LOCAL}/templates/node-function`, currentDir);
+                    console.log(color.cyan("✨ Using function-first template (defineNode API)\n"));
+                }
+                else {
+                    fsExtra.copySync(`${GITHUB_REPO_LOCAL}/templates/node`, currentDir);
+                }
+                fs.writeFileSync(filePath, fileContent, "utf8");
+                const configFileContent = fs.readFileSync(`${currentDir}/config.json`, "utf8");
+                const openai = createOpenAI({
+                    compatibility: "strict",
+                    apiKey: apiKey,
+                });
+                const config = await generateText({
+                    model: openai("gpt-4o"),
+                    system: `${generateNodeManifestSystemPrompt.prompt} \n${configFileContent}`,
+                    prompt: `Node information:
+
+Name: ${nodeName} (This is the key in the nodes object)
+Source Code:
+${fileContent}
+
+Take the class name from the source code and use it to register the node in Nodes.ts.`,
+                    temperature: 0.2,
+                });
+                let cleaned = config.text.replace(/^```json\s*([\s\S]*?)\s*```$/gm, "$1");
+                fs.writeFileSync(`${currentDir}/config.json`, cleaned, "utf8");
+                const readme = await generateText({
+                    model: openai("gpt-4o"),
+                    system: `${generateReadmeFromBlokService.prompt} \n${configFileContent}`,
+                    prompt: `Node information:
+
+Name: ${nodeName} (This is the key in the nodes object)
+Source Code:
+${fileContent}
+
+Take the class name from the source code and use it to register the node in Nodes.ts.`,
+                    temperature: 0.2,
+                });
+                cleaned = readme.text.replace(/^```markdown\s*([\s\S]*?)\s*```$/gm, "$1");
+                fs.writeFileSync(`${currentDir}/README.md`, cleaned, "utf8");
+                const packageJsonPath = `${currentDir}/package.json`;
+                const packageJsonContent = fs.readFileSync(packageJsonPath, "utf8");
+                const packageJson = JSON.parse(packageJsonContent);
+                packageJson.name = nodeName;
+                packageJson.description = `A BlokService node for ${nodeName}`;
+                packageJson.version = "1.0.0";
+                let hasDependencies = false;
+                const dependencies = fileContent.match(/import\s+.*?\s+from\s+['"](.*?)['"]/g);
+                const installedDependencies = [];
+                if (nodeStyle === "function") {
+                    packageJson.dependencies = packageJson.dependencies || {};
+                    if (!packageJson.dependencies.zod) {
+                        packageJson.dependencies.zod = "^3.24.1";
+                        installedDependencies.push({
+                            name: "zod",
+                            version: "^3.24.1",
+                        });
+                    }
+                }
+                if (dependencies) {
+                    const depList = dependencies
+                        .map((dep) => {
+                        const match = dep.match(/['"](.*?)['"]/);
+                        return match ? match[1] : null;
+                    })
+                        .filter((dep) => dep !== null);
+                    packageJson.dependencies = packageJson.dependencies || {};
+                    for (const dep of depList) {
+                        if (!packageJson.dependencies[dep] && !this.nodeDependencies.includes(dep)) {
+                            packageJson.dependencies[dep] = "latest";
+                            installedDependencies.push({
+                                name: dep,
+                                version: "latest",
+                            });
+                        }
+                        if (this.typesDependencies.includes(dep) &&
+                            (!packageJson.devDependencies || !packageJson.devDependencies[`@types/${dep}`])) {
+                            packageJson.devDependencies = packageJson.devDependencies || {};
+                            packageJson.devDependencies[`@types/${dep}`] = "latest";
+                        }
+                    }
+                }
+                fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf8");
+                if (installedDependencies.length > 0) {
+                    const packageJsonDirPath = `${dirPath}/package.json`;
+                    const packageJsonDirContent = fs.readFileSync(packageJsonDirPath, "utf8");
+                    const packageJsonDir = JSON.parse(packageJsonDirContent);
+                    console.log("\n");
+                    for (const dep of installedDependencies) {
+                        if (!packageJsonDir.dependencies[dep.name] && !this.nodeDependencies.includes(dep.name)) {
+                            packageJsonDir.dependencies[dep.name] = dep.version;
+                            console.log(color.blue(`Added dependency "${dep.name}": "${dep.version}".`));
+                            hasDependencies = true;
+                        }
+                        if (this.typesDependencies.includes(dep.name) &&
+                            (!packageJsonDir.devDependencies || !packageJsonDir.devDependencies[`@types/${dep.name}`])) {
+                            packageJsonDir.devDependencies = packageJsonDir.devDependencies || {};
+                            packageJsonDir.devDependencies[`@types/${dep.name}`] = "latest";
+                            console.log(color.cyan(`Added dev dependency "@types/${dep.name}": "latest".`));
+                            hasDependencies = true;
+                        }
+                    }
+                    fs.writeFileSync(packageJsonDirPath, JSON.stringify(packageJsonDir, null, 2), "utf8");
+                    if (hasDependencies) {
+                        console.log(color.blue("Run `npm install` to install the new dependencies.\n"));
+                    }
+                }
+            }
+            else {
+                fs.writeFileSync(filePath, fileContent, "utf8");
+            }
+            return filePath;
+        }
+        catch (error) {
+            console.error(`Error generating file: ${error.message}`);
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+type NodeInformation = {
+    nodeName: string;
+    userPrompt: string;
+    code: string;
+    validationResult?: {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+        attempts: number;
+        promptVersion?: string;
+        durationMs?: number;
+    };
+};
+export type { NodeInformation };
+export default class NodeGenerator {
+    private readonly MAX_VALIDATION_ATTEMPTS;
+    generateNode(nodeName: string, userPrompt: string, apiKey: string, update?: boolean, nodeStyle?: string): Promise<NodeInformation>;
+    private createFeedbackPrompt;
+    private getSemanticGuidance;
+}

package/dist/commands/generate/NodeGenerator.js

@@ -0,0 +1,181 @@
+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";
+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,
+        });
+        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();
+            const nodeDir = `${dirPath}/src/nodes`;
+            const currentDir = `${nodeDir}/${dirName}`;
+            const filePath = `${currentDir}/index.ts`;
+            existingCode = fs.readFileSync(filePath, "utf8");
+            prompt = `${promptTemplate.updatePrompt} \n\n ${existingCode}`;
+        }
+        let attempts = 0;
+        let generatedCode = "";
+        let validationErrors = [];
+        let validationWarnings = [];
+        let isValid = false;
+        const allErrors = [];
+        while (attempts < this.MAX_VALIDATION_ATTEMPTS && !isValid) {
+            attempts++;
+            let finalPrompt = userPrompt;
+            if (attempts > 1 && validationErrors.length > 0) {
+                finalPrompt = this.createFeedbackPrompt(userPrompt, generatedCode, validationErrors);
+            }
+            const { text } = await generateText({
+                model: openai("gpt-4o"),
+                system: prompt,
+                prompt: finalPrompt,
+                temperature: 0.2,
+            });
+            generatedCode = text;
+            const compilationResult = CompilationValidator.validateCode(generatedCode, `${nodeName}.ts`);
+            validationErrors = compilationResult.errors;
+            validationWarnings = compilationResult.warnings;
+            isValid = compilationResult.success;
+            if (isValid && nodeStyle === "function") {
+                const context = {
+                    filePath: `${nodeName}.ts`,
+                    nodeStyle: "function",
+                    content: generatedCode,
+                };
+                const structureResult = NodeValidator.validateFunctionFirstStructure(context);
+                if (!structureResult.valid) {
+                    isValid = false;
+                    validationErrors.push(...structureResult.errors);
+                    validationWarnings.push(...structureResult.warnings);
+                }
+            }
+            allErrors.push(...validationErrors);
+            if (!isValid && attempts < this.MAX_VALIDATION_ATTEMPTS) {
+                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,
+            code: generatedCode,
+            validationResult: {
+                valid: isValid,
+                errors: validationErrors,
+                warnings: validationWarnings,
+                attempts,
+                promptVersion,
+                durationMs,
+            },
+        };
+    }
+    createFeedbackPrompt(originalPrompt, previousCode, errors) {
+        const analyzedErrors = errors.map((err, i) => {
+            const guidance = this.getSemanticGuidance(err);
+            return `${i + 1}. ${err}${guidance ? `\n   💡 Fix: ${guidance}` : ""}`;
+        });
+        const feedback = [
+            originalPrompt,
+            "",
+            "❌ The previous generation had validation errors. Here's what went wrong and how to fix it:",
+            "",
+            ...analyzedErrors,
+            "",
+            "Previous code:",
+            "```typescript",
+            previousCode,
+            "```",
+            "",
+            "Please fix ALL the errors listed above and regenerate the complete code.",
+            "Make sure to:",
+            "- Import defineNode from '@blok/runner'",
+            "- Import z from 'zod'",
+            "- Import Context type from '@blok/shared'",
+            "- Use z.object({...}) for input and output schemas",
+            "- Make the execute function async",
+            "- Export as default: export default defineNode({...})",
+            "- Return a plain object matching the output schema (no BlokResponse)",
+        ].join("\n");
+        return feedback;
+    }
+    getSemanticGuidance(error) {
+        const errorLower = error.toLowerCase();
+        if (errorLower.includes("missing") && errorLower.includes("definenode")) {
+            return "Add: import { defineNode } from '@blok/runner';";
+        }
+        if (errorLower.includes("missing") && errorLower.includes("zod")) {
+            return "Add: import { z } from 'zod';";
+        }
+        if (errorLower.includes("cannot find") && errorLower.includes("definenode")) {
+            return "Ensure defineNode is imported from '@blok/runner'";
+        }
+        if (errorLower.includes("z.object") || errorLower.includes("zod schema")) {
+            return "Use z.object({...}) for both input and output schemas with proper Zod types";
+        }
+        if (errorLower.includes("execute") && errorLower.includes("async")) {
+            return "The execute function must be async: async execute(ctx, input) { ... }";
+        }
+        if (errorLower.includes("execute") && errorLower.includes("missing")) {
+            return "Add execute property: async execute(ctx, input) { return { ... }; }";
+        }
+        if (errorLower.includes("export") && errorLower.includes("default")) {
+            return "Use: export default defineNode({...}) at the end of the file";
+        }
+        if (errorLower.includes("type") && errorLower.includes("not assignable")) {
+            return "Check that the return type of execute() matches the output Zod schema exactly";
+        }
+        if (errorLower.includes("blokresponse") || errorLower.includes("setsuccess")) {
+            return "Do NOT use BlokResponse in function-first nodes. Just return a plain object.";
+        }
+        if (errorLower.includes("ctx.request") || errorLower.includes("context")) {
+            return "Use ctx.request.body, ctx.request.query, ctx.request.params for HTTP data; ctx.vars for cross-node data";
+        }
+        if (errorLower.includes("cannot find module") || errorLower.includes("module not found")) {
+            return "Check import paths. Use '@blok/runner' for defineNode and '@blok/shared' for Context/GlobalError";
+        }
+        if (errorLower.includes("property") && errorLower.includes("does not exist")) {
+            return "Verify property names match your Zod schemas. Use z.infer<typeof schema> for type inference.";
+        }
+        if (errorLower.includes("name") && errorLower.includes("missing")) {
+            return "Add a 'name' property with a kebab-case identifier, e.g., name: 'my-node'";
+        }
+        if (errorLower.includes("description") && errorLower.includes("missing")) {
+            return "Add a 'description' property describing what the node does";
+        }
+        if (errorLower.includes("duplicate identifier") || errorLower.includes("already declared")) {
+            return "Remove duplicate variable/function declarations. Each identifier must be unique in its scope.";
+        }
+        if (errorLower.includes("implicit") && errorLower.includes("any")) {
+            return "Add explicit type annotations. Use z.infer<typeof inputSchema> for input types.";
+        }
+        return null;
+    }
+}

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

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

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

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import NodeGenerator from "./NodeGenerator.js";
+describe("NodeGenerator", () => {
+    describe("getSemanticGuidance (via reflection)", () => {
+        const generator = new NodeGenerator();
+        const getGuidance = (error) => generator.getSemanticGuidance(error);
+        it("should provide guidance for missing defineNode import", () => {
+            const guidance = getGuidance("Missing defineNode import");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("defineNode");
+            expect(guidance).toContain("@blok/runner");
+        });
+        it("should provide guidance for missing Zod import", () => {
+            const guidance = getGuidance("Missing zod import");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("zod");
+        });
+        it("should provide guidance for cannot find defineNode", () => {
+            const guidance = getGuidance("Cannot find name 'defineNode'");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("defineNode");
+        });
+        it("should provide guidance for Zod schema issues", () => {
+            const guidance = getGuidance("Missing z.object() for input schema");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("z.object");
+        });
+        it("should provide guidance for missing async execute", () => {
+            const guidance = getGuidance("Execute function must be async");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("async");
+        });
+        it("should provide guidance for missing execute function", () => {
+            const guidance = getGuidance("Missing execute property");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("execute");
+        });
+        it("should provide guidance for missing default export", () => {
+            const guidance = getGuidance("Missing export default");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("export default");
+        });
+        it("should provide guidance for type not assignable errors", () => {
+            const guidance = getGuidance("Type 'string' is not assignable to type 'number'");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("output Zod schema");
+        });
+        it("should provide guidance for BlokResponse misuse", () => {
+            const guidance = getGuidance("Do not use BlokResponse in function-first nodes");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("plain object");
+        });
+        it("should provide guidance for setSuccess misuse", () => {
+            const guidance = getGuidance("response.setSuccess is not needed");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("plain object");
+        });
+        it("should provide guidance for module not found", () => {
+            const guidance = getGuidance("Cannot find module '@blok/core'");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("import paths");
+        });
+        it("should provide guidance for context access patterns", () => {
+            const guidance = getGuidance("Property 'request' does not exist on type 'Context'");
+            expect(guidance).not.toBeNull();
+            expect(guidance).toContain("ctx.request");
+        });
+        it("should return null for unknown error patterns", () => {
+            const guidance = getGuidance("Some random error that doesn't match any pattern");
+            expect(guidance).toBeNull();
+        });
+    });
+    describe("createFeedbackPrompt (via reflection)", () => {
+        const generator = new NodeGenerator();
+        const createFeedback = (originalPrompt, previousCode, errors) => generator.createFeedbackPrompt(originalPrompt, previousCode, errors);
+        it("should include original prompt", () => {
+            const result = createFeedback("Create a user fetcher node", "code", ["error"]);
+            expect(result).toContain("Create a user fetcher node");
+        });
+        it("should include all errors with semantic guidance", () => {
+            const errors = ["Missing defineNode import", "Missing zod import"];
+            const result = createFeedback("test", "code", errors);
+            expect(result).toContain("Missing defineNode import");
+            expect(result).toContain("Missing zod import");
+            expect(result).toContain("Fix:");
+        });
+        it("should include previous code for context", () => {
+            const code = "const x = 42;";
+            const result = createFeedback("test", code, ["error"]);
+            expect(result).toContain(code);
+        });
+        it("should include checklist of common requirements", () => {
+            const result = createFeedback("test", "code", ["error"]);
+            expect(result).toContain("defineNode");
+            expect(result).toContain("zod");
+            expect(result).toContain("export default");
+            expect(result).toContain("z.object");
+            expect(result).toContain("async");
+        });
+    });
+});

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

@@ -0,0 +1,25 @@
+export interface PromptVersion {
+    id: string;
+    version: string;
+    changelog: string;
+    createdAt: string;
+    contentHash: string;
+}
+export interface PromptRegistry {
+    [promptId: string]: PromptVersion;
+}
+export declare const PROMPT_VERSIONS: PromptRegistry;
+export declare function computeContentHash(content: string): string;
+export declare function getPromptVersion(promptId: string): PromptVersion | undefined;
+export declare function getAllPromptVersions(): PromptVersion[];
+export declare function getVersionStamp(promptId: string): string;
+export declare function registerPromptContent(promptId: string, content: string): void;
+declare const _default: {
+    PROMPT_VERSIONS: PromptRegistry;
+    getPromptVersion: typeof getPromptVersion;
+    getAllPromptVersions: typeof getAllPromptVersions;
+    getVersionStamp: typeof getVersionStamp;
+    computeContentHash: typeof computeContentHash;
+    registerPromptContent: typeof registerPromptContent;
+};
+export default _default;

package/dist/commands/generate/PromptVersioning.js

@@ -0,0 +1,71 @@
+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.d.ts

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