trickle-cli 0.1.0

package/src/commands/auto.ts

@@ -0,0 +1,268 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { fetchCodegen } from "../api-client";
+
+export interface AutoOptions {
+  dir?: string;
+  env?: string;
+}
+
+interface DetectedFormat {
+  format: string;
+  fileName: string;
+  label: string;
+  reason: string;
+}
+
+/**
+ * Detect which codegen formats are relevant based on package.json dependencies.
+ */
+function detectFormats(projectDir: string): DetectedFormat[] {
+  const pkgPath = path.join(projectDir, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    return [];
+  }
+
+  let pkg: Record<string, unknown>;
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  } catch {
+    return [];
+  }
+
+  const deps: Record<string, string> = {
+    ...(pkg.dependencies as Record<string, string> || {}),
+    ...(pkg.devDependencies as Record<string, string> || {}),
+  };
+
+  const formats: DetectedFormat[] = [];
+
+  // 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.
+ */
+export async function autoCommand(opts: AutoOptions): Promise<void> {
+  const projectDir = process.cwd();
+  const outDir = path.resolve(opts.dir || ".trickle");
+
+  // Detect formats
+  const formats = detectFormats(projectDir);
+
+  if (formats.length === 0) {
+    console.error(chalk.red("\n  No package.json found in current directory."));
+    console.error(chalk.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.bold("  trickle auto"));
+  console.log(chalk.gray("  " + "─".repeat(50)));
+  console.log(chalk.gray(`  Project: ${projectDir}`));
+  console.log(chalk.gray(`  Output:  ${outDir}`));
+  if (opts.env) {
+    console.log(chalk.gray(`  Env:     ${opts.env}`));
+  }
+  console.log(chalk.gray("  " + "─".repeat(50)));
+  console.log("");
+
+  // Show detected formats
+  console.log(chalk.gray("  Detected dependencies:"));
+  for (const f of formats) {
+    console.log(chalk.gray(`    ${chalk.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 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.yellow("  ─ ") + chalk.gray(`${f.fileName} (no data)`));
+        skipped++;
+        continue;
+      }
+
+      fs.writeFileSync(filePath, content, "utf-8");
+      generated++;
+
+      const size = content.split("\n").length;
+      console.log(
+        chalk.green("  ✓ ") +
+        chalk.bold(f.fileName) +
+        chalk.gray(` (${size} lines)`),
+      );
+    } catch {
+      console.log(chalk.yellow("  ─ ") + chalk.gray(`${f.fileName} (error)`));
+      skipped++;
+    }
+  }
+
+  console.log("");
+  if (generated > 0) {
+    console.log(
+      chalk.green(`  ${generated} files generated`) +
+      (skipped > 0 ? chalk.gray(`, ${skipped} skipped`) : ""),
+    );
+    console.log(chalk.gray(`  Output directory: ${outDir}`));
+  } else {
+    console.log(chalk.yellow("  No files generated — instrument your app and make some requests first."));
+  }
+  console.log("");
+}

package/src/commands/capture.ts

@@ -0,0 +1,257 @@
+import * as crypto from "crypto";
+import chalk from "chalk";
+import { getBackendUrl } from "../config";
+
+export interface CaptureOptions {
+  header?: string[];
+  body?: string;
+  env?: string;
+  module?: string;
+}
+
+interface TypeNode {
+  kind: string;
+  [key: string]: unknown;
+}
+
+/**
+ * `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 async function captureCommand(
+  method: string,
+  url: string,
+  opts: CaptureOptions,
+): Promise<void> {
+  const backendUrl = getBackendUrl();
+
+  // Validate method
+  const httpMethod = method.toUpperCase();
+  const validMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+  if (!validMethods.includes(httpMethod)) {
+    console.error(chalk.red(`\n  Invalid HTTP method: ${method}`));
+    console.error(chalk.gray(`  Valid methods: ${validMethods.join(", ")}\n`));
+    process.exit(1);
+  }
+
+  // Parse URL
+  let parsedUrl: URL;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    console.error(chalk.red(`\n  Invalid URL: ${url}\n`));
+    process.exit(1);
+  }
+
+  // Build request headers
+  const headers: Record<string, string> = {
+    "Accept": "application/json",
+  };
+  if (opts.header) {
+    for (const h of opts.header) {
+      const colonIdx = h.indexOf(":");
+      if (colonIdx === -1) {
+        console.error(chalk.red(`\n  Invalid header format: ${h}`));
+        console.error(chalk.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: string | undefined;
+  let reqJson: unknown = 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.red(`\n  Cannot reach trickle backend at ${chalk.bold(backendUrl)}`));
+    console.error(chalk.gray("  Start the backend first: npx trickle-backend\n"));
+    process.exit(1);
+  }
+
+  console.log("");
+  console.log(chalk.bold("  trickle capture"));
+  console.log(chalk.gray("  " + "─".repeat(50)));
+  console.log(chalk.gray(`  ${chalk.bold(httpMethod)} ${url}`));
+
+  // Make the request
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method: httpMethod,
+      headers,
+      body: reqBody,
+      signal: AbortSignal.timeout(30000),
+    });
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    console.error(chalk.red(`\n  Request failed: ${msg}\n`));
+    process.exit(1);
+  }
+
+  const status = response.status;
+  const statusColor = status < 400 ? chalk.green : chalk.red;
+  console.log(chalk.gray(`  Status:   `) + statusColor(`${status} ${response.statusText}`));
+
+  // Read response body
+  const resText = await response.text();
+  let resJson: unknown = undefined;
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("json") && resText.length > 0) {
+    try {
+      resJson = JSON.parse(resText);
+    } catch {
+      console.error(chalk.yellow("\n  Response is not valid JSON — cannot capture types.\n"));
+      process.exit(1);
+    }
+  } else {
+    console.error(chalk.yellow("\n  Response is not JSON — cannot capture types."));
+    console.error(chalk.gray(`  Content-Type: ${contentType}\n`));
+    process.exit(1);
+  }
+
+  // Build type observations
+  const routePath = normalizePath(parsedUrl.pathname);
+  const functionName = `${httpMethod} ${routePath}`;
+
+  const argsProperties: Record<string, TypeNode> = {};
+  if (reqJson !== undefined && reqJson !== null) {
+    argsProperties.body = jsonToTypeNode(reqJson);
+  }
+
+  // Extract query params
+  if (parsedUrl.search) {
+    const queryProps: Record<string, TypeNode> = {};
+    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: TypeNode = 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: unknown) {
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    console.error(chalk.red(`\n  Failed to send types to backend: ${msg}\n`));
+    process.exit(1);
+  }
+
+  console.log(chalk.gray(`  Route:    `) + chalk.white(functionName));
+  console.log(chalk.gray(`  Backend:  `) + chalk.white(backendUrl));
+  console.log(chalk.gray("  " + "─".repeat(50)));
+  console.log(chalk.green("  Types captured successfully!"));
+
+  // Show a preview of what was captured
+  const fieldCount = countFields(returnType);
+  console.log(chalk.gray(`  Response shape: ${fieldCount} fields observed`));
+  if (reqJson) {
+    const reqFieldCount = countFields(argsProperties.body || { kind: "object", properties: {} });
+    console.log(chalk.gray(`  Request body:   ${reqFieldCount} fields observed`));
+  }
+  console.log("");
+  console.log(chalk.gray("  Run ") + chalk.white(`trickle codegen`) + chalk.gray(" to generate type definitions."));
+  console.log("");
+}
+
+/**
+ * Infer a TypeNode from a JSON value.
+ */
+function jsonToTypeNode(value: unknown): TypeNode {
+  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 as Record<string, unknown>;
+  const properties: Record<string, TypeNode> = {};
+  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: string): string {
+  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: TypeNode, returnType: TypeNode): string {
+  const data = JSON.stringify({ a: argsType, r: returnType });
+  return crypto.createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+
+function countFields(node: TypeNode): number {
+  if (node.kind === "object" && node.properties) {
+    return Object.keys(node.properties as Record<string, unknown>).length;
+  }
+  if (node.kind === "array") return 1;
+  return 1;
+}