trickle-cli 0.1.0

package/dist/commands/types.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typesCommand = typesCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const api_client_1 = require("../api-client");
+const type_formatter_1 = require("../formatters/type-formatter");
+const diff_formatter_1 = require("../formatters/diff-formatter");
+const badges_1 = require("../ui/badges");
+async function typesCommand(functionName, opts) {
+    // Look up function by name (partial match)
+    const result = await (0, api_client_1.listFunctions)({ search: functionName });
+    const { functions } = result;
+    if (functions.length === 0) {
+        console.log(chalk_1.default.yellow(`\n  No function found matching "${functionName}".\n`));
+        return;
+    }
+    // Prefer exact match, then first partial match
+    const exactMatch = functions.find((f) => f.function_name === functionName || f.function_name.toLowerCase() === functionName.toLowerCase());
+    const fn = exactMatch || functions[0];
+    if (!exactMatch && functions.length > 1) {
+        console.log(chalk_1.default.gray(`\n  Multiple matches found, showing results for "${chalk_1.default.white(fn.function_name)}"`));
+        console.log(chalk_1.default.gray(`  Other matches: ${functions
+            .slice(1, 5)
+            .map((f) => f.function_name)
+            .join(", ")}${functions.length > 5 ? "..." : ""}\n`));
+    }
+    // Diff mode
+    if (opts.diff) {
+        await showDiff(fn.id, fn.function_name, opts);
+        return;
+    }
+    // Normal mode: show type snapshots
+    const typesResult = await (0, api_client_1.listTypes)(fn.id, { env: opts.env });
+    const { snapshots } = typesResult;
+    if (snapshots.length === 0) {
+        console.log(chalk_1.default.yellow(`\n  No type snapshots found for "${fn.function_name}".\n`));
+        return;
+    }
+    console.log("");
+    console.log(chalk_1.default.white.bold(`  ${fn.function_name}`) + chalk_1.default.gray(` (${fn.module})`));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    for (const snapshot of snapshots) {
+        console.log("");
+        console.log(`  ${(0, badges_1.envBadge)(snapshot.env)}  ${(0, badges_1.timeBadge)(snapshot.observed_at)}`);
+        console.log("");
+        // Display function signature
+        console.log(chalk_1.default.gray("  args: ") + (0, type_formatter_1.formatType)(snapshot.args_type, 4));
+        console.log(chalk_1.default.gray("  returns: ") + (0, type_formatter_1.formatType)(snapshot.return_type, 4));
+        if (snapshot.sample_input !== undefined && snapshot.sample_input !== null) {
+            console.log("");
+            console.log(chalk_1.default.gray("  sample input:"));
+            console.log(chalk_1.default.gray("  ") + colorizeJson(snapshot.sample_input, 4));
+        }
+        if (snapshot.sample_output !== undefined && snapshot.sample_output !== null) {
+            console.log(chalk_1.default.gray("  sample output:"));
+            console.log(chalk_1.default.gray("  ") + colorizeJson(snapshot.sample_output, 4));
+        }
+    }
+    console.log("");
+}
+async function showDiff(functionId, functionName, opts) {
+    try {
+        let diffResult;
+        if (opts.env1 && opts.env2) {
+            diffResult = await (0, api_client_1.getTypeDiff)(functionId, {
+                fromEnv: opts.env1,
+                toEnv: opts.env2,
+            });
+        }
+        else {
+            // Get latest two snapshots and diff by their IDs
+            const typesResult = await (0, api_client_1.listTypes)(functionId, { limit: 2 });
+            const { snapshots } = typesResult;
+            if (snapshots.length < 2) {
+                console.log(chalk_1.default.yellow(`\n  Not enough snapshots to diff for "${functionName}".`));
+                console.log(chalk_1.default.gray("  Need at least 2 snapshots. Try specifying --env1 and --env2.\n"));
+                return;
+            }
+            diffResult = await (0, api_client_1.getTypeDiff)(functionId, {
+                from: snapshots[1].id,
+                to: snapshots[0].id,
+            });
+        }
+        console.log("");
+        console.log(chalk_1.default.white.bold(`  Type diff for ${functionName}`));
+        console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+        console.log("");
+        console.log(chalk_1.default.gray("  from: ") +
+            (0, badges_1.envBadge)(diffResult.from.env) +
+            chalk_1.default.gray("  " + diffResult.from.observed_at));
+        console.log(chalk_1.default.gray("  to:   ") +
+            (0, badges_1.envBadge)(diffResult.to.env) +
+            chalk_1.default.gray("  " + diffResult.to.observed_at));
+        console.log("");
+        if (diffResult.diffs.length === 0) {
+            console.log(chalk_1.default.green("  No type differences found.\n"));
+        }
+        else {
+            console.log((0, diff_formatter_1.formatDiffs)(diffResult.diffs));
+            console.log("");
+        }
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            console.error(chalk_1.default.red(`\n  Error: ${err.message}\n`));
+        }
+    }
+}
+function colorizeJson(value, indent = 0) {
+    const json = JSON.stringify(value, null, 2);
+    if (!json)
+        return chalk_1.default.gray("null");
+    return json
+        .split("\n")
+        .map((line, i) => {
+        const padded = i === 0 ? line : " ".repeat(indent) + line;
+        return padded
+            .replace(/"([^"]+)":/g, (_, key) => `${chalk_1.default.white(`"${key}"`)}:`)
+            .replace(/: "([^"]*)"/g, (_, val) => `: ${chalk_1.default.green(`"${val}"`)}`)
+            .replace(/: (\d+\.?\d*)/g, (_, val) => `: ${chalk_1.default.yellow(val)}`)
+            .replace(/: (true|false)/g, (_, val) => `: ${chalk_1.default.blue(val)}`)
+            .replace(/: (null)/g, (_, val) => `: ${chalk_1.default.gray(val)}`);
+    })
+        .join("\n");
+}

package/dist/commands/unpack.d.ts

@@ -0,0 +1,11 @@
+export interface UnpackOptions {
+    env?: string;
+    dryRun?: boolean;
+}
+/**
+ * `trickle unpack <file>` — Import types from a packed bundle into the backend.
+ *
+ * Reads a .trickle.json bundle (created by `trickle pack`) and ingests
+ * all functions and their type snapshots into the backend.
+ */
+export declare function unpackCommand(file: string, opts: UnpackOptions): Promise<void>;

package/dist/commands/unpack.js

@@ -0,0 +1,166 @@
+"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.unpackCommand = unpackCommand;
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config");
+/**
+ * `trickle unpack <file>` — Import types from a packed bundle into the backend.
+ *
+ * Reads a .trickle.json bundle (created by `trickle pack`) and ingests
+ * all functions and their type snapshots into the backend.
+ */
+async function unpackCommand(file, opts) {
+    const backendUrl = (0, config_1.getBackendUrl)();
+    // Read and parse the bundle
+    if (!fs.existsSync(file)) {
+        console.error(chalk_1.default.red(`\n  File not found: ${file}\n`));
+        process.exit(1);
+    }
+    let bundle;
+    try {
+        const content = fs.readFileSync(file, "utf-8");
+        bundle = JSON.parse(content);
+    }
+    catch {
+        console.error(chalk_1.default.red("\n  Invalid bundle file — expected JSON.\n"));
+        process.exit(1);
+    }
+    // Validate bundle structure
+    if (!bundle.version || !bundle.functions || !Array.isArray(bundle.functions)) {
+        console.error(chalk_1.default.red("\n  Invalid bundle format — missing required fields.\n"));
+        process.exit(1);
+    }
+    if (bundle.version !== 1) {
+        console.error(chalk_1.default.red(`\n  Unsupported bundle version: ${bundle.version}\n`));
+        process.exit(1);
+    }
+    console.log("");
+    console.log(chalk_1.default.bold("  trickle unpack"));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log(chalk_1.default.gray(`  File:     ${file}`));
+    console.log(chalk_1.default.gray(`  Created:  ${bundle.createdAt}`));
+    console.log(chalk_1.default.gray(`  Source:   ${bundle.source}`));
+    console.log(chalk_1.default.gray(`  Contains: ${bundle.functions.length} functions, ${bundle.stats.totalSnapshots} snapshots`));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    if (opts.dryRun) {
+        console.log("");
+        console.log(chalk_1.default.yellow("  Dry run — listing contents without importing:"));
+        console.log("");
+        for (const fn of bundle.functions) {
+            console.log(chalk_1.default.white(`  ${fn.functionName}`) +
+                chalk_1.default.gray(` (${fn.module}, ${fn.language}, ${fn.snapshots.length} snapshot${fn.snapshots.length === 1 ? "" : "s"})`));
+        }
+        console.log("");
+        console.log(chalk_1.default.gray(`  ${bundle.functions.length} functions would be imported.`));
+        console.log(chalk_1.default.gray("  Remove --dry-run to import.\n"));
+        return;
+    }
+    // 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);
+    }
+    console.log("");
+    // Ingest each function's snapshots
+    let imported = 0;
+    let skipped = 0;
+    let errors = 0;
+    for (const fn of bundle.functions) {
+        // Use the latest snapshot for ingest
+        const snapshot = fn.snapshots[0];
+        if (!snapshot) {
+            skipped++;
+            continue;
+        }
+        const env = opts.env || snapshot.env || fn.environment;
+        const typeHash = snapshot.typeHash || computeTypeHash(snapshot.argsType, snapshot.returnType);
+        const payload = {
+            functionName: fn.functionName,
+            module: fn.module,
+            language: fn.language,
+            environment: env,
+            typeHash,
+            argsType: snapshot.argsType,
+            returnType: snapshot.returnType,
+            sampleInput: snapshot.sampleInput,
+            sampleOutput: snapshot.sampleOutput,
+        };
+        try {
+            const res = await fetch(`${backendUrl}/api/ingest`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            imported++;
+            console.log(chalk_1.default.green("  ✓ ") + chalk_1.default.white(fn.functionName));
+        }
+        catch {
+            errors++;
+            console.log(chalk_1.default.red("  ✗ ") + chalk_1.default.white(fn.functionName) + chalk_1.default.gray(" (failed)"));
+        }
+    }
+    console.log("");
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    if (imported > 0) {
+        console.log(chalk_1.default.green(`  ${imported} functions imported successfully`));
+    }
+    if (skipped > 0) {
+        console.log(chalk_1.default.yellow(`  ${skipped} skipped (no snapshots)`));
+    }
+    if (errors > 0) {
+        console.log(chalk_1.default.red(`  ${errors} failed`));
+    }
+    console.log("");
+    console.log(chalk_1.default.gray("  Run ") + chalk_1.default.white("trickle overview") + chalk_1.default.gray(" to see imported types."));
+    console.log("");
+}
+function computeTypeHash(argsType, returnType) {
+    const data = JSON.stringify({ a: argsType, r: returnType });
+    return crypto.createHash("sha256").update(data).digest("hex").slice(0, 16);
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,13 @@
+export interface ValidateOptions {
+    header?: string[];
+    body?: string;
+    env?: string;
+    strict?: boolean;
+}
+/**
+ * `trickle validate <method> <url>` — Validate a live API response against observed types.
+ *
+ * Makes an HTTP request, infers types from the response, fetches the stored
+ * type for that route from the backend, and reports any mismatches.
+ */
+export declare function validateCommand(method: string, url: string, opts: ValidateOptions): Promise<void>;

package/dist/commands/validate.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCommand = validateCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config");
+/**
+ * `trickle validate <method> <url>` — Validate a live API response against observed types.
+ *
+ * Makes an HTTP request, infers types from the response, fetches the stored
+ * type for that route from the backend, and reports any mismatches.
+ */
+async function validateCommand(method, url, opts) {
+    const backendUrl = (0, config_1.getBackendUrl)();
+    const httpMethod = method.toUpperCase();
+    const validMethods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+    if (!validMethods.includes(httpMethod)) {
+        console.error(chalk_1.default.red(`\n  Invalid HTTP method: ${method}\n`));
+        process.exit(1);
+    }
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(url);
+    }
+    catch {
+        console.error(chalk_1.default.red(`\n  Invalid URL: ${url}\n`));
+        process.exit(1);
+    }
+    // Check backend
+    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);
+    }
+    // Build request headers
+    const headers = { Accept: "application/json" };
+    if (opts.header) {
+        for (const h of opts.header) {
+            const colonIdx = h.indexOf(":");
+            if (colonIdx === -1) {
+                console.error(chalk_1.default.red(`\n  Invalid header: ${h}\n`));
+                process.exit(1);
+            }
+            headers[h.slice(0, colonIdx).trim()] = h.slice(colonIdx + 1).trim();
+        }
+    }
+    let reqBody;
+    if (opts.body) {
+        reqBody = opts.body;
+        headers["Content-Type"] = headers["Content-Type"] || "application/json";
+    }
+    console.log("");
+    console.log(chalk_1.default.bold("  trickle validate"));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log(chalk_1.default.gray(`  ${chalk_1.default.bold(httpMethod)} ${url}`));
+    // Make the request
+    let response;
+    try {
+        response = await fetch(url, {
+            method: httpMethod,
+            headers,
+            body: reqBody,
+            signal: AbortSignal.timeout(30000),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        console.error(chalk_1.default.red(`\n  Request failed: ${msg}\n`));
+        process.exit(1);
+    }
+    const status = response.status;
+    const statusColor = status < 400 ? chalk_1.default.green : chalk_1.default.red;
+    console.log(chalk_1.default.gray(`  Status:   `) + statusColor(`${status} ${response.statusText}`));
+    // Parse response
+    const resText = await response.text();
+    let resJson;
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("json") && resText.length > 0) {
+        try {
+            resJson = JSON.parse(resText);
+        }
+        catch {
+            console.error(chalk_1.default.red("\n  Response is not valid JSON.\n"));
+            process.exit(1);
+        }
+    }
+    else {
+        console.error(chalk_1.default.red("\n  Response is not JSON.\n"));
+        process.exit(1);
+    }
+    // Normalize path and find stored types
+    const routePath = normalizePath(parsedUrl.pathname);
+    const functionName = `${httpMethod} ${routePath}`;
+    console.log(chalk_1.default.gray(`  Route:    `) + chalk_1.default.white(functionName));
+    // Fetch stored function from backend
+    const funcsRes = await fetch(`${backendUrl}/api/functions?q=${encodeURIComponent(functionName)}&limit=100`, { signal: AbortSignal.timeout(5000) });
+    const funcsData = await funcsRes.json();
+    const matchedFunc = funcsData.functions.find((f) => f.function_name === functionName);
+    if (!matchedFunc) {
+        console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+        console.log(chalk_1.default.yellow("  No previously observed types for this route."));
+        console.log(chalk_1.default.gray("  Run ") + chalk_1.default.white("trickle capture") + chalk_1.default.gray(" first to establish a baseline.\n"));
+        process.exit(1);
+    }
+    // Fetch latest type snapshot
+    const envQuery = opts.env ? `&env=${encodeURIComponent(opts.env)}` : "";
+    const typesRes = await fetch(`${backendUrl}/api/types/${matchedFunc.id}?limit=1${envQuery}`, { signal: AbortSignal.timeout(5000) });
+    const typesData = await typesRes.json();
+    if (!typesData.snapshots || typesData.snapshots.length === 0) {
+        console.log(chalk_1.default.yellow("  No type snapshots found for this route.\n"));
+        process.exit(1);
+    }
+    const snapshot = typesData.snapshots[0];
+    let expectedType;
+    try {
+        expectedType = (typeof snapshot.return_type === 'string'
+            ? JSON.parse(snapshot.return_type)
+            : snapshot.return_type);
+    }
+    catch {
+        console.error(chalk_1.default.red("  Cannot parse stored type snapshot.\n"));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.gray(`  Baseline: `) + chalk_1.default.gray(`observed ${snapshot.observed_at}`));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    // Infer type from actual response
+    const actualType = jsonToTypeNode(resJson);
+    // Compare
+    const mismatches = [];
+    compareTypes(expectedType, actualType, "response", mismatches, opts.strict || false);
+    if (mismatches.length === 0) {
+        console.log(chalk_1.default.green("\n  ✓ Response matches observed type shape\n"));
+        console.log(chalk_1.default.gray("  All fields present with expected types.\n"));
+    }
+    else {
+        console.log(chalk_1.default.red(`\n  ✗ ${mismatches.length} mismatch${mismatches.length === 1 ? "" : "es"} found\n`));
+        for (const m of mismatches) {
+            switch (m.issue) {
+                case "missing":
+                    console.log(chalk_1.default.red("  MISSING ") +
+                        chalk_1.default.white(m.path) +
+                        chalk_1.default.gray(` (expected ${m.expected})`));
+                    break;
+                case "extra":
+                    console.log(chalk_1.default.yellow("  EXTRA   ") +
+                        chalk_1.default.white(m.path) +
+                        chalk_1.default.gray(` (${m.actual}, not in observed types)`));
+                    break;
+                case "type_mismatch":
+                    console.log(chalk_1.default.red("  TYPE    ") +
+                        chalk_1.default.white(m.path) +
+                        chalk_1.default.gray(` (expected ${m.expected}, got ${m.actual})`));
+                    break;
+                case "kind_mismatch":
+                    console.log(chalk_1.default.red("  SHAPE   ") +
+                        chalk_1.default.white(m.path) +
+                        chalk_1.default.gray(` (expected ${m.expected}, got ${m.actual})`));
+                    break;
+            }
+        }
+        const errors = mismatches.filter((m) => m.issue !== "extra");
+        const warnings = mismatches.filter((m) => m.issue === "extra");
+        console.log("");
+        if (errors.length > 0) {
+            console.log(chalk_1.default.red(`  ${errors.length} error${errors.length === 1 ? "" : "s"}`) +
+                (warnings.length > 0 ? chalk_1.default.yellow(`, ${warnings.length} warning${warnings.length === 1 ? "" : "s"}`) : ""));
+        }
+        else {
+            console.log(chalk_1.default.yellow(`  ${warnings.length} warning${warnings.length === 1 ? "" : "s"} (extra fields only)`));
+        }
+        console.log("");
+        if (errors.length > 0) {
+            process.exitCode = 1;
+        }
+    }
+}
+/**
+ * Recursively compare expected vs actual TypeNode.
+ */
+function compareTypes(expected, actual, path, mismatches, strict) {
+    // Kind mismatch
+    if (expected.kind !== actual.kind) {
+        // Special case: unknown expected matches anything
+        if (expected.kind === "unknown")
+            return;
+        // Special case: expected primitive null matches any actual (nullable)
+        if (expected.kind === "primitive" && expected.name === "null")
+            return;
+        mismatches.push({
+            path,
+            issue: "kind_mismatch",
+            expected: describeType(expected),
+            actual: describeType(actual),
+        });
+        return;
+    }
+    switch (expected.kind) {
+        case "primitive": {
+            const expectedName = expected.name;
+            const actualName = actual.name;
+            if (expectedName !== actualName) {
+                mismatches.push({
+                    path,
+                    issue: "type_mismatch",
+                    expected: expectedName,
+                    actual: actualName,
+                });
+            }
+            break;
+        }
+        case "object": {
+            const expectedProps = expected.properties;
+            const actualProps = actual.properties;
+            // Check for missing fields
+            for (const key of Object.keys(expectedProps)) {
+                if (!(key in actualProps)) {
+                    mismatches.push({
+                        path: `${path}.${key}`,
+                        issue: "missing",
+                        expected: describeType(expectedProps[key]),
+                    });
+                }
+                else {
+                    compareTypes(expectedProps[key], actualProps[key], `${path}.${key}`, mismatches, strict);
+                }
+            }
+            // Check for extra fields (warnings in non-strict, errors in strict)
+            if (strict) {
+                for (const key of Object.keys(actualProps)) {
+                    if (!(key in expectedProps)) {
+                        mismatches.push({
+                            path: `${path}.${key}`,
+                            issue: "extra",
+                            actual: describeType(actualProps[key]),
+                        });
+                    }
+                }
+            }
+            break;
+        }
+        case "array": {
+            const expectedElement = expected.element;
+            const actualElement = actual.element;
+            if (expectedElement.kind !== "unknown" && actualElement.kind !== "unknown") {
+                compareTypes(expectedElement, actualElement, `${path}[]`, mismatches, strict);
+            }
+            break;
+        }
+        case "union": {
+            // For unions, check that actual matches at least one member
+            // Simplified: just skip deep comparison for unions
+            break;
+        }
+    }
+}
+function describeType(node) {
+    switch (node.kind) {
+        case "primitive":
+            return node.name;
+        case "object":
+            return "object";
+        case "array":
+            return `${describeType(node.element)}[]`;
+        case "union":
+            return node.members.map(describeType).join(" | ");
+        default:
+            return node.kind;
+    }
+}
+function jsonToTypeNode(value) {
+    if (value === null)
+        return { kind: "primitive", name: "null" };
+    if (value === undefined)
+        return { kind: "primitive", name: "undefined" };
+    switch (typeof value) {
+        case "string": return { kind: "primitive", name: "string" };
+        case "number": return { kind: "primitive", name: "number" };
+        case "boolean": return { kind: "primitive", name: "boolean" };
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return { kind: "array", element: { kind: "unknown" } };
+        return { kind: "array", element: jsonToTypeNode(value[0]) };
+    }
+    const obj = value;
+    const properties = {};
+    for (const [key, val] of Object.entries(obj)) {
+        properties[key] = jsonToTypeNode(val);
+    }
+    return { kind: "object", properties };
+}
+function normalizePath(urlPath) {
+    return urlPath.split("/").map((part, i) => {
+        if (!part)
+            return part;
+        if (/^\d+$/.test(part))
+            return ":id";
+        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(part))
+            return ":id";
+        if (/^[0-9a-f]{16,}$/i.test(part) && i > 1)
+            return ":id";
+        return part;
+    }).join("/");
+}

package/dist/commands/watch.d.ts

@@ -0,0 +1,9 @@
+export interface WatchOptions {
+    dir?: string;
+    env?: string;
+    interval?: string;
+}
+/**
+ * `trickle watch` — Watch for new type observations and auto-regenerate type files.
+ */
+export declare function watchCommand(opts: WatchOptions): Promise<void>;