trickle-cli 0.1.0

package/dist/commands/test-gen.js

@@ -0,0 +1,237 @@
+"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.testGenCommand = testGenCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_client_1 = require("../api-client");
+/**
+ * `trickle test --generate` — Generate API test files from runtime observations.
+ *
+ * Uses real sample request/response data captured at runtime to generate
+ * ready-to-run test files with correct endpoints, request bodies, and
+ * response shape assertions.
+ */
+async function testGenCommand(opts) {
+    const framework = opts.framework || "vitest";
+    const baseUrl = opts.baseUrl || "http://localhost:3000";
+    if (framework !== "vitest" && framework !== "jest") {
+        console.error(chalk_1.default.red(`\n  Unsupported framework: ${framework}`));
+        console.error(chalk_1.default.gray("  Supported: vitest, jest\n"));
+        process.exit(1);
+    }
+    try {
+        const { routes } = await (0, api_client_1.fetchMockConfig)();
+        if (routes.length === 0) {
+            console.error(chalk_1.default.yellow("\n  No API routes observed yet."));
+            console.error(chalk_1.default.gray("  Instrument your app and make some requests first.\n"));
+            process.exit(1);
+        }
+        const testCode = generateTestFile(routes, framework, baseUrl);
+        if (opts.out) {
+            const resolvedPath = path.resolve(opts.out);
+            const dir = path.dirname(resolvedPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(resolvedPath, testCode, "utf-8");
+            console.log("");
+            console.log(chalk_1.default.green(`  Tests written to ${chalk_1.default.bold(opts.out)}`));
+            console.log(chalk_1.default.gray(`  ${routes.length} route tests generated (${framework})`));
+            console.log(chalk_1.default.gray(`  Run with: npx ${framework === "vitest" ? "vitest run" : "jest"} ${opts.out}`));
+            console.log("");
+        }
+        else {
+            console.log("");
+            console.log(testCode);
+        }
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            console.error(chalk_1.default.red(`\n  Error: ${err.message}\n`));
+        }
+        process.exit(1);
+    }
+}
+function generateTestFile(routes, framework, baseUrl) {
+    const lines = [];
+    lines.push("// Auto-generated API tests by trickle");
+    lines.push(`// Generated at ${new Date().toISOString()}`);
+    lines.push("// Do not edit manually — re-run `trickle test --generate` to update");
+    lines.push("");
+    // Import block
+    if (framework === "vitest") {
+        lines.push('import { describe, it, expect } from "vitest";');
+    }
+    // jest needs no import — globals are available
+    lines.push("");
+    lines.push(`const BASE_URL = process.env.TEST_API_URL || "${baseUrl}";`);
+    lines.push("");
+    // Group routes by resource path prefix
+    const groups = groupByResource(routes);
+    for (const [resource, resourceRoutes] of Object.entries(groups)) {
+        lines.push(`describe("${resource}", () => {`);
+        for (const route of resourceRoutes) {
+            const testName = `${route.method} ${route.path}`;
+            const hasBody = ["POST", "PUT", "PATCH"].includes(route.method);
+            lines.push(`  it("${testName} — returns expected shape", async () => {`);
+            // Build fetch call
+            const fetchPath = route.path.replace(/:(\w+)/g, (_, param) => {
+                // Use sample data to get a real param value if available
+                const sampleValue = extractParamFromSample(route.sampleInput, param);
+                return sampleValue || `test-${param}`;
+            });
+            lines.push(`    const res = await fetch(\`\${BASE_URL}${fetchPath}\`, {`);
+            lines.push(`      method: "${route.method}",`);
+            if (hasBody && route.sampleInput) {
+                const bodyData = extractBodyFromSample(route.sampleInput);
+                if (bodyData && Object.keys(bodyData).length > 0) {
+                    lines.push(`      headers: { "Content-Type": "application/json" },`);
+                    lines.push(`      body: JSON.stringify(${JSON.stringify(bodyData, null, 6).replace(/\n/g, "\n      ")}),`);
+                }
+            }
+            lines.push("    });");
+            lines.push("");
+            // Status assertion
+            lines.push("    expect(res.ok).toBe(true);");
+            lines.push(`    expect(res.status).toBe(200);`);
+            lines.push("");
+            // Response body assertions
+            lines.push("    const body = await res.json();");
+            if (route.sampleOutput && typeof route.sampleOutput === "object") {
+                const assertions = generateAssertions(route.sampleOutput, "body");
+                for (const assertion of assertions) {
+                    lines.push(`    ${assertion}`);
+                }
+            }
+            lines.push("  });");
+            lines.push("");
+        }
+        lines.push("});");
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd() + "\n";
+}
+/**
+ * Group routes by their first meaningful path segment.
+ */
+function groupByResource(routes) {
+    const groups = {};
+    for (const route of routes) {
+        const parts = route.path.split("/").filter(Boolean);
+        // /api/users → "api/users", /users → "users"
+        let resource;
+        if (parts[0] === "api" && parts.length >= 2) {
+            resource = `/api/${parts[1]}`;
+        }
+        else {
+            resource = `/${parts[0] || "root"}`;
+        }
+        if (!groups[resource])
+            groups[resource] = [];
+        groups[resource].push(route);
+    }
+    return groups;
+}
+/**
+ * Try to extract a path param value from sample input.
+ */
+function extractParamFromSample(sampleInput, param) {
+    if (!sampleInput || typeof sampleInput !== "object")
+        return null;
+    const input = sampleInput;
+    // Check params object
+    if (input.params && typeof input.params === "object") {
+        const params = input.params;
+        if (params[param] !== undefined)
+            return String(params[param]);
+    }
+    return null;
+}
+/**
+ * Extract request body from sample input.
+ */
+function extractBodyFromSample(sampleInput) {
+    if (!sampleInput || typeof sampleInput !== "object")
+        return null;
+    const input = sampleInput;
+    if (input.body && typeof input.body === "object") {
+        return input.body;
+    }
+    return null;
+}
+/**
+ * Generate expect() assertions for a sample response object.
+ * Checks structure (property existence and types), not exact values.
+ */
+function generateAssertions(obj, path, depth = 0) {
+    if (depth > 3)
+        return []; // Prevent deeply nested assertions
+    const assertions = [];
+    for (const [key, value] of Object.entries(obj)) {
+        const propPath = `${path}.${key}`;
+        if (value === null) {
+            assertions.push(`expect(${propPath}).toBeNull();`);
+        }
+        else if (Array.isArray(value)) {
+            assertions.push(`expect(Array.isArray(${propPath})).toBe(true);`);
+            // If array has items, assert shape of first element
+            if (value.length > 0 && typeof value[0] === "object" && value[0] !== null) {
+                assertions.push(`expect(${propPath}.length).toBeGreaterThan(0);`);
+                const itemAssertions = generateAssertions(value[0], `${propPath}[0]`, depth + 1);
+                assertions.push(...itemAssertions);
+            }
+        }
+        else if (typeof value === "object") {
+            assertions.push(`expect(typeof ${propPath}).toBe("object");`);
+            const nestedAssertions = generateAssertions(value, propPath, depth + 1);
+            assertions.push(...nestedAssertions);
+        }
+        else if (typeof value === "string") {
+            assertions.push(`expect(typeof ${propPath}).toBe("string");`);
+        }
+        else if (typeof value === "number") {
+            assertions.push(`expect(typeof ${propPath}).toBe("number");`);
+        }
+        else if (typeof value === "boolean") {
+            assertions.push(`expect(typeof ${propPath}).toBe("boolean");`);
+        }
+    }
+    return assertions;
+}

package/dist/commands/trace.d.ts

@@ -0,0 +1,14 @@
+export interface TraceOptions {
+    header?: string[];
+    body?: string;
+    save?: boolean;
+    env?: string;
+    module?: string;
+}
+/**
+ * `trickle trace <method> <url>` — Make an HTTP request and show the response
+ * with inline type annotations. Like curl but type-aware.
+ *
+ * Optionally saves the types to the backend with --save.
+ */
+export declare function traceCommand(method: string, url: string, opts: TraceOptions): Promise<void>;

package/dist/commands/trace.js

@@ -0,0 +1,417 @@
+"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.traceCommand = traceCommand;
+const crypto = __importStar(require("crypto"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config");
+/**
+ * `trickle trace <method> <url>` — Make an HTTP request and show the response
+ * with inline type annotations. Like curl but type-aware.
+ *
+ * Optionally saves the types to the backend with --save.
+ */
+async function traceCommand(method, url, opts) {
+    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}\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);
+    }
+    // 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;
+    let reqJson = undefined;
+    if (opts.body) {
+        reqBody = opts.body;
+        headers["Content-Type"] = headers["Content-Type"] || "application/json";
+        try {
+            reqJson = JSON.parse(opts.body);
+        }
+        catch { }
+    }
+    console.log("");
+    console.log(chalk_1.default.bold("  trickle trace"));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    // Make the request
+    const startTime = Date.now();
+    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 elapsed = Date.now() - startTime;
+    // Status line
+    const status = response.status;
+    const statusColor = status < 300 ? chalk_1.default.green : status < 400 ? chalk_1.default.yellow : chalk_1.default.red;
+    console.log(chalk_1.default.gray(`  ${chalk_1.default.bold(httpMethod)} ${url}`));
+    console.log(chalk_1.default.gray(`  Status: `) +
+        statusColor(`${status} ${response.statusText}`) +
+        chalk_1.default.gray(` (${elapsed}ms)`));
+    // Show response headers summary
+    const contentType = response.headers.get("content-type") || "";
+    const contentLength = response.headers.get("content-length");
+    console.log(chalk_1.default.gray(`  Type:   ${contentType}`));
+    if (contentLength) {
+        console.log(chalk_1.default.gray(`  Size:   ${formatBytes(parseInt(contentLength, 10))}`));
+    }
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    // Read and parse body
+    const bodyText = await response.text();
+    if (!contentType.includes("json") || bodyText.length === 0) {
+        console.log("");
+        if (bodyText.length > 0) {
+            console.log(chalk_1.default.gray("  (non-JSON response)"));
+            console.log(chalk_1.default.gray("  " + bodyText.slice(0, 500)));
+        }
+        else {
+            console.log(chalk_1.default.gray("  (empty response)"));
+        }
+        console.log("");
+        return;
+    }
+    let jsonData;
+    try {
+        jsonData = JSON.parse(bodyText);
+    }
+    catch {
+        console.error(chalk_1.default.red("\n  Response is not valid JSON.\n"));
+        process.exit(1);
+    }
+    // Render annotated JSON
+    console.log("");
+    const lines = renderAnnotatedJson(jsonData, 2);
+    for (const line of lines) {
+        console.log(line);
+    }
+    // Summary
+    const typeNode = jsonToTypeNode(jsonData);
+    const stats = countTypeStats(typeNode);
+    console.log("");
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log(chalk_1.default.gray(`  ${stats.fields} fields, ${stats.uniqueTypes} unique types, ${stats.depth} depth`));
+    // Optionally save to backend
+    if (opts.save) {
+        await saveTypes(parsedUrl, httpMethod, jsonData, reqJson, opts);
+    }
+    console.log("");
+}
+/**
+ * Render JSON with inline type annotations.
+ */
+function renderAnnotatedJson(value, baseIndent) {
+    const lines = [];
+    renderValue(value, baseIndent, 0, lines, false, true);
+    return lines;
+}
+function renderValue(value, baseIndent, depth, lines, trailingComma, isLast) {
+    const indent = " ".repeat(baseIndent + depth * 2);
+    const comma = trailingComma ? "," : "";
+    const annotationGap = 2;
+    if (value === null) {
+        lines.push(indent + chalk_1.default.gray("null") + comma + typeAnnotation("null", indent.length + 4, annotationGap));
+        return;
+    }
+    if (value === undefined) {
+        lines.push(indent + chalk_1.default.gray("undefined") + comma);
+        return;
+    }
+    switch (typeof value) {
+        case "string": {
+            const display = value.length > 60 ? `"${value.slice(0, 57)}..."` : `"${value}"`;
+            lines.push(indent + chalk_1.default.green(display) + comma + typeAnnotation("string", indent.length + display.length, annotationGap));
+            return;
+        }
+        case "number":
+            lines.push(indent + chalk_1.default.yellow(String(value)) + comma + typeAnnotation("number", indent.length + String(value).length, annotationGap));
+            return;
+        case "boolean":
+            lines.push(indent + chalk_1.default.blue(String(value)) + comma + typeAnnotation("boolean", indent.length + String(value).length, annotationGap));
+            return;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            lines.push(indent + "[]" + comma + typeAnnotation("unknown[]", indent.length + 2, annotationGap));
+            return;
+        }
+        // Show type annotation on the opening bracket
+        const elemType = compactType(jsonToTypeNode(value[0]));
+        lines.push(indent + "[" + typeAnnotation(`${elemType}[]`, indent.length + 1, annotationGap));
+        // Show first few elements, collapse if too many
+        const maxShow = Math.min(value.length, 3);
+        for (let i = 0; i < maxShow; i++) {
+            renderValue(value[i], baseIndent, depth + 1, lines, i < value.length - 1, i === maxShow - 1);
+        }
+        if (value.length > maxShow) {
+            const innerIndent = " ".repeat(baseIndent + (depth + 1) * 2);
+            lines.push(innerIndent + chalk_1.default.gray(`// ... +${value.length - maxShow} more items`));
+        }
+        lines.push(indent + "]" + comma);
+        return;
+    }
+    // Object
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+        lines.push(indent + "{}" + comma + typeAnnotation("{}", indent.length + 2, annotationGap));
+        return;
+    }
+    lines.push(indent + "{");
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const val = obj[key];
+        const isLastKey = i === keys.length - 1;
+        const keyComma = isLastKey ? "" : ",";
+        const innerIndent = " ".repeat(baseIndent + (depth + 1) * 2);
+        // For simple values, render key: value on one line
+        if (val === null || typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+            const valStr = formatSimpleValue(val);
+            const valType = val === null ? "null" : typeof val;
+            const lineContent = `${innerIndent}${chalk_1.default.white(`"${key}"`)}: ${valStr}${keyComma}`;
+            const rawLen = innerIndent.length + `"${key}": `.length + rawValueLen(val) + keyComma.length;
+            lines.push(lineContent + typeAnnotation(valType, rawLen, annotationGap));
+        }
+        else {
+            // Complex value — render key then value
+            lines.push(`${innerIndent}${chalk_1.default.white(`"${key}"`)}:`);
+            renderValue(val, baseIndent, depth + 1, lines, !isLastKey, isLastKey);
+        }
+    }
+    lines.push(indent + "}" + comma);
+}
+function formatSimpleValue(val) {
+    if (val === null)
+        return chalk_1.default.gray("null");
+    if (typeof val === "string") {
+        const display = val.length > 50 ? `"${val.slice(0, 47)}..."` : `"${val}"`;
+        return chalk_1.default.green(display);
+    }
+    if (typeof val === "number")
+        return chalk_1.default.yellow(String(val));
+    if (typeof val === "boolean")
+        return chalk_1.default.blue(String(val));
+    return String(val);
+}
+function rawValueLen(val) {
+    if (val === null)
+        return 4;
+    if (typeof val === "string") {
+        return Math.min(val.length + 2, 53);
+    }
+    return String(val).length;
+}
+function typeAnnotation(type, currentCol, gap) {
+    const targetCol = 45;
+    const padding = Math.max(gap, targetCol - currentCol);
+    return " ".repeat(padding) + chalk_1.default.gray(`// ${type}`);
+}
+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 compactType(node) {
+    switch (node.kind) {
+        case "primitive":
+            return node.name;
+        case "object": {
+            const props = node.properties;
+            const keys = Object.keys(props);
+            if (keys.length === 0)
+                return "{}";
+            if (keys.length <= 4) {
+                return `{${keys.join(", ")}}`;
+            }
+            return `{${keys.slice(0, 3).join(", ")}, …+${keys.length - 3}}`;
+        }
+        case "array":
+            return `${compactType(node.element)}[]`;
+        default:
+            return node.kind;
+    }
+}
+function countTypeStats(node) {
+    const types = new Set();
+    let fields = 0;
+    let maxDepth = 0;
+    function walk(n, depth) {
+        maxDepth = Math.max(maxDepth, depth);
+        if (n.kind === "primitive") {
+            types.add(n.name);
+        }
+        else if (n.kind === "object") {
+            const props = n.properties;
+            for (const val of Object.values(props)) {
+                fields++;
+                walk(val, depth + 1);
+            }
+        }
+        else if (n.kind === "array") {
+            types.add("array");
+            walk(n.element, depth + 1);
+        }
+    }
+    walk(node, 0);
+    return { fields, uniqueTypes: types.size, depth: maxDepth };
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+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("/");
+}
+function computeTypeHash(argsType, returnType) {
+    const data = JSON.stringify({ a: argsType, r: returnType });
+    return crypto.createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+async function saveTypes(parsedUrl, httpMethod, resJson, reqJson, opts) {
+    const backendUrl = (0, config_1.getBackendUrl)();
+    try {
+        const res = await fetch(`${backendUrl}/api/health`, { signal: AbortSignal.timeout(3000) });
+        if (!res.ok)
+            throw new Error("not ok");
+    }
+    catch {
+        console.log(chalk_1.default.yellow("  Could not save types — backend not reachable."));
+        return;
+    }
+    const routePath = normalizePath(parsedUrl.pathname);
+    const functionName = `${httpMethod} ${routePath}`;
+    const argsProperties = {};
+    if (reqJson !== undefined && reqJson !== null) {
+        argsProperties.body = jsonToTypeNode(reqJson);
+    }
+    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 || "trace",
+        language: "js",
+        environment: opts.env || "development",
+        typeHash,
+        argsType,
+        returnType,
+        sampleOutput: resJson,
+        sampleInput: Object.keys(argsProperties).length > 0 ? argsProperties : undefined,
+    };
+    try {
+        const ingestRes = await fetch(`${backendUrl}/api/ingest`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!ingestRes.ok)
+            throw new Error(`HTTP ${ingestRes.status}`);
+        console.log(chalk_1.default.green(`  Types saved as "${functionName}"`));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        console.log(chalk_1.default.yellow(`  Could not save types: ${msg}`));
+    }
+}

package/dist/commands/types.d.ts

@@ -0,0 +1,7 @@
+export interface TypesOptions {
+    env?: string;
+    diff?: boolean;
+    env1?: string;
+    env2?: string;
+}
+export declare function typesCommand(functionName: string, opts: TypesOptions): Promise<void>;