trickle-cli 0.1.0

package/dist/commands/auto.js

@@ -0,0 +1,268 @@
+"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.autoCommand = autoCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_client_1 = require("../api-client");
+/**
+ * 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 [];
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+    const deps = {
+        ...(pkg.dependencies || {}),
+        ...(pkg.devDependencies || {}),
+    };
+    const formats = [];
+    // Always generate base TypeScript types
+    formats.push({
+        format: "",
+        fileName: "types.d.ts",
+        label: "TypeScript types",
+        reason: "always generated",
+    });
+    // Axios client
+    if (deps["axios"]) {
+        formats.push({
+            format: "axios",
+            fileName: "axios-client.ts",
+            label: "Axios client",
+            reason: "axios detected",
+        });
+    }
+    // Fetch-based client (always useful as a fallback if no axios)
+    if (!deps["axios"]) {
+        formats.push({
+            format: "client",
+            fileName: "api-client.ts",
+            label: "Fetch API client",
+            reason: "default HTTP client",
+        });
+    }
+    // React Query / TanStack Query
+    if (deps["@tanstack/react-query"] || deps["react-query"]) {
+        formats.push({
+            format: "react-query",
+            fileName: "hooks.ts",
+            label: "React Query hooks",
+            reason: deps["@tanstack/react-query"] ? "@tanstack/react-query" : "react-query",
+        });
+    }
+    // SWR
+    if (deps["swr"]) {
+        formats.push({
+            format: "swr",
+            fileName: "swr-hooks.ts",
+            label: "SWR hooks",
+            reason: "swr detected",
+        });
+    }
+    // Zod
+    if (deps["zod"]) {
+        formats.push({
+            format: "zod",
+            fileName: "schemas.ts",
+            label: "Zod schemas",
+            reason: "zod detected",
+        });
+    }
+    // tRPC
+    if (deps["@trpc/server"] || deps["@trpc/client"]) {
+        formats.push({
+            format: "trpc",
+            fileName: "trpc-router.ts",
+            label: "tRPC router",
+            reason: deps["@trpc/server"] ? "@trpc/server" : "@trpc/client",
+        });
+    }
+    // class-validator / NestJS
+    if (deps["class-validator"] || deps["@nestjs/common"]) {
+        formats.push({
+            format: "class-validator",
+            fileName: "dtos.ts",
+            label: "class-validator DTOs",
+            reason: deps["class-validator"] ? "class-validator" : "@nestjs/common",
+        });
+    }
+    // Express handler types
+    if (deps["express"] || deps["@types/express"]) {
+        formats.push({
+            format: "handlers",
+            fileName: "handlers.d.ts",
+            label: "Express handler types",
+            reason: deps["express"] ? "express" : "@types/express",
+        });
+        formats.push({
+            format: "middleware",
+            fileName: "middleware.ts",
+            label: "Express middleware",
+            reason: deps["express"] ? "express" : "@types/express",
+        });
+    }
+    // MSW
+    if (deps["msw"]) {
+        formats.push({
+            format: "msw",
+            fileName: "msw-handlers.ts",
+            label: "MSW mock handlers",
+            reason: "msw detected",
+        });
+    }
+    // Pydantic (Python projects)
+    if (fs.existsSync(path.join(projectDir, "requirements.txt")) ||
+        fs.existsSync(path.join(projectDir, "pyproject.toml"))) {
+        // Check if pydantic is in requirements
+        let hasPydantic = false;
+        try {
+            const reqPath = path.join(projectDir, "requirements.txt");
+            if (fs.existsSync(reqPath)) {
+                const reqs = fs.readFileSync(reqPath, "utf-8");
+                if (reqs.toLowerCase().includes("pydantic"))
+                    hasPydantic = true;
+            }
+            const pyprojectPath = path.join(projectDir, "pyproject.toml");
+            if (fs.existsSync(pyprojectPath)) {
+                const pyproject = fs.readFileSync(pyprojectPath, "utf-8");
+                if (pyproject.toLowerCase().includes("pydantic"))
+                    hasPydantic = true;
+            }
+        }
+        catch { }
+        if (hasPydantic) {
+            formats.push({
+                format: "pydantic",
+                fileName: "models.py",
+                label: "Pydantic models",
+                reason: "pydantic detected",
+            });
+        }
+    }
+    // Type guards (always useful)
+    formats.push({
+        format: "guards",
+        fileName: "guards.ts",
+        label: "Type guards",
+        reason: "runtime type checking",
+    });
+    return formats;
+}
+/**
+ * `trickle auto` — Auto-detect project deps and generate only relevant type files.
+ */
+async function autoCommand(opts) {
+    const projectDir = process.cwd();
+    const outDir = path.resolve(opts.dir || ".trickle");
+    // Detect formats
+    const formats = detectFormats(projectDir);
+    if (formats.length === 0) {
+        console.error(chalk_1.default.red("\n  No package.json found in current directory."));
+        console.error(chalk_1.default.gray("  Run this command from your project root.\n"));
+        process.exit(1);
+    }
+    // Ensure output directory
+    if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+    }
+    console.log("");
+    console.log(chalk_1.default.bold("  trickle auto"));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log(chalk_1.default.gray(`  Project: ${projectDir}`));
+    console.log(chalk_1.default.gray(`  Output:  ${outDir}`));
+    if (opts.env) {
+        console.log(chalk_1.default.gray(`  Env:     ${opts.env}`));
+    }
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log("");
+    // Show detected formats
+    console.log(chalk_1.default.gray("  Detected dependencies:"));
+    for (const f of formats) {
+        console.log(chalk_1.default.gray(`    ${chalk_1.default.white(f.label)} ← ${f.reason}`));
+    }
+    console.log("");
+    // Generate each format
+    const queryOpts = { env: opts.env };
+    let generated = 0;
+    let skipped = 0;
+    for (const f of formats) {
+        const filePath = path.join(outDir, f.fileName);
+        try {
+            const result = await (0, api_client_1.fetchCodegen)({
+                ...queryOpts,
+                format: f.format || undefined,
+            });
+            const content = result.types;
+            if (!content || content.includes("No functions found") || content.includes("No API routes found")) {
+                console.log(chalk_1.default.yellow("  ─ ") + chalk_1.default.gray(`${f.fileName} (no data)`));
+                skipped++;
+                continue;
+            }
+            fs.writeFileSync(filePath, content, "utf-8");
+            generated++;
+            const size = content.split("\n").length;
+            console.log(chalk_1.default.green("  ✓ ") +
+                chalk_1.default.bold(f.fileName) +
+                chalk_1.default.gray(` (${size} lines)`));
+        }
+        catch {
+            console.log(chalk_1.default.yellow("  ─ ") + chalk_1.default.gray(`${f.fileName} (error)`));
+            skipped++;
+        }
+    }
+    console.log("");
+    if (generated > 0) {
+        console.log(chalk_1.default.green(`  ${generated} files generated`) +
+            (skipped > 0 ? chalk_1.default.gray(`, ${skipped} skipped`) : ""));
+        console.log(chalk_1.default.gray(`  Output directory: ${outDir}`));
+    }
+    else {
+        console.log(chalk_1.default.yellow("  No files generated — instrument your app and make some requests first."));
+    }
+    console.log("");
+}

package/dist/commands/capture.d.ts

@@ -0,0 +1,14 @@
+export interface CaptureOptions {
+    header?: string[];
+    body?: string;
+    env?: string;
+    module?: string;
+}
+/**
+ * `trickle capture <method> <url>` — Capture types from a live API endpoint.
+ *
+ * Makes an HTTP request to the given URL, infers TypeNode from the response,
+ * and sends the observation to the trickle backend. Zero instrumentation needed —
+ * just point at any API and start collecting types.
+ */
+export declare function captureCommand(method: string, url: string, opts: CaptureOptions): Promise<void>;

package/dist/commands/capture.js

@@ -0,0 +1,271 @@
+"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.captureCommand = captureCommand;
+const crypto = __importStar(require("crypto"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config");
+/**
+ * `trickle capture <method> <url>` — Capture types from a live API endpoint.
+ *
+ * Makes an HTTP request to the given URL, infers TypeNode from the response,
+ * and sends the observation to the trickle backend. Zero instrumentation needed —
+ * just point at any API and start collecting types.
+ */
+async function captureCommand(method, url, opts) {
+    const backendUrl = (0, config_1.getBackendUrl)();
+    // Validate method
+    const httpMethod = method.toUpperCase();
+    const validMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+    if (!validMethods.includes(httpMethod)) {
+        console.error(chalk_1.default.red(`\n  Invalid HTTP method: ${method}`));
+        console.error(chalk_1.default.gray(`  Valid methods: ${validMethods.join(", ")}\n`));
+        process.exit(1);
+    }
+    // Parse URL
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(url);
+    }
+    catch {
+        console.error(chalk_1.default.red(`\n  Invalid URL: ${url}\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 format: ${h}`));
+                console.error(chalk_1.default.gray('  Use "Header-Name: value" format\n'));
+                process.exit(1);
+            }
+            const key = h.slice(0, colonIdx).trim();
+            const value = h.slice(colonIdx + 1).trim();
+            headers[key] = value;
+        }
+    }
+    // Parse request body
+    let reqBody;
+    let reqJson = undefined;
+    if (opts.body) {
+        reqBody = opts.body;
+        headers["Content-Type"] = headers["Content-Type"] || "application/json";
+        try {
+            reqJson = JSON.parse(opts.body);
+        }
+        catch {
+            // Not JSON body — that's fine
+        }
+    }
+    // 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)}`));
+        console.error(chalk_1.default.gray("  Start the backend first: npx trickle-backend\n"));
+        process.exit(1);
+    }
+    console.log("");
+    console.log(chalk_1.default.bold("  trickle capture"));
+    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}`));
+    // Read response body
+    const resText = await response.text();
+    let resJson = undefined;
+    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.yellow("\n  Response is not valid JSON — cannot capture types.\n"));
+            process.exit(1);
+        }
+    }
+    else {
+        console.error(chalk_1.default.yellow("\n  Response is not JSON — cannot capture types."));
+        console.error(chalk_1.default.gray(`  Content-Type: ${contentType}\n`));
+        process.exit(1);
+    }
+    // Build type observations
+    const routePath = normalizePath(parsedUrl.pathname);
+    const functionName = `${httpMethod} ${routePath}`;
+    const argsProperties = {};
+    if (reqJson !== undefined && reqJson !== null) {
+        argsProperties.body = jsonToTypeNode(reqJson);
+    }
+    // Extract query params
+    if (parsedUrl.search) {
+        const queryProps = {};
+        for (const [key] of parsedUrl.searchParams) {
+            queryProps[key] = { kind: "primitive", name: "string" };
+        }
+        if (Object.keys(queryProps).length > 0) {
+            argsProperties.query = { kind: "object", properties: queryProps };
+        }
+    }
+    const argsType = Object.keys(argsProperties).length > 0
+        ? { kind: "object", properties: argsProperties }
+        : { kind: "object", properties: {} };
+    const returnType = jsonToTypeNode(resJson);
+    const typeHash = computeTypeHash(argsType, returnType);
+    const payload = {
+        functionName,
+        module: opts.module || "capture",
+        language: "js",
+        environment: opts.env || "development",
+        typeHash,
+        argsType,
+        returnType,
+        sampleInput: Object.keys(argsProperties).length > 0 ? argsProperties : undefined,
+        sampleOutput: resJson,
+    };
+    // Send to backend
+    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}`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        console.error(chalk_1.default.red(`\n  Failed to send types to backend: ${msg}\n`));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.gray(`  Route:    `) + chalk_1.default.white(functionName));
+    console.log(chalk_1.default.gray(`  Backend:  `) + chalk_1.default.white(backendUrl));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log(chalk_1.default.green("  Types captured successfully!"));
+    // Show a preview of what was captured
+    const fieldCount = countFields(returnType);
+    console.log(chalk_1.default.gray(`  Response shape: ${fieldCount} fields observed`));
+    if (reqJson) {
+        const reqFieldCount = countFields(argsProperties.body || { kind: "object", properties: {} });
+        console.log(chalk_1.default.gray(`  Request body:   ${reqFieldCount} fields observed`));
+    }
+    console.log("");
+    console.log(chalk_1.default.gray("  Run ") + chalk_1.default.white(`trickle codegen`) + chalk_1.default.gray(" to generate type definitions."));
+    console.log("");
+}
+/**
+ * Infer a TypeNode from a JSON value.
+ */
+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" } };
+        const elementType = jsonToTypeNode(value[0]);
+        return { kind: "array", element: elementType };
+    }
+    // Object
+    const obj = value;
+    const properties = {};
+    for (const [key, val] of Object.entries(obj)) {
+        properties[key] = jsonToTypeNode(val);
+    }
+    return { kind: "object", properties };
+}
+/**
+ * Normalize URL path: replace dynamic segments with :param patterns.
+ */
+function normalizePath(urlPath) {
+    const parts = urlPath.split("/");
+    return parts
+        .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("/");
+}
+function computeTypeHash(argsType, returnType) {
+    const data = JSON.stringify({ a: argsType, r: returnType });
+    return crypto.createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+function countFields(node) {
+    if (node.kind === "object" && node.properties) {
+        return Object.keys(node.properties).length;
+    }
+    if (node.kind === "array")
+        return 1;
+    return 1;
+}

package/dist/commands/check.d.ts

@@ -0,0 +1,6 @@
+export interface CheckOptions {
+    save?: string;
+    against?: string;
+    env?: string;
+}
+export declare function checkCommand(opts: CheckOptions): Promise<void>;