trickle-cli 0.1.0

package/dist/commands/watch.js

@@ -0,0 +1,267 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchCommand = watchCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_client_1 = require("../api-client");
+const config_1 = require("../config");
+/**
+ * Detect which codegen formats are relevant based on package.json dependencies.
+ */
+function detectFormats(projectDir) {
+    const pkgPath = path.join(projectDir, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+        return [
+            { format: "", fileName: "types.d.ts", label: "TypeScript types" },
+            { format: "guards", fileName: "guards.ts", label: "Type guards" },
+        ];
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    }
+    catch {
+        return [
+            { format: "", fileName: "types.d.ts", label: "TypeScript types" },
+            { format: "guards", fileName: "guards.ts", label: "Type guards" },
+        ];
+    }
+    const deps = {
+        ...(pkg.dependencies || {}),
+        ...(pkg.devDependencies || {}),
+    };
+    const formats = [];
+    formats.push({ format: "", fileName: "types.d.ts", label: "TypeScript types" });
+    if (deps["axios"]) {
+        formats.push({ format: "axios", fileName: "axios-client.ts", label: "Axios client" });
+    }
+    else {
+        formats.push({ format: "client", fileName: "api-client.ts", label: "Fetch API client" });
+    }
+    if (deps["@tanstack/react-query"] || deps["react-query"]) {
+        formats.push({ format: "react-query", fileName: "hooks.ts", label: "React Query hooks" });
+    }
+    if (deps["swr"]) {
+        formats.push({ format: "swr", fileName: "swr-hooks.ts", label: "SWR hooks" });
+    }
+    if (deps["zod"]) {
+        formats.push({ format: "zod", fileName: "schemas.ts", label: "Zod schemas" });
+    }
+    if (deps["@trpc/server"] || deps["@trpc/client"]) {
+        formats.push({ format: "trpc", fileName: "trpc-router.ts", label: "tRPC router" });
+    }
+    if (deps["class-validator"] || deps["@nestjs/common"]) {
+        formats.push({ format: "class-validator", fileName: "dtos.ts", label: "class-validator DTOs" });
+    }
+    if (deps["express"] || deps["@types/express"]) {
+        formats.push({ format: "handlers", fileName: "handlers.d.ts", label: "Express handler types" });
+    }
+    if (deps["msw"]) {
+        formats.push({ format: "msw", fileName: "msw-handlers.ts", label: "MSW mock handlers" });
+    }
+    formats.push({ format: "guards", fileName: "guards.ts", label: "Type guards" });
+    return formats;
+}
+/**
+ * Build a fingerprint from the functions list to detect changes.
+ * Uses function names + type hashes + last_seen timestamps.
+ */
+function buildFingerprint(functions) {
+    const parts = functions
+        .map((f) => `${f.function_name}:${f.last_seen_at}`)
+        .sort();
+    return parts.join("|");
+}
+/**
+ * Generate all relevant type files to the output directory.
+ */
+async function regenerate(formats, outDir, env) {
+    if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+    }
+    const files = [];
+    let generated = 0;
+    for (const f of formats) {
+        try {
+            const result = await (0, api_client_1.fetchCodegen)({
+                env,
+                format: f.format || undefined,
+            });
+            const content = result.types;
+            if (!content || content.includes("No functions found") || content.includes("No API routes found")) {
+                continue;
+            }
+            const filePath = path.join(outDir, f.fileName);
+            fs.writeFileSync(filePath, content, "utf-8");
+            generated++;
+            files.push(f.fileName);
+        }
+        catch {
+            // Skip failed formats silently
+        }
+    }
+    return { generated, files };
+}
+function timestamp() {
+    const now = new Date();
+    return now.toLocaleTimeString("en-US", { hour12: false });
+}
+/**
+ * `trickle watch` — Watch for new type observations and auto-regenerate type files.
+ */
+async function watchCommand(opts) {
+    const backendUrl = (0, config_1.getBackendUrl)();
+    const projectDir = process.cwd();
+    const outDir = path.resolve(opts.dir || ".trickle");
+    const intervalMs = parseInterval(opts.interval || "3s");
+    // Check backend connectivity
+    try {
+        const res = await fetch(`${backendUrl}/api/health`, { signal: AbortSignal.timeout(3000) });
+        if (!res.ok)
+            throw new Error("not ok");
+    }
+    catch {
+        console.error(chalk_1.default.red(`\n  Cannot reach trickle backend at ${chalk_1.default.bold(backendUrl)}\n`));
+        process.exit(1);
+    }
+    // Detect formats from project deps
+    const formats = detectFormats(projectDir);
+    console.log("");
+    console.log(chalk_1.default.bold("  trickle watch"));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log(chalk_1.default.gray(`  Backend:  ${backendUrl}`));
+    console.log(chalk_1.default.gray(`  Output:   ${outDir}`));
+    console.log(chalk_1.default.gray(`  Interval: ${opts.interval || "3s"}`));
+    if (opts.env) {
+        console.log(chalk_1.default.gray(`  Env:      ${opts.env}`));
+    }
+    console.log(chalk_1.default.gray(`  Formats:  ${formats.map((f) => f.fileName).join(", ")}`));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log("");
+    // Initial generation
+    console.log(chalk_1.default.gray(`  [${timestamp()}]`) + " Performing initial type generation...");
+    let lastFingerprint = "";
+    try {
+        const { functions } = await (0, api_client_1.listFunctions)({ env: opts.env, limit: 1000 });
+        if (functions.length > 0) {
+            lastFingerprint = buildFingerprint(functions);
+            const { generated, files } = await regenerate(formats, outDir, opts.env);
+            if (generated > 0) {
+                console.log(chalk_1.default.green(`  [${timestamp()}]`) +
+                    ` Generated ${generated} files: ${chalk_1.default.white(files.join(", "))}`);
+            }
+            else {
+                console.log(chalk_1.default.gray(`  [${timestamp()}]`) + " No types to generate yet.");
+            }
+        }
+        else {
+            console.log(chalk_1.default.gray(`  [${timestamp()}]`) + " No observed functions yet. Waiting...");
+        }
+    }
+    catch {
+        console.log(chalk_1.default.yellow(`  [${timestamp()}]`) + " Could not fetch initial types. Will retry...");
+    }
+    console.log("");
+    console.log(chalk_1.default.gray("  Watching for type changes... (Ctrl+C to stop)"));
+    console.log("");
+    // Poll loop
+    const poll = async () => {
+        try {
+            const { functions } = await (0, api_client_1.listFunctions)({ env: opts.env, limit: 1000 });
+            const fingerprint = buildFingerprint(functions);
+            if (fingerprint !== lastFingerprint && fingerprint !== "") {
+                // Types changed — find what's new
+                const newFunctions = functions.filter((f) => {
+                    // A function is "new" if it wasn't in the last fingerprint
+                    return !lastFingerprint.includes(`${f.function_name}:`);
+                });
+                const updatedFunctions = functions.filter((f) => {
+                    // A function is "updated" if its timestamp changed
+                    const oldEntry = `${f.function_name}:${f.last_seen_at}`;
+                    return lastFingerprint.includes(`${f.function_name}:`) && !lastFingerprint.includes(oldEntry);
+                });
+                lastFingerprint = fingerprint;
+                // Show what changed
+                for (const f of newFunctions) {
+                    console.log(chalk_1.default.cyan(`  [${timestamp()}]`) +
+                        chalk_1.default.gray(" New: ") +
+                        chalk_1.default.white(f.function_name));
+                }
+                for (const f of updatedFunctions) {
+                    console.log(chalk_1.default.blue(`  [${timestamp()}]`) +
+                        chalk_1.default.gray(" Updated: ") +
+                        chalk_1.default.white(f.function_name));
+                }
+                // Regenerate
+                const { generated, files } = await regenerate(formats, outDir, opts.env);
+                if (generated > 0) {
+                    console.log(chalk_1.default.green(`  [${timestamp()}]`) +
+                        ` Regenerated ${generated} files: ${chalk_1.default.white(files.join(", "))}`);
+                }
+            }
+        }
+        catch {
+            // Silently skip poll failures
+        }
+    };
+    // Set up interval
+    const timer = setInterval(poll, intervalMs);
+    // Handle graceful shutdown
+    const cleanup = () => {
+        clearInterval(timer);
+        console.log(chalk_1.default.gray(`\n  [${timestamp()}]`) + " Watch stopped.\n");
+        process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+}
+function parseInterval(input) {
+    const match = input.match(/^(\d+)(s|ms|m)?$/);
+    if (!match)
+        return 3000;
+    const value = parseInt(match[1], 10);
+    const unit = match[2] || "s";
+    switch (unit) {
+        case "ms": return value;
+        case "s": return value * 1000;
+        case "m": return value * 60 * 1000;
+        default: return value * 1000;
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1 @@
+export declare function getBackendUrl(): string;

package/dist/config.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackendUrl = getBackendUrl;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const DEFAULT_BACKEND_URL = "http://localhost:4888";
+function loadConfigFile() {
+    const configPath = path.join(os.homedir(), ".trickle", "config.json");
+    try {
+        if (fs.existsSync(configPath)) {
+            const raw = fs.readFileSync(configPath, "utf-8");
+            return JSON.parse(raw);
+        }
+    }
+    catch {
+        // Ignore invalid config file
+    }
+    return null;
+}
+function getBackendUrl() {
+    // 1. Environment variable takes priority
+    if (process.env.TRICKLE_BACKEND_URL) {
+        return process.env.TRICKLE_BACKEND_URL.replace(/\/+$/, "");
+    }
+    // 2. Config file
+    const config = loadConfigFile();
+    if (config?.backendUrl) {
+        return config.backendUrl.replace(/\/+$/, "");
+    }
+    // 3. Default
+    return DEFAULT_BACKEND_URL;
+}

package/dist/formatters/diff-formatter.d.ts

@@ -0,0 +1,5 @@
+import { TypeDiff } from "../api-client";
+/**
+ * Format an array of TypeDiff entries as colorized diff output.
+ */
+export declare function formatDiffs(diffs: TypeDiff[]): string;

package/dist/formatters/diff-formatter.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDiffs = formatDiffs;
+const chalk_1 = __importDefault(require("chalk"));
+const type_formatter_1 = require("./type-formatter");
+/**
+ * Format an array of TypeDiff entries as colorized diff output.
+ */
+function formatDiffs(diffs) {
+    if (diffs.length === 0) {
+        return chalk_1.default.gray("  No differences found.");
+    }
+    const lines = [];
+    for (const diff of diffs) {
+        const pathStr = chalk_1.default.gray(diff.path);
+        switch (diff.kind) {
+            case "added":
+                lines.push(chalk_1.default.green("  + added  ") +
+                    pathStr +
+                    chalk_1.default.gray(": ") +
+                    (0, type_formatter_1.formatType)(diff.type, 0));
+                break;
+            case "removed":
+                lines.push(chalk_1.default.red("  - removed  ") +
+                    pathStr +
+                    chalk_1.default.gray(": ") +
+                    (0, type_formatter_1.formatType)(diff.type, 0));
+                break;
+            case "changed":
+                lines.push(chalk_1.default.yellow("  ~ changed  ") +
+                    pathStr +
+                    chalk_1.default.gray(": ") +
+                    (0, type_formatter_1.formatType)(diff.from, 0) +
+                    chalk_1.default.gray(" -> ") +
+                    (0, type_formatter_1.formatType)(diff.to, 0));
+                break;
+        }
+    }
+    return lines.join("\n");
+}

package/dist/formatters/type-formatter.d.ts

@@ -0,0 +1,22 @@
+interface TypeNode {
+    kind: string;
+    name?: string;
+    element?: TypeNode;
+    properties?: Record<string, TypeNode>;
+    members?: TypeNode[];
+    params?: TypeNode[];
+    returnType?: TypeNode;
+    resolved?: TypeNode;
+    key?: TypeNode;
+    value?: TypeNode;
+    elements?: TypeNode[];
+}
+/**
+ * Format a TypeNode as colorized pseudo-TypeScript.
+ */
+export declare function formatType(node: TypeNode | unknown, indent?: number): string;
+/**
+ * Format a type node as a compact single-line string (no colors).
+ */
+export declare function formatTypePlain(node: TypeNode | unknown): string;
+export {};

package/dist/formatters/type-formatter.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatType = formatType;
+exports.formatTypePlain = formatTypePlain;
+const chalk_1 = __importDefault(require("chalk"));
+const INDENT_SIZE = 2;
+function primitiveColor(name) {
+    switch (name) {
+        case "string":
+            return chalk_1.default.green(name);
+        case "number":
+        case "bigint":
+            return chalk_1.default.yellow(name);
+        case "boolean":
+            return chalk_1.default.blue(name);
+        case "null":
+        case "undefined":
+            return chalk_1.default.gray(name);
+        case "symbol":
+            return chalk_1.default.magenta(name);
+        default:
+            return chalk_1.default.white(name);
+    }
+}
+/**
+ * Format a TypeNode as colorized pseudo-TypeScript.
+ */
+function formatType(node, indent = 0) {
+    if (!node || typeof node !== "object") {
+        return chalk_1.default.gray("unknown");
+    }
+    const n = node;
+    const pad = " ".repeat(indent);
+    const innerPad = " ".repeat(indent + INDENT_SIZE);
+    switch (n.kind) {
+        case "primitive":
+            return primitiveColor(n.name || "unknown");
+        case "array":
+            if (n.element) {
+                const inner = formatType(n.element, indent);
+                // Wrap complex types in parens for array notation
+                if (n.element.kind === "union") {
+                    return `(${inner})[]`;
+                }
+                return `${inner}[]`;
+            }
+            return chalk_1.default.gray("unknown[]");
+        case "object": {
+            if (!n.properties)
+                return chalk_1.default.gray("{}");
+            const keys = Object.keys(n.properties);
+            if (keys.length === 0)
+                return chalk_1.default.gray("{}");
+            // Inline for small objects (2 or fewer properties)
+            if (keys.length <= 2) {
+                const props = keys.map((key) => `${chalk_1.default.white(key)}: ${formatType(n.properties[key], 0)}`);
+                return `{ ${props.join(", ")} }`;
+            }
+            // Multi-line for larger objects
+            const lines = keys.map((key) => `${innerPad}${chalk_1.default.white(key)}: ${formatType(n.properties[key], indent + INDENT_SIZE)}`);
+            return `{\n${lines.join(",\n")}\n${pad}}`;
+        }
+        case "union": {
+            if (!n.members || n.members.length === 0)
+                return chalk_1.default.gray("never");
+            return n.members.map((m) => formatType(m, indent)).join(chalk_1.default.gray(" | "));
+        }
+        case "function": {
+            const params = (n.params || [])
+                .map((p, i) => `${chalk_1.default.white(`arg${i}`)}: ${formatType(p, indent)}`)
+                .join(", ");
+            const ret = n.returnType ? formatType(n.returnType, indent) : chalk_1.default.gray("void");
+            return `(${params}) => ${ret}`;
+        }
+        case "promise": {
+            const resolved = n.resolved ? formatType(n.resolved, indent) : chalk_1.default.gray("unknown");
+            return `${chalk_1.default.cyan("Promise")}<${resolved}>`;
+        }
+        case "map": {
+            const key = n.key ? formatType(n.key, indent) : chalk_1.default.gray("unknown");
+            const value = n.value ? formatType(n.value, indent) : chalk_1.default.gray("unknown");
+            return `${chalk_1.default.cyan("Map")}<${key}, ${value}>`;
+        }
+        case "set": {
+            const element = n.element ? formatType(n.element, indent) : chalk_1.default.gray("unknown");
+            return `${chalk_1.default.cyan("Set")}<${element}>`;
+        }
+        case "tuple": {
+            if (!n.elements || n.elements.length === 0)
+                return "[]";
+            const elems = n.elements.map((e) => formatType(e, indent)).join(", ");
+            return `[${elems}]`;
+        }
+        case "unknown":
+            return chalk_1.default.gray("unknown");
+        default:
+            return chalk_1.default.gray("unknown");
+    }
+}
+/**
+ * Format a type node as a compact single-line string (no colors).
+ */
+function formatTypePlain(node) {
+    if (!node || typeof node !== "object")
+        return "unknown";
+    const n = node;
+    switch (n.kind) {
+        case "primitive":
+            return n.name || "unknown";
+        case "array":
+            return n.element ? `${formatTypePlain(n.element)}[]` : "unknown[]";
+        case "object": {
+            if (!n.properties)
+                return "{}";
+            const keys = Object.keys(n.properties);
+            if (keys.length === 0)
+                return "{}";
+            const props = keys.map((k) => `${k}: ${formatTypePlain(n.properties[k])}`);
+            return `{ ${props.join(", ")} }`;
+        }
+        case "union":
+            return (n.members || []).map(formatTypePlain).join(" | ");
+        case "function": {
+            const params = (n.params || []).map((p, i) => `arg${i}: ${formatTypePlain(p)}`).join(", ");
+            return `(${params}) => ${n.returnType ? formatTypePlain(n.returnType) : "void"}`;
+        }
+        case "promise":
+            return `Promise<${n.resolved ? formatTypePlain(n.resolved) : "unknown"}>`;
+        default:
+            return "unknown";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};