blokctl 0.6.15 → 0.6.17

package/dist/commands/create/project.js

@@ -17,7 +17,7 @@ const exec = util.promisify(child_process.exec);
 const HOME_DIR = `${os.homedir()}/.blok`;
 const GITHUB_REPO_LOCAL = `${HOME_DIR}/blok`;
 const GITHUB_REPO_REMOTE = "https://github.com/well-prado/blok.git";
-const GITHUB_REPO_RELEASE_TAG = "v0.6.15";
+const GITHUB_REPO_RELEASE_TAG = "v0.6.17";
 fsExtra.ensureDirSync(HOME_DIR);
 const options = {
     baseDir: HOME_DIR,
@@ -487,7 +487,7 @@ export async function createProject(opts, version, currentPath = false, localRep
             "@blokjs/trigger-websocket": "triggers/websocket",
             "@blokjs/trigger-worker": "triggers/worker",
         };
-        const BLOKJS_DEP_RANGE = "^0.6.15";
+        const BLOKJS_DEP_RANGE = "^0.6.17";
         for (const depGroup of ["dependencies", "devDependencies", "peerDependencies"]) {
             const deps = packageJsonContent[depGroup];
             if (!deps)

package/dist/commands/gen/appTypes.d.ts

@@ -0,0 +1,13 @@
+import type { OptionValues } from "commander";
+export interface WorkflowEntry {
+    name: string;
+    file: string;
+}
+export declare function extractWorkflowName(source: string): string | null;
+export declare function nameToIdentifier(name: string): string;
+export declare function importSpecifier(outFile: string, workflowFile: string): string;
+export declare function buildAppTypeSource(entries: readonly WorkflowEntry[], outFile: string): {
+    source: string;
+    collisions: string[];
+};
+export declare function generateAppTypes(opts: OptionValues): Promise<void>;

package/dist/commands/gen/appTypes.js

@@ -0,0 +1,195 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import color from "picocolors";
+export function extractWorkflowName(source) {
+    const stripped = source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+    const factory = /\b(?:workflow|Workflow)\s*\(/.exec(stripped);
+    if (!factory)
+        return null;
+    const rest = stripped.slice(factory.index);
+    const nameMatch = /\bname\s*:\s*(["'`])([^"'`]+)\1/.exec(rest);
+    return nameMatch ? nameMatch[2].trim() : null;
+}
+export function nameToIdentifier(name) {
+    const parts = name.split(/[^A-Za-z0-9]+/).filter(Boolean);
+    const camel = parts.map((p, i) => (i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1))).join("");
+    const safe = camel.length === 0 ? "wf" : camel;
+    return /^[0-9]/.test(safe) ? `wf_${safe}` : safe;
+}
+export function importSpecifier(outFile, workflowFile) {
+    let rel = path.relative(path.dirname(outFile), workflowFile).replace(/\\/g, "/").replace(/\.ts$/, "");
+    if (!rel.startsWith("."))
+        rel = `./${rel}`;
+    return rel;
+}
+function isLeaf(node) {
+    return typeof node.__leaf === "string";
+}
+export function buildAppTypeSource(entries, outFile) {
+    const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+    const collisions = [];
+    const usedIdents = new Map();
+    const imports = [];
+    const tree = {};
+    for (const entry of sorted) {
+        let ident = nameToIdentifier(entry.name);
+        if (usedIdents.has(ident) && usedIdents.get(ident) !== entry.name) {
+            let n = 2;
+            while (usedIdents.has(`${ident}${n}`))
+                n++;
+            ident = `${ident}${n}`;
+        }
+        usedIdents.set(ident, entry.name);
+        imports.push(`import type ${ident} from "${importSpecifier(outFile, entry.file)}";`);
+        const segments = entry.name.split(".").filter(Boolean);
+        let node = tree;
+        let collided = false;
+        for (let i = 0; i < segments.length; i++) {
+            const seg = segments[i];
+            const last = i === segments.length - 1;
+            if (last) {
+                if (node[seg] !== undefined) {
+                    collisions.push(entry.name);
+                    collided = true;
+                    break;
+                }
+                node[seg] = { __leaf: ident };
+            }
+            else {
+                const existing = node[seg];
+                if (existing === undefined) {
+                    const child = {};
+                    node[seg] = child;
+                    node = child;
+                }
+                else if (isLeaf(existing)) {
+                    collisions.push(entry.name);
+                    collided = true;
+                    break;
+                }
+                else {
+                    node = existing;
+                }
+            }
+        }
+        if (collided)
+            imports.pop();
+    }
+    const render = (node, indent) => {
+        const lines = ["{"];
+        for (const key of Object.keys(node).sort()) {
+            const child = node[key];
+            const k = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+            if (isLeaf(child)) {
+                lines.push(`${indent}\t${k}: ${child.__leaf};`);
+            }
+            else {
+                lines.push(`${indent}\t${k}: ${render(child, `${indent}\t`)};`);
+            }
+        }
+        lines.push(`${indent}}`);
+        return lines.join("\n");
+    };
+    const header = [
+        "// AUTO-GENERATED by `blokctl gen app-types`. Do not edit by hand.",
+        "// Regenerate after adding, removing, or renaming a workflow.",
+        "// Consumed by `@blokjs/client`: `createBlokClient<BlokApp>()`.",
+        "",
+    ].join("\n");
+    const body = imports.length === 0
+        ? "export type BlokApp = Record<string, never>;\n"
+        : `${imports.join("\n")}\n\nexport type BlokApp = ${render(tree, "")};\n`;
+    return { source: `${header}${body}`, collisions };
+}
+async function collectTsFiles(dir) {
+    const out = [];
+    let dirents;
+    try {
+        dirents = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const d of dirents) {
+        if (d.name.startsWith("_") || d.name.startsWith("."))
+            continue;
+        const full = path.join(dir, d.name);
+        if (d.isDirectory()) {
+            out.push(...(await collectTsFiles(full)));
+        }
+        else if (d.name.endsWith(".ts") &&
+            !d.name.endsWith(".test.ts") &&
+            !d.name.endsWith(".spec.ts") &&
+            !d.name.endsWith(".d.ts")) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+async function resolveWorkflowsDir(cwd, explicit) {
+    const candidates = explicit
+        ? [explicit]
+        : ["triggers/http/src/workflows", "src/workflows", "workflows/ts", "workflows"];
+    for (const c of candidates) {
+        const abs = path.isAbsolute(c) ? c : path.join(cwd, c);
+        try {
+            const stat = await fsp.stat(abs);
+            if (stat.isDirectory())
+                return abs;
+        }
+        catch {
+        }
+    }
+    return null;
+}
+export async function generateAppTypes(opts) {
+    const cwd = process.cwd();
+    const explicitDir = opts.dir ?? null;
+    console.log(color.cyan("\n🧬 Blok app-types generator"));
+    console.log(color.dim("Generates the typed `BlokApp` index consumed by @blokjs/client.\n"));
+    const dir = await resolveWorkflowsDir(cwd, explicitDir);
+    if (!dir) {
+        console.log(color.red("❌ Could not find a TS workflows directory. Looked in: triggers/http/src/workflows/, " +
+            "src/workflows/, workflows/. Pass --dir <path> to override."));
+        process.exit(1);
+        return;
+    }
+    const outFile = path.isAbsolute(opts.out ?? "")
+        ? opts.out
+        : path.join(cwd, opts.out ?? "blok-app.d.ts");
+    console.log(color.dim(`Scanning ${color.cyan(dir)} (recursive)\n`));
+    const files = await collectTsFiles(dir);
+    const entries = [];
+    const skipped = [];
+    for (const file of files) {
+        const src = await fsp.readFile(file, "utf8");
+        const name = extractWorkflowName(src);
+        if (name)
+            entries.push({ name, file });
+        else
+            skipped.push(path.relative(cwd, file));
+    }
+    if (entries.length === 0) {
+        console.log(color.yellow("No TS workflows with a literal `name:` found — nothing to generate."));
+        if (skipped.length > 0)
+            console.log(color.dim(`Skipped (no literal name): ${skipped.join(", ")}`));
+        return;
+    }
+    const { source, collisions } = buildAppTypeSource(entries, outFile);
+    if (opts.dryRun === true) {
+        console.log(color.dim(`— dry run — would write ${color.cyan(path.relative(cwd, outFile))}:\n`));
+        console.log(source);
+    }
+    else {
+        await fsp.mkdir(path.dirname(outFile), { recursive: true });
+        await fsp.writeFile(outFile, source, "utf8");
+        console.log(color.green(`✅ Wrote ${color.cyan(path.relative(cwd, outFile))} (${entries.length} workflow(s)).`));
+    }
+    for (const c of collisions) {
+        console.log(color.yellow(`⚠️  name collision — "${c}" overlaps another workflow's path and was dropped.`));
+    }
+    if (skipped.length > 0) {
+        console.log(color.dim(`ℹ️  Skipped ${skipped.length} file(s) without a literal workflow name (dynamic name or not a workflow): ${skipped.join(", ")}`));
+    }
+    console.log(color.dim('\nNext: `import type { BlokApp } from "<out>"` and `createBlokClient<BlokApp>({ baseUrl })`.\n'));
+}

package/dist/commands/gen/appTypes.test.d.ts

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

package/dist/commands/gen/appTypes.test.js

@@ -0,0 +1,116 @@
+import { promises as fsp } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { buildAppTypeSource, extractWorkflowName, generateAppTypes, importSpecifier, nameToIdentifier, } from "./appTypes.js";
+describe("extractWorkflowName", () => {
+    it("extracts the name from a v2 workflow() factory call", () => {
+        const src = `import { workflow } from "@blokjs/helper";
+export default workflow({ name: "users.list", version: "1.0.0", trigger: { http: { method: "GET" } }, steps: [{ id: "s", use: "@blokjs/respond", inputs: {} }] });`;
+        expect(extractWorkflowName(src)).toBe("users.list");
+    });
+    it("handles the legacy Workflow() factory and single quotes", () => {
+        expect(extractWorkflowName("const x = Workflow({ name: 'orders.create' })")).toBe("orders.create");
+    });
+    it("anchors on the factory call, not a step/node `name:`", () => {
+        const src = `export default workflow({
+			name: "the.workflow",
+			steps: [{ id: "x", use: "n", inputs: { name: "not-the-workflow" } }],
+		});`;
+        expect(extractWorkflowName(src)).toBe("the.workflow");
+    });
+    it("ignores a commented-out name", () => {
+        const src = `// name: "commented"
+		/* name: "blocked" */
+		export default workflow({ name: "real.name" });`;
+        expect(extractWorkflowName(src)).toBe("real.name");
+    });
+    it("returns null when there is no workflow factory call", () => {
+        expect(extractWorkflowName(`export const x = { name: "not.a.workflow" };`)).toBeNull();
+    });
+    it("returns null when the name is a non-literal (variable)", () => {
+        expect(extractWorkflowName(`export default workflow({ name: WF_NAME, version: "1" })`)).toBeNull();
+    });
+});
+describe("nameToIdentifier", () => {
+    it("camelCases a dotted name", () => {
+        expect(nameToIdentifier("users.list")).toBe("usersList");
+        expect(nameToIdentifier("a.b.c")).toBe("aBC");
+    });
+    it("passes a single segment through", () => {
+        expect(nameToIdentifier("health")).toBe("health");
+    });
+    it("prefixes identifiers that would start with a digit", () => {
+        expect(nameToIdentifier("2fa.verify")).toBe("wf_2faVerify");
+    });
+});
+describe("importSpecifier", () => {
+    it("computes a relative, extensionless, ./-prefixed specifier", () => {
+        const spec = importSpecifier("/proj/blok-app.d.ts", "/proj/triggers/http/src/workflows/users/list.ts");
+        expect(spec).toBe("./triggers/http/src/workflows/users/list");
+    });
+    it("emits ../ when the workflow is above the output dir", () => {
+        const spec = importSpecifier("/proj/web/blok-app.d.ts", "/proj/server/workflows/health.ts");
+        expect(spec).toBe("../server/workflows/health");
+    });
+});
+describe("buildAppTypeSource", () => {
+    const out = "/proj/blok-app.d.ts";
+    it("nests workflows by their dotted name and imports each by file", () => {
+        const entries = [
+            { name: "users.list", file: "/proj/wf/users/list.ts" },
+            { name: "users.create", file: "/proj/wf/users/create.ts" },
+            { name: "health", file: "/proj/wf/health.ts" },
+        ];
+        const { source, collisions } = buildAppTypeSource(entries, out);
+        expect(collisions).toEqual([]);
+        expect(source).toContain('import type usersList from "./wf/users/list";');
+        expect(source).toContain('import type usersCreate from "./wf/users/create";');
+        expect(source).toContain('import type health from "./wf/health";');
+        expect(source).toContain("export type BlokApp = {");
+        expect(source).toContain("users: {");
+        expect(source).toContain("list: usersList;");
+        expect(source).toContain("create: usersCreate;");
+        expect(source).toContain("health: health;");
+    });
+    it("flags a leaf-vs-group collision and drops the loser", () => {
+        const entries = [
+            { name: "users", file: "/proj/wf/users.ts" },
+            { name: "users.list", file: "/proj/wf/users/list.ts" },
+        ];
+        const { collisions } = buildAppTypeSource(entries, out);
+        expect(collisions.length).toBe(1);
+    });
+    it("quotes non-identifier path segments", () => {
+        const { source } = buildAppTypeSource([{ name: "weird-name.go", file: "/proj/wf/x.ts" }], out);
+        expect(source).toContain('"weird-name":');
+    });
+    it("emits an empty-but-valid type when there are no workflows", () => {
+        const { source } = buildAppTypeSource([], out);
+        expect(source).toContain("export type BlokApp = Record<string, never>;");
+    });
+});
+describe("generateAppTypes (fs integration)", () => {
+    const tmpDirs = [];
+    afterEach(async () => {
+        for (const d of tmpDirs)
+            await fsp.rm(d, { recursive: true, force: true });
+        tmpDirs.length = 0;
+    });
+    it("scans a workflows dir and writes blok-app.d.ts", async () => {
+        const root = await fsp.mkdtemp(path.join(os.tmpdir(), "blok-gen-"));
+        tmpDirs.push(root);
+        const wfDir = path.join(root, "workflows", "users");
+        await fsp.mkdir(wfDir, { recursive: true });
+        await fsp.writeFile(path.join(wfDir, "list.ts"), `import { workflow } from "@blokjs/helper";
+export default workflow({ name: "users.list", version: "1.0.0", trigger: { http: { method: "GET" } }, steps: [] });`);
+        await fsp.writeFile(path.join(root, "workflows", "_helper.ts"), "export const x = 1;");
+        const out = path.join(root, "blok-app.d.ts");
+        await generateAppTypes({ dir: path.join(root, "workflows"), out });
+        const written = await fsp.readFile(out, "utf8");
+        expect(written).toContain("export type BlokApp = {");
+        expect(written).toContain("users: {");
+        expect(written).toContain("list: usersList;");
+        expect(written).toContain('import type usersList from "./workflows/users/list";');
+    });
+});

package/dist/commands/gen/index.d.ts

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

package/dist/commands/gen/index.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { program } from "../../services/commander.js";
+import { generateAppTypes } from "./appTypes.js";
+const gen = new Command("gen").description("Generate typed client artifacts for @blokjs/client");
+const appTypes = new Command("app-types")
+    .description("Generate the typed `BlokApp` index (blok-app.d.ts) from your TS workflow files")
+    .option("-d, --dir <value>", "TS workflows directory (defaults to triggers/http/src/workflows, src/workflows, or workflows)")
+    .option("-o, --out <value>", "Output file (default: ./blok-app.d.ts)")
+    .option("--dry-run", "Print the generated file without writing it")
+    .action(async (options) => {
+    await generateAppTypes(options);
+});
+gen.addCommand(appTypes);
+program.addCommand(gen);

package/dist/index.d.ts

@@ -8,6 +8,7 @@ import "./commands/publish/index.js";
 import "./commands/install/index.js";
 import "./commands/search/index.js";
 import "./commands/generate/index.js";
+import "./commands/gen/index.js";
 import "./commands/config/index.js";
 import "./commands/migrate/index.js";
 import "./commands/graph/index.js";

package/dist/index.js

@@ -23,6 +23,7 @@ import "./commands/publish/index.js";
 import "./commands/install/index.js";
 import "./commands/search/index.js";
 import "./commands/generate/index.js";
+import "./commands/gen/index.js";
 import "./commands/config/index.js";
 import "./commands/migrate/index.js";
 import "./commands/graph/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blokctl",
-	"version": "0.6.15",
+	"version": "0.6.17",
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"description": "cli for blok",
@@ -30,7 +30,7 @@
 	"keywords": ["blokctl", "cli", "blok", "blok"],
 	"dependencies": {
 		"@ai-sdk/openai": "^1.3.22",
-		"@blokjs/runner": "^0.6.15",
+		"@blokjs/runner": "^0.6.17",
 		"@clack/prompts": "^1.0.0",
 		"ai": "^4.3.16",
 		"better-sqlite3": "^12.6.2",