blokctl 0.6.20 → 0.7.0

package/dist/studio-dist/index.html

@@ -15,7 +15,7 @@
       href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Newsreader:ital,wght@1,400;1,500&display=swap"
       rel="stylesheet"
     />
-    <script type="module" crossorigin src="/assets/index-BD8_9YPN.js"></script>
+    <script type="module" crossorigin src="/assets/index-CnFqCRQe.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/tanstack-query-Day3Mt-4.js">
     <link rel="modulepreload" crossorigin href="/assets/tanstack-router-BB95iErN.js">
     <link rel="modulepreload" crossorigin href="/assets/charts-Dh48HebV.js">

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blokctl",
-	"version": "0.6.20",
+	"version": "0.7.0",
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"description": "cli for blok",
@@ -13,7 +13,7 @@
 	"bin": {
 		"blokctl": "./dist/index.js"
 	},
-	"files": ["dist", "node_modules"],
+	"files": ["dist"],
 	"scripts": {
 		"build": "rm -rf dist && bun run tsc",
 		"build:dev": "tsc --watch",
@@ -30,7 +30,7 @@
 	"keywords": ["blokctl", "cli", "blok", "blok"],
 	"dependencies": {
 		"@ai-sdk/openai": "^1.3.22",
-		"@blokjs/runner": "^0.6.20",
+		"@blokjs/runner": "^0.7.0",
 		"@clack/prompts": "^1.0.0",
 		"ai": "^4.3.16",
 		"better-sqlite3": "^12.6.2",

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

@@ -1,61 +0,0 @@
-export type GenerationType = "node" | "workflow" | "trigger";
-export interface GenerationEvent {
-    id: string;
-    timestamp: string;
-    type: GenerationType;
-    subtype: string;
-    name: string;
-    success: boolean;
-    attempts: number;
-    durationMs: number;
-    errors: string[];
-    promptVersion: string;
-}
-export interface GenerationStats {
-    totalGenerations: number;
-    successCount: number;
-    failureCount: number;
-    successRate: number;
-    averageAttempts: number;
-    averageDurationMs: number;
-    topErrors: Array<{
-        pattern: string;
-        count: number;
-    }>;
-    byType: Record<GenerationType, TypeStats>;
-}
-export interface TypeStats {
-    total: number;
-    success: number;
-    failure: number;
-    successRate: number;
-    averageAttempts: number;
-}
-export declare class GenerationAnalytics {
-    private events;
-    private static instance;
-    static getInstance(): GenerationAnalytics;
-    recordEvent(event: Omit<GenerationEvent, "id" | "timestamp">): GenerationEvent;
-    startTimer(): () => number;
-    getStats(): GenerationStats;
-    private getTypeStats;
-    private getTopErrors;
-    private normalizeErrorPattern;
-    getEvents(filter?: {
-        type?: GenerationType;
-        success?: boolean;
-        since?: string;
-    }): GenerationEvent[];
-    getFirstAttemptSuccessRate(): number;
-    getSuccessRateByPromptVersion(): Record<string, {
-        total: number;
-        success: number;
-        rate: number;
-    }>;
-    toJSON(): string;
-    fromJSON(json: string): void;
-    clear(): void;
-    static resetInstance(): void;
-    private generateId;
-}
-export default GenerationAnalytics;

package/dist/commands/generate/GenerationAnalytics.js

@@ -1,163 +0,0 @@
-export class GenerationAnalytics {
-    events = [];
-    static instance = null;
-    static getInstance() {
-        if (!GenerationAnalytics.instance) {
-            GenerationAnalytics.instance = new GenerationAnalytics();
-        }
-        return GenerationAnalytics.instance;
-    }
-    recordEvent(event) {
-        const fullEvent = {
-            ...event,
-            id: this.generateId(),
-            timestamp: new Date().toISOString(),
-        };
-        this.events.push(fullEvent);
-        return fullEvent;
-    }
-    startTimer() {
-        const start = performance.now();
-        return () => Math.round(performance.now() - start);
-    }
-    getStats() {
-        const total = this.events.length;
-        if (total === 0) {
-            return {
-                totalGenerations: 0,
-                successCount: 0,
-                failureCount: 0,
-                successRate: 0,
-                averageAttempts: 0,
-                averageDurationMs: 0,
-                topErrors: [],
-                byType: {
-                    node: { total: 0, success: 0, failure: 0, successRate: 0, averageAttempts: 0 },
-                    workflow: { total: 0, success: 0, failure: 0, successRate: 0, averageAttempts: 0 },
-                    trigger: { total: 0, success: 0, failure: 0, successRate: 0, averageAttempts: 0 },
-                },
-            };
-        }
-        const successCount = this.events.filter((e) => e.success).length;
-        const failureCount = total - successCount;
-        const totalAttempts = this.events.reduce((sum, e) => sum + e.attempts, 0);
-        const totalDuration = this.events.reduce((sum, e) => sum + e.durationMs, 0);
-        return {
-            totalGenerations: total,
-            successCount,
-            failureCount,
-            successRate: Math.round((successCount / total) * 100),
-            averageAttempts: Math.round((totalAttempts / total) * 10) / 10,
-            averageDurationMs: Math.round(totalDuration / total),
-            topErrors: this.getTopErrors(),
-            byType: {
-                node: this.getTypeStats("node"),
-                workflow: this.getTypeStats("workflow"),
-                trigger: this.getTypeStats("trigger"),
-            },
-        };
-    }
-    getTypeStats(type) {
-        const typeEvents = this.events.filter((e) => e.type === type);
-        const total = typeEvents.length;
-        if (total === 0) {
-            return { total: 0, success: 0, failure: 0, successRate: 0, averageAttempts: 0 };
-        }
-        const success = typeEvents.filter((e) => e.success).length;
-        const failure = total - success;
-        const totalAttempts = typeEvents.reduce((sum, e) => sum + e.attempts, 0);
-        return {
-            total,
-            success,
-            failure,
-            successRate: Math.round((success / total) * 100),
-            averageAttempts: Math.round((totalAttempts / total) * 10) / 10,
-        };
-    }
-    getTopErrors() {
-        const errorCounts = new Map();
-        for (const event of this.events) {
-            for (const error of event.errors) {
-                const pattern = this.normalizeErrorPattern(error);
-                errorCounts.set(pattern, (errorCounts.get(pattern) || 0) + 1);
-            }
-        }
-        return Array.from(errorCounts.entries())
-            .map(([pattern, count]) => ({ pattern, count }))
-            .sort((a, b) => b.count - a.count)
-            .slice(0, 10);
-    }
-    normalizeErrorPattern(error) {
-        return error
-            .replace(/TS\d+/, "TS****")
-            .replace(/"[^"]*"/, '"..."')
-            .replace(/'\S+'/, "'...'")
-            .replace(/line \d+/, "line N")
-            .replace(/column \d+/, "column N")
-            .replace(/at index \d+/, "at index N")
-            .trim();
-    }
-    getEvents(filter) {
-        let filtered = [...this.events];
-        if (filter?.type) {
-            filtered = filtered.filter((e) => e.type === filter.type);
-        }
-        if (filter?.success !== undefined) {
-            filtered = filtered.filter((e) => e.success === filter.success);
-        }
-        if (filter?.since) {
-            const since = filter.since;
-            filtered = filtered.filter((e) => e.timestamp >= since);
-        }
-        return filtered;
-    }
-    getFirstAttemptSuccessRate() {
-        if (this.events.length === 0)
-            return 0;
-        const firstAttemptSuccess = this.events.filter((e) => e.success && e.attempts === 1).length;
-        return Math.round((firstAttemptSuccess / this.events.length) * 100);
-    }
-    getSuccessRateByPromptVersion() {
-        const byVersion = {};
-        for (const event of this.events) {
-            if (!byVersion[event.promptVersion]) {
-                byVersion[event.promptVersion] = { total: 0, success: 0 };
-            }
-            byVersion[event.promptVersion].total++;
-            if (event.success) {
-                byVersion[event.promptVersion].success++;
-            }
-        }
-        const result = {};
-        for (const [version, stats] of Object.entries(byVersion)) {
-            result[version] = {
-                ...stats,
-                rate: Math.round((stats.success / stats.total) * 100),
-            };
-        }
-        return result;
-    }
-    toJSON() {
-        return JSON.stringify({
-            events: this.events,
-            stats: this.getStats(),
-            exportedAt: new Date().toISOString(),
-        }, null, 2);
-    }
-    fromJSON(json) {
-        const data = JSON.parse(json);
-        if (data.events && Array.isArray(data.events)) {
-            this.events.push(...data.events);
-        }
-    }
-    clear() {
-        this.events = [];
-    }
-    static resetInstance() {
-        GenerationAnalytics.instance = null;
-    }
-    generateId() {
-        return `gen_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    }
-}
-export default GenerationAnalytics;

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

@@ -1,407 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { GenerationAnalytics } from "./GenerationAnalytics.js";
-describe("GenerationAnalytics", () => {
-    let analytics;
-    beforeEach(() => {
-        GenerationAnalytics.resetInstance();
-        analytics = GenerationAnalytics.getInstance();
-        analytics.clear();
-    });
-    describe("singleton pattern", () => {
-        it("should return the same instance", () => {
-            const a = GenerationAnalytics.getInstance();
-            const b = GenerationAnalytics.getInstance();
-            expect(a).toBe(b);
-        });
-        it("should create new instance after reset", () => {
-            const a = GenerationAnalytics.getInstance();
-            GenerationAnalytics.resetInstance();
-            const b = GenerationAnalytics.getInstance();
-            expect(a).not.toBe(b);
-        });
-    });
-    describe("recordEvent", () => {
-        it("should record a generation event and return it with id and timestamp", () => {
-            const event = analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "fetch-user",
-                success: true,
-                attempts: 1,
-                durationMs: 2500,
-                errors: [],
-                promptVersion: "create-fn-node@2.0.0",
-            });
-            expect(event.id).toBeTruthy();
-            expect(event.id).toMatch(/^gen_/);
-            expect(event.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-            expect(event.type).toBe("node");
-            expect(event.success).toBe(true);
-        });
-        it("should track multiple events", () => {
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "node1",
-                success: true,
-                attempts: 1,
-                durationMs: 1000,
-                errors: [],
-                promptVersion: "v1",
-            });
-            analytics.recordEvent({
-                type: "workflow",
-                subtype: "http",
-                name: "wf1",
-                success: false,
-                attempts: 3,
-                durationMs: 5000,
-                errors: ["Error 1"],
-                promptVersion: "v1",
-            });
-            const events = analytics.getEvents();
-            expect(events.length).toBe(2);
-        });
-    });
-    describe("getStats - empty", () => {
-        it("should return zero stats when no events recorded", () => {
-            const stats = analytics.getStats();
-            expect(stats.totalGenerations).toBe(0);
-            expect(stats.successCount).toBe(0);
-            expect(stats.failureCount).toBe(0);
-            expect(stats.successRate).toBe(0);
-            expect(stats.averageAttempts).toBe(0);
-            expect(stats.averageDurationMs).toBe(0);
-            expect(stats.topErrors).toEqual([]);
-        });
-    });
-    describe("getStats - with data", () => {
-        beforeEach(() => {
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n1",
-                success: true,
-                attempts: 1,
-                durationMs: 1000,
-                errors: [],
-                promptVersion: "v1",
-            });
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n2",
-                success: true,
-                attempts: 2,
-                durationMs: 3000,
-                errors: ["Missing import"],
-                promptVersion: "v1",
-            });
-            analytics.recordEvent({
-                type: "workflow",
-                subtype: "http",
-                name: "w1",
-                success: true,
-                attempts: 1,
-                durationMs: 2000,
-                errors: [],
-                promptVersion: "v2",
-            });
-            analytics.recordEvent({
-                type: "trigger",
-                subtype: "queue",
-                name: "t1",
-                success: false,
-                attempts: 3,
-                durationMs: 8000,
-                errors: ["Missing TriggerBase", "Missing createContext"],
-                promptVersion: "v1",
-            });
-        });
-        it("should calculate correct totals", () => {
-            const stats = analytics.getStats();
-            expect(stats.totalGenerations).toBe(4);
-            expect(stats.successCount).toBe(3);
-            expect(stats.failureCount).toBe(1);
-        });
-        it("should calculate correct success rate", () => {
-            const stats = analytics.getStats();
-            expect(stats.successRate).toBe(75);
-        });
-        it("should calculate correct average attempts", () => {
-            const stats = analytics.getStats();
-            expect(stats.averageAttempts).toBe(1.8);
-        });
-        it("should calculate correct average duration", () => {
-            const stats = analytics.getStats();
-            expect(stats.averageDurationMs).toBe(3500);
-        });
-        it("should provide per-type breakdown", () => {
-            const stats = analytics.getStats();
-            expect(stats.byType.node.total).toBe(2);
-            expect(stats.byType.node.success).toBe(2);
-            expect(stats.byType.node.successRate).toBe(100);
-            expect(stats.byType.workflow.total).toBe(1);
-            expect(stats.byType.workflow.success).toBe(1);
-            expect(stats.byType.workflow.successRate).toBe(100);
-            expect(stats.byType.trigger.total).toBe(1);
-            expect(stats.byType.trigger.success).toBe(0);
-            expect(stats.byType.trigger.successRate).toBe(0);
-        });
-        it("should track top error patterns", () => {
-            const stats = analytics.getStats();
-            expect(stats.topErrors.length).toBeGreaterThan(0);
-            for (let i = 1; i < stats.topErrors.length; i++) {
-                expect(stats.topErrors[i].count).toBeLessThanOrEqual(stats.topErrors[i - 1].count);
-            }
-        });
-    });
-    describe("getEvents - filtering", () => {
-        beforeEach(() => {
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n1",
-                success: true,
-                attempts: 1,
-                durationMs: 1000,
-                errors: [],
-                promptVersion: "v1",
-            });
-            analytics.recordEvent({
-                type: "workflow",
-                subtype: "http",
-                name: "w1",
-                success: false,
-                attempts: 3,
-                durationMs: 5000,
-                errors: ["Error"],
-                promptVersion: "v1",
-            });
-            analytics.recordEvent({
-                type: "trigger",
-                subtype: "queue",
-                name: "t1",
-                success: true,
-                attempts: 2,
-                durationMs: 3000,
-                errors: ["Retried"],
-                promptVersion: "v2",
-            });
-        });
-        it("should filter by type", () => {
-            const nodes = analytics.getEvents({ type: "node" });
-            expect(nodes.length).toBe(1);
-            expect(nodes[0].name).toBe("n1");
-        });
-        it("should filter by success", () => {
-            const successes = analytics.getEvents({ success: true });
-            expect(successes.length).toBe(2);
-            const failures = analytics.getEvents({ success: false });
-            expect(failures.length).toBe(1);
-        });
-        it("should filter by type and success combined", () => {
-            const failedWorkflows = analytics.getEvents({ type: "workflow", success: false });
-            expect(failedWorkflows.length).toBe(1);
-            expect(failedWorkflows[0].name).toBe("w1");
-        });
-        it("should return all events when no filter", () => {
-            const all = analytics.getEvents();
-            expect(all.length).toBe(3);
-        });
-    });
-    describe("getFirstAttemptSuccessRate", () => {
-        it("should return 0 when no events", () => {
-            expect(analytics.getFirstAttemptSuccessRate()).toBe(0);
-        });
-        it("should calculate first-attempt success rate correctly", () => {
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n1",
-                success: true,
-                attempts: 1,
-                durationMs: 1000,
-                errors: [],
-                promptVersion: "v1",
-            });
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n2",
-                success: true,
-                attempts: 2,
-                durationMs: 3000,
-                errors: [],
-                promptVersion: "v1",
-            });
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n3",
-                success: true,
-                attempts: 1,
-                durationMs: 1000,
-                errors: [],
-                promptVersion: "v1",
-            });
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n4",
-                success: false,
-                attempts: 3,
-                durationMs: 8000,
-                errors: ["Error"],
-                promptVersion: "v1",
-            });
-            expect(analytics.getFirstAttemptSuccessRate()).toBe(50);
-        });
-    });
-    describe("getSuccessRateByPromptVersion", () => {
-        it("should break down success rate by prompt version", () => {
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n1",
-                success: true,
-                attempts: 1,
-                durationMs: 1000,
-                errors: [],
-                promptVersion: "create-fn-node@1.0.0",
-            });
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n2",
-                success: false,
-                attempts: 3,
-                durationMs: 5000,
-                errors: ["Error"],
-                promptVersion: "create-fn-node@1.0.0",
-            });
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n3",
-                success: true,
-                attempts: 1,
-                durationMs: 1000,
-                errors: [],
-                promptVersion: "create-fn-node@2.0.0",
-            });
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n4",
-                success: true,
-                attempts: 2,
-                durationMs: 3000,
-                errors: [],
-                promptVersion: "create-fn-node@2.0.0",
-            });
-            const rates = analytics.getSuccessRateByPromptVersion();
-            expect(rates["create-fn-node@1.0.0"]).toBeDefined();
-            expect(rates["create-fn-node@1.0.0"].total).toBe(2);
-            expect(rates["create-fn-node@1.0.0"].rate).toBe(50);
-            expect(rates["create-fn-node@2.0.0"]).toBeDefined();
-            expect(rates["create-fn-node@2.0.0"].total).toBe(2);
-            expect(rates["create-fn-node@2.0.0"].rate).toBe(100);
-        });
-    });
-    describe("serialization", () => {
-        it("should serialize to JSON", () => {
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n1",
-                success: true,
-                attempts: 1,
-                durationMs: 1000,
-                errors: [],
-                promptVersion: "v1",
-            });
-            const json = analytics.toJSON();
-            const parsed = JSON.parse(json);
-            expect(parsed.events).toBeDefined();
-            expect(parsed.events.length).toBe(1);
-            expect(parsed.stats).toBeDefined();
-            expect(parsed.exportedAt).toBeTruthy();
-        });
-        it("should import from JSON", () => {
-            const exportData = {
-                events: [
-                    {
-                        id: "gen_imported_1",
-                        timestamp: "2026-01-28T00:00:00Z",
-                        type: "node",
-                        subtype: "function",
-                        name: "imported-node",
-                        success: true,
-                        attempts: 1,
-                        durationMs: 1000,
-                        errors: [],
-                        promptVersion: "v1",
-                    },
-                ],
-            };
-            analytics.fromJSON(JSON.stringify(exportData));
-            const events = analytics.getEvents();
-            expect(events.length).toBe(1);
-            expect(events[0].name).toBe("imported-node");
-        });
-    });
-    describe("startTimer", () => {
-        it("should measure duration", async () => {
-            const getElapsed = analytics.startTimer();
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            const elapsed = getElapsed();
-            expect(elapsed).toBeGreaterThanOrEqual(40);
-            expect(elapsed).toBeLessThan(200);
-        });
-    });
-    describe("error pattern normalization", () => {
-        it("should normalize TypeScript error codes in top errors", () => {
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n1",
-                success: false,
-                attempts: 3,
-                durationMs: 5000,
-                errors: ['TS2304: Cannot find name "defineNode"', "TS2307: Cannot find module '@blokjs/runner'"],
-                promptVersion: "v1",
-            });
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n2",
-                success: false,
-                attempts: 3,
-                durationMs: 5000,
-                errors: ['TS2304: Cannot find name "z"'],
-                promptVersion: "v1",
-            });
-            const stats = analytics.getStats();
-            const ts2304 = stats.topErrors.filter((e) => e.pattern.includes("TS****"));
-            expect(ts2304.length).toBeGreaterThan(0);
-        });
-    });
-    describe("clear", () => {
-        it("should clear all events", () => {
-            analytics.recordEvent({
-                type: "node",
-                subtype: "function",
-                name: "n1",
-                success: true,
-                attempts: 1,
-                durationMs: 1000,
-                errors: [],
-                promptVersion: "v1",
-            });
-            analytics.clear();
-            const events = analytics.getEvents();
-            expect(events.length).toBe(0);
-        });
-    });
-});

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

@@ -1,25 +0,0 @@
-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;