trickle-cli 0.1.0

package/dist/commands/export.js

@@ -0,0 +1,238 @@
+"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.exportCommand = exportCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_client_1 = require("../api-client");
+/**
+ * `trickle export` — Generate all output formats into a directory at once.
+ *
+ * Creates a complete `.trickle/` directory with:
+ * - types.d.ts — TypeScript type declarations
+ * - api-client.ts — Typed fetch-based API client
+ * - handlers.d.ts — Express handler type aliases
+ * - schemas.ts — Zod validation schemas
+ * - hooks.ts — TanStack React Query hooks
+ * - guards.ts — Runtime type guard functions
+ * - openapi.json — OpenAPI 3.0 specification
+ * - api.test.ts — Generated API test scaffolds
+ */
+async function exportCommand(opts) {
+    const outDir = path.resolve(opts.dir || ".trickle");
+    // Ensure directory exists
+    if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+    }
+    console.log("");
+    console.log(chalk_1.default.bold("  trickle export"));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log(chalk_1.default.gray(`  Output directory: ${outDir}`));
+    if (opts.env) {
+        console.log(chalk_1.default.gray(`  Environment: ${opts.env}`));
+    }
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log("");
+    const results = [];
+    const queryOpts = { env: opts.env };
+    // 1. TypeScript types
+    results.push(await generateFile(path.join(outDir, "types.d.ts"), "TypeScript types", () => (0, api_client_1.fetchCodegen)({ ...queryOpts }).then((r) => r.types), countInterfaces));
+    // 2. API client
+    results.push(await generateFile(path.join(outDir, "api-client.ts"), "Typed API client", () => (0, api_client_1.fetchCodegen)({ ...queryOpts, format: "client" }).then((r) => r.types), countFunctions));
+    // 3. Express handler types
+    results.push(await generateFile(path.join(outDir, "handlers.d.ts"), "Express handler types", () => (0, api_client_1.fetchCodegen)({ ...queryOpts, format: "handlers" }).then((r) => r.types), countHandlers));
+    // 4. Zod schemas
+    results.push(await generateFile(path.join(outDir, "schemas.ts"), "Zod schemas", () => (0, api_client_1.fetchCodegen)({ ...queryOpts, format: "zod" }).then((r) => r.types), countSchemas));
+    // 5. React Query hooks
+    results.push(await generateFile(path.join(outDir, "hooks.ts"), "React Query hooks", () => (0, api_client_1.fetchCodegen)({ ...queryOpts, format: "react-query" }).then((r) => r.types), countHooks));
+    // 6. Type guards
+    results.push(await generateFile(path.join(outDir, "guards.ts"), "Type guards", () => (0, api_client_1.fetchCodegen)({ ...queryOpts, format: "guards" }).then((r) => r.types), countGuards));
+    // OpenAPI spec
+    results.push(await generateFile(path.join(outDir, "openapi.json"), "OpenAPI 3.0 spec", async () => {
+        const spec = await (0, api_client_1.fetchOpenApiSpec)({ env: opts.env });
+        return JSON.stringify(spec, null, 2);
+    }, countPaths));
+    // API tests
+    results.push(await generateFile(path.join(outDir, "api.test.ts"), "API test scaffolds", async () => {
+        const { routes } = await (0, api_client_1.fetchMockConfig)();
+        if (routes.length === 0)
+            return null;
+        // Use the testGenCommand's internal logic by fetching via codegen format?
+        // Actually, let's generate a simple version directly
+        return generateTestContent(routes);
+    }, countTests));
+    // Summary
+    console.log("");
+    const successCount = results.filter((r) => r.ok).length;
+    const skipCount = results.filter((r) => !r.ok).length;
+    for (const r of results) {
+        if (r.ok) {
+            const countStr = r.count ? chalk_1.default.gray(` (${r.count})`) : "";
+            console.log(chalk_1.default.green("  ✓ ") + chalk_1.default.bold(r.file) + countStr);
+        }
+        else {
+            console.log(chalk_1.default.yellow("  ─ ") + chalk_1.default.gray(r.file) + chalk_1.default.gray(" (skipped — no data)"));
+        }
+    }
+    console.log("");
+    if (successCount > 0) {
+        console.log(chalk_1.default.green(`  ${successCount} files generated`) + (skipCount > 0 ? chalk_1.default.gray(`, ${skipCount} skipped`) : ""));
+    }
+    else {
+        console.log(chalk_1.default.yellow("  No files generated — instrument your app and make some requests first."));
+    }
+    console.log("");
+}
+async function generateFile(filePath, label, generator, counter) {
+    const fileName = path.basename(filePath);
+    try {
+        const content = await generator();
+        if (!content || content.includes("No functions found") || content.includes("No API routes found") || content.includes("No observations")) {
+            return { file: fileName, label, ok: false };
+        }
+        fs.writeFileSync(filePath, content, "utf-8");
+        const count = counter(content);
+        return { file: fileName, label, ok: true, count };
+    }
+    catch {
+        return { file: fileName, label, ok: false };
+    }
+}
+function countInterfaces(content) {
+    const count = (content.match(/export (interface|type) /g) || []).length;
+    return count > 0 ? `${count} types` : undefined;
+}
+function countFunctions(content) {
+    if (content.includes("createTrickleClient"))
+        return "client factory";
+    return undefined;
+}
+function countHandlers(content) {
+    const count = (content.match(/export type \w+Handler/g) || []).length;
+    return count > 0 ? `${count} handlers` : undefined;
+}
+function countSchemas(content) {
+    const count = (content.match(/Schema = /g) || []).length;
+    return count > 0 ? `${count} schemas` : undefined;
+}
+function countHooks(content) {
+    const count = (content.match(/export function use\w+/g) || []).length;
+    return count > 0 ? `${count} hooks` : undefined;
+}
+function countPaths(content) {
+    try {
+        const spec = JSON.parse(content);
+        const paths = Object.keys(spec.paths || {}).length;
+        return paths > 0 ? `${paths} paths` : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function countTests(content) {
+    const count = (content.match(/it\("/g) || []).length;
+    return count > 0 ? `${count} tests` : undefined;
+}
+function countGuards(content) {
+    const count = (content.match(/export function is\w+/g) || []).length;
+    return count > 0 ? `${count} guards` : undefined;
+}
+function generateTestContent(routes) {
+    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 export` to update");
+    lines.push("");
+    lines.push('import { describe, it, expect } from "vitest";');
+    lines.push("");
+    lines.push('const BASE_URL = process.env.TEST_API_URL || "http://localhost:3000";');
+    lines.push("");
+    // Group by resource
+    const groups = {};
+    for (const r of routes) {
+        const parts = r.path.split("/").filter(Boolean);
+        const resource = parts[0] === "api" && parts.length >= 2 ? `/api/${parts[1]}` : `/${parts[0] || "root"}`;
+        if (!groups[resource])
+            groups[resource] = [];
+        groups[resource].push(r);
+    }
+    for (const [resource, resourceRoutes] of Object.entries(groups)) {
+        lines.push(`describe("${resource}", () => {`);
+        for (const route of resourceRoutes) {
+            const hasBody = ["POST", "PUT", "PATCH"].includes(route.method);
+            const fetchPath = route.path.replace(/:(\w+)/g, "test-$1");
+            lines.push(`  it("${route.method} ${route.path} — returns expected shape", async () => {`);
+            lines.push(`    const res = await fetch(\`\${BASE_URL}${fetchPath}\`, {`);
+            lines.push(`      method: "${route.method}",`);
+            if (hasBody && route.sampleInput) {
+                const body = typeof route.sampleInput === "object" && route.sampleInput !== null
+                    ? route.sampleInput.body || route.sampleInput
+                    : route.sampleInput;
+                if (body && typeof body === "object" && Object.keys(body).length > 0) {
+                    lines.push(`      headers: { "Content-Type": "application/json" },`);
+                    lines.push(`      body: JSON.stringify(${JSON.stringify(body)}),`);
+                }
+            }
+            lines.push("    });");
+            lines.push("    expect(res.ok).toBe(true);");
+            if (route.sampleOutput && typeof route.sampleOutput === "object") {
+                lines.push("    const body = await res.json();");
+                for (const [key, value] of Object.entries(route.sampleOutput)) {
+                    if (Array.isArray(value)) {
+                        lines.push(`    expect(Array.isArray(body.${key})).toBe(true);`);
+                    }
+                    else if (typeof value === "string") {
+                        lines.push(`    expect(typeof body.${key}).toBe("string");`);
+                    }
+                    else if (typeof value === "number") {
+                        lines.push(`    expect(typeof body.${key}).toBe("number");`);
+                    }
+                    else if (typeof value === "boolean") {
+                        lines.push(`    expect(typeof body.${key}).toBe("boolean");`);
+                    }
+                }
+            }
+            lines.push("  });");
+            lines.push("");
+        }
+        lines.push("});");
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd() + "\n";
+}

package/dist/commands/functions.d.ts

@@ -0,0 +1,6 @@
+export interface FunctionsOptions {
+    env?: string;
+    lang?: string;
+    search?: string;
+}
+export declare function functionsCommand(opts: FunctionsOptions): Promise<void>;

package/dist/commands/functions.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionsCommand = functionsCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const api_client_1 = require("../api-client");
+const badges_1 = require("../ui/badges");
+async function functionsCommand(opts) {
+    const result = await (0, api_client_1.listFunctions)({
+        env: opts.env,
+        language: opts.lang,
+        search: opts.search,
+    });
+    const { functions } = result;
+    if (functions.length === 0) {
+        console.log(chalk_1.default.yellow("\n  No functions found.\n"));
+        if (opts.env || opts.lang || opts.search) {
+            console.log(chalk_1.default.gray("  Try adjusting your filters.\n"));
+        }
+        return;
+    }
+    console.log("");
+    const table = new cli_table3_1.default({
+        head: [
+            chalk_1.default.cyan.bold("Name"),
+            chalk_1.default.cyan.bold("Module"),
+            chalk_1.default.cyan.bold("Language"),
+            chalk_1.default.cyan.bold("Environment"),
+            chalk_1.default.cyan.bold("Last Seen"),
+        ],
+        style: {
+            head: [],
+            border: ["gray"],
+        },
+        chars: {
+            top: "─",
+            "top-mid": "┬",
+            "top-left": "┌",
+            "top-right": "┐",
+            bottom: "─",
+            "bottom-mid": "┴",
+            "bottom-left": "└",
+            "bottom-right": "┘",
+            left: "│",
+            "left-mid": "├",
+            mid: "─",
+            "mid-mid": "┼",
+            right: "│",
+            "right-mid": "┤",
+            middle: "│",
+        },
+    });
+    for (const fn of functions) {
+        table.push([
+            chalk_1.default.white.bold(fn.function_name),
+            chalk_1.default.gray(fn.module),
+            (0, badges_1.langBadge)(fn.language),
+            (0, badges_1.envBadge)(fn.environment),
+            (0, badges_1.timeBadge)(fn.last_seen_at),
+        ]);
+    }
+    console.log(table.toString());
+    console.log(chalk_1.default.gray(`\n  Showing ${chalk_1.default.white.bold(String(functions.length))} functions`) +
+        (result.total > functions.length
+            ? chalk_1.default.gray(` of ${result.total} total`)
+            : "") +
+        "\n");
+}

package/dist/commands/infer.d.ts

@@ -0,0 +1,14 @@
+export interface InferOptions {
+    name: string;
+    env?: string;
+    module?: string;
+    requestBody?: string;
+}
+/**
+ * `trickle infer <file>` — Infer types from a JSON file or stdin and store them.
+ *
+ * Reads JSON from a file (or stdin if file is "-" or omitted with piped input),
+ * infers TypeNode from the data, and sends the observation to the trickle backend.
+ * Works offline with saved API responses, test fixtures, or piped command output.
+ */
+export declare function inferCommand(file: string | undefined, opts: InferOptions): Promise<void>;

package/dist/commands/infer.js

@@ -0,0 +1,275 @@
+"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.inferCommand = inferCommand;
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config");
+/**
+ * `trickle infer <file>` — Infer types from a JSON file or stdin and store them.
+ *
+ * Reads JSON from a file (or stdin if file is "-" or omitted with piped input),
+ * infers TypeNode from the data, and sends the observation to the trickle backend.
+ * Works offline with saved API responses, test fixtures, or piped command output.
+ */
+async function inferCommand(file, opts) {
+    const backendUrl = (0, config_1.getBackendUrl)();
+    // 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);
+    }
+    // Read JSON input
+    let jsonText;
+    let sourceName;
+    if (!file || file === "-") {
+        // Read from stdin
+        if (process.stdin.isTTY) {
+            console.error(chalk_1.default.red("\n  No input provided."));
+            console.error(chalk_1.default.gray("  Pipe JSON via stdin or provide a file path:\n"));
+            console.error(chalk_1.default.gray('  echo \'{"key":"value"}\' | trickle infer --name "GET /api/data"'));
+            console.error(chalk_1.default.gray('  trickle infer response.json --name "GET /api/data"\n'));
+            process.exit(1);
+        }
+        jsonText = await readStdin();
+        sourceName = "stdin";
+    }
+    else {
+        // Read from file
+        if (!fs.existsSync(file)) {
+            console.error(chalk_1.default.red(`\n  File not found: ${file}\n`));
+            process.exit(1);
+        }
+        jsonText = fs.readFileSync(file, "utf-8");
+        sourceName = file;
+    }
+    // Parse JSON
+    let jsonData;
+    try {
+        jsonData = JSON.parse(jsonText.trim());
+    }
+    catch {
+        console.error(chalk_1.default.red("\n  Input is not valid JSON.\n"));
+        process.exit(1);
+    }
+    // Build type observations
+    const functionName = opts.name;
+    const returnType = jsonToTypeNode(jsonData);
+    const argsProperties = {};
+    // Parse request body example if provided
+    if (opts.requestBody) {
+        try {
+            const reqJson = JSON.parse(opts.requestBody);
+            argsProperties.body = jsonToTypeNode(reqJson);
+        }
+        catch {
+            console.error(chalk_1.default.red("\n  --request-body is not valid JSON.\n"));
+            process.exit(1);
+        }
+    }
+    const argsType = Object.keys(argsProperties).length > 0
+        ? { kind: "object", properties: argsProperties }
+        : { kind: "object", properties: {} };
+    const typeHash = computeTypeHash(argsType, returnType);
+    const payload = {
+        functionName,
+        module: opts.module || "infer",
+        language: "js",
+        environment: opts.env || "development",
+        typeHash,
+        argsType,
+        returnType,
+        sampleInput: Object.keys(argsProperties).length > 0 ? argsProperties : undefined,
+        sampleOutput: jsonData,
+    };
+    // 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("");
+    console.log(chalk_1.default.bold("  trickle infer"));
+    console.log(chalk_1.default.gray("  " + "─".repeat(50)));
+    console.log(chalk_1.default.gray(`  Source:   `) + chalk_1.default.white(sourceName));
+    console.log(chalk_1.default.gray(`  Name:     `) + 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 inferred and stored successfully!"));
+    // Show a preview of the inferred shape
+    const shape = describeShape(returnType, 1);
+    console.log("");
+    console.log(chalk_1.default.gray("  Inferred shape:"));
+    for (const line of shape) {
+        console.log(chalk_1.default.gray("    ") + line);
+    }
+    if (opts.requestBody) {
+        const reqShape = describeShape(argsProperties.body, 1);
+        console.log("");
+        console.log(chalk_1.default.gray("  Request body shape:"));
+        for (const line of reqShape) {
+            console.log(chalk_1.default.gray("    ") + line);
+        }
+    }
+    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("");
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => { data += chunk; });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+        // Timeout after 10 seconds
+        setTimeout(() => {
+            if (data.length === 0) {
+                reject(new Error("No input received from stdin"));
+            }
+            else {
+                resolve(data);
+            }
+        }, 10000);
+    });
+}
+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 computeTypeHash(argsType, returnType) {
+    const data = JSON.stringify({ a: argsType, r: returnType });
+    return crypto.createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+/**
+ * Describe a TypeNode shape as human-readable lines.
+ */
+function describeShape(node, maxDepth, depth = 0) {
+    const indent = "  ".repeat(depth);
+    const lines = [];
+    if (node.kind === "primitive") {
+        lines.push(indent + chalk_1.default.cyan(node.name));
+    }
+    else if (node.kind === "array") {
+        const element = node.element;
+        if (element.kind === "object" && depth < maxDepth) {
+            lines.push(indent + chalk_1.default.yellow("Array<{"));
+            const subLines = describeShape(element, maxDepth, depth + 1);
+            lines.push(...subLines);
+            lines.push(indent + chalk_1.default.yellow("}>"));
+        }
+        else {
+            lines.push(indent + chalk_1.default.yellow(`${describeTypeCompact(element)}[]`));
+        }
+    }
+    else if (node.kind === "object") {
+        const props = node.properties;
+        const keys = Object.keys(props);
+        if (keys.length === 0) {
+            lines.push(indent + chalk_1.default.gray("{}"));
+        }
+        else {
+            for (const key of keys) {
+                const propType = props[key];
+                const typeStr = describeTypeCompact(propType);
+                lines.push(indent + chalk_1.default.white(key) + chalk_1.default.gray(": ") + chalk_1.default.cyan(typeStr));
+            }
+        }
+    }
+    else {
+        lines.push(indent + chalk_1.default.gray(node.kind));
+    }
+    return lines;
+}
+function describeTypeCompact(node) {
+    switch (node.kind) {
+        case "primitive":
+            return node.name;
+        case "array": {
+            const element = node.element;
+            return `${describeTypeCompact(element)}[]`;
+        }
+        case "object": {
+            const props = node.properties;
+            const keys = Object.keys(props);
+            if (keys.length === 0)
+                return "{}";
+            if (keys.length <= 3) {
+                const inner = keys.map((k) => `${k}: ${describeTypeCompact(props[k])}`).join(", ");
+                return `{ ${inner} }`;
+            }
+            return `{ ${keys.slice(0, 2).map((k) => `${k}: ${describeTypeCompact(props[k])}`).join(", ")}, ... }`;
+        }
+        default:
+            return node.kind;
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+export interface InitOptions {
+    dir?: string;
+    python?: boolean;
+}
+export declare function initCommand(opts: InitOptions): Promise<void>;