@tsproxy/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,676 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { writeFileSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import { resolve } from "path";
+async function init() {
+  p.intro(pc.bgCyan(pc.black(" tsproxy init ")));
+  const scope = await p.select({
+    message: "What do you want to set up?",
+    options: [
+      { value: "both", label: "Backend + Frontend", hint: "proxy server and search UI" },
+      { value: "backend", label: "Backend only", hint: "proxy server" },
+      { value: "frontend", label: "Frontend only", hint: "search client and components" }
+    ]
+  });
+  if (p.isCancel(scope)) return process.exit(0);
+  const needsBackend = scope === "both" || scope === "backend";
+  const needsFrontend = scope === "both" || scope === "frontend";
+  let typesenseMode = "docker";
+  let tsHost = "localhost";
+  let tsPort = "8108";
+  let tsApiKey = "test-api-key";
+  let tsProtocol = "http";
+  let wantsRedis = false;
+  let redisHost = "localhost";
+  let redisPort = "6379";
+  if (needsBackend) {
+    typesenseMode = await p.select({
+      message: "How will you run Typesense?",
+      options: [
+        { value: "docker", label: "Docker (local)", hint: "generates docker-compose.yml" },
+        { value: "cloud", label: "Typesense Cloud" },
+        { value: "self-hosted", label: "Self-hosted" }
+      ]
+    });
+    if (p.isCancel(typesenseMode)) return process.exit(0);
+    if (typesenseMode === "cloud" || typesenseMode === "self-hosted") {
+      const hostInput = await p.text({
+        message: "Typesense host",
+        placeholder: typesenseMode === "cloud" ? "xyz.a1.typesense.net" : "localhost",
+        validate: (v) => v.length === 0 ? "Host is required" : void 0
+      });
+      if (p.isCancel(hostInput)) return process.exit(0);
+      tsHost = hostInput;
+      const portInput = await p.text({
+        message: "Typesense port",
+        initialValue: typesenseMode === "cloud" ? "443" : "8108"
+      });
+      if (p.isCancel(portInput)) return process.exit(0);
+      tsPort = portInput;
+      if (typesenseMode === "cloud") {
+        tsProtocol = "https";
+      }
+      const keyInput = await p.text({
+        message: "Typesense API key",
+        validate: (v) => v.length === 0 ? "API key is required" : void 0
+      });
+      if (p.isCancel(keyInput)) return process.exit(0);
+      tsApiKey = keyInput;
+    }
+    const redisChoice = await p.confirm({
+      message: "Use Redis for persistent queue?",
+      initialValue: typesenseMode === "docker"
+    });
+    if (p.isCancel(redisChoice)) return process.exit(0);
+    wantsRedis = redisChoice;
+    if (wantsRedis && typesenseMode !== "docker") {
+      const rHost = await p.text({
+        message: "Redis host",
+        initialValue: "localhost"
+      });
+      if (p.isCancel(rHost)) return process.exit(0);
+      redisHost = rHost;
+      const rPort = await p.text({
+        message: "Redis port",
+        initialValue: "6379"
+      });
+      if (p.isCancel(rPort)) return process.exit(0);
+      redisPort = rPort;
+    }
+  }
+  let frontendType = "react";
+  if (needsFrontend) {
+    frontendType = await p.select({
+      message: "Frontend framework?",
+      options: [
+        { value: "react", label: "React", hint: "headless components + InstantSearch" },
+        { value: "vanilla", label: "Vanilla JS", hint: "search client only" }
+      ]
+    });
+    if (p.isCancel(frontendType)) return process.exit(0);
+  }
+  const s = p.spinner();
+  s.start("Generating files");
+  const cwd = process.cwd();
+  if (needsBackend) {
+    const configContent = generateConfig({
+      tsHost,
+      tsPort,
+      tsProtocol,
+      tsApiKey,
+      wantsRedis,
+      redisHost,
+      redisPort,
+      isDocker: typesenseMode === "docker"
+    });
+    writeFileSync(resolve(cwd, "tsproxy.config.ts"), configContent);
+  }
+  if (typesenseMode === "docker") {
+    const dockerContent = generateDockerCompose(wantsRedis);
+    if (!existsSync(resolve(cwd, "docker-compose.yml"))) {
+      writeFileSync(resolve(cwd, "docker-compose.yml"), dockerContent);
+    } else {
+      p.log.warn("docker-compose.yml already exists, skipping");
+    }
+  }
+  const envContent = generateEnv({
+    tsHost,
+    tsPort,
+    tsProtocol,
+    tsApiKey,
+    isDocker: typesenseMode === "docker",
+    wantsRedis,
+    redisHost,
+    redisPort
+  });
+  if (!existsSync(resolve(cwd, ".env"))) {
+    writeFileSync(resolve(cwd, ".env"), envContent);
+  }
+  s.stop("Files generated");
+  const deps = [];
+  if (needsBackend) deps.push("@tsproxy/api");
+  if (needsFrontend) {
+    deps.push("@tsproxy/js");
+    if (frontendType === "react") {
+      deps.push("@tsproxy/react", "react-instantsearch");
+    }
+  }
+  if (deps.length > 0) {
+    const pm = detectPackageManager();
+    s.start(`Installing ${deps.join(", ")}`);
+    try {
+      const installCmd = pm === "pnpm" ? `pnpm add ${deps.join(" ")}` : pm === "yarn" ? `yarn add ${deps.join(" ")}` : pm === "bun" ? `bun add ${deps.join(" ")}` : `npm install ${deps.join(" ")}`;
+      execSync(installCmd, { stdio: "pipe", cwd });
+      s.stop("Dependencies installed");
+    } catch {
+      s.stop("Failed to install \u2014 run manually:");
+      p.log.info(`  ${pm} add ${deps.join(" ")}`);
+    }
+  }
+  p.note(
+    [
+      typesenseMode === "docker" && "docker compose up -d",
+      needsBackend && "npx tsproxy dev",
+      needsFrontend && "# Import in your app:",
+      needsFrontend && frontendType === "react" ? '  import { SearchBox, Hits } from "@tsproxy/react"' : needsFrontend ? '  import { createSearchClient } from "@tsproxy/js"' : null
+    ].filter(Boolean).join("\n"),
+    "Next steps"
+  );
+  p.outro(pc.green("Ready!"));
+}
+function generateConfig(opts) {
+  const redis = opts.wantsRedis ? `
+    redis: { host: "${opts.isDocker ? "localhost" : opts.redisHost}", port: ${opts.isDocker ? 6379 : opts.redisPort} },` : "";
+  return `import { defineConfig } from "@tsproxy/api";
+
+export default defineConfig({
+  typesense: {
+    host: "${opts.isDocker ? "localhost" : opts.tsHost}",
+    port: ${opts.isDocker ? 8108 : opts.tsPort},
+    protocol: "${opts.tsProtocol}",
+    apiKey: process.env.TYPESENSE_API_KEY || "${opts.tsApiKey}",
+  },
+
+  server: {
+    port: 3000,
+    apiKey: process.env.PROXY_API_KEY || "change-me",
+  },
+
+  cache: {
+    ttl: 60,
+    maxSize: 1000,
+  },
+
+  queue: {
+    concurrency: 5,
+    maxSize: 10000,${redis}
+  },
+
+  rateLimit: {
+    search: 100,
+    ingest: 30,
+  },
+
+  collections: {
+    // Define your collections here:
+    // products: {
+    //   fields: {
+    //     name: { type: "string", searchable: true },
+    //     price: { type: "float", sortable: true },
+    //     category: { type: "string", facet: true },
+    //   },
+    // },
+  },
+});
+`;
+}
+function generateDockerCompose(wantsRedis) {
+  let content = `services:
+  typesense:
+    image: typesense/typesense:30.0
+    restart: unless-stopped
+    ports:
+      - "8108:8108"
+    volumes:
+      - typesense-data:/data
+    command: >
+      --data-dir /data
+      --api-key=\${TYPESENSE_API_KEY:-test-api-key}
+      --enable-cors
+    healthcheck:
+      test: ["CMD", "curl", "-sf", "http://localhost:8108/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+`;
+  if (wantsRedis) {
+    content += `
+  redis:
+    image: redis:7-alpine
+    restart: unless-stopped
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    command: redis-server --appendonly yes
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+`;
+  }
+  content += `
+volumes:
+  typesense-data:`;
+  if (wantsRedis) {
+    content += `
+  redis-data:`;
+  }
+  return content + "\n";
+}
+function generateEnv(opts) {
+  let content = `# Typesense
+TYPESENSE_HOST=${opts.isDocker ? "localhost" : opts.tsHost}
+TYPESENSE_PORT=${opts.isDocker ? "8108" : opts.tsPort}
+TYPESENSE_PROTOCOL=${opts.tsProtocol}
+TYPESENSE_API_KEY=${opts.tsApiKey}
+
+# Proxy
+PROXY_PORT=3000
+PROXY_API_KEY=change-me
+`;
+  if (opts.wantsRedis) {
+    content += `
+# Redis
+REDIS_HOST=${opts.isDocker ? "localhost" : opts.redisHost}
+REDIS_PORT=${opts.isDocker ? "6379" : opts.redisPort}
+`;
+  }
+  return content;
+}
+function detectPackageManager() {
+  const cwd = process.cwd();
+  if (existsSync(resolve(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(resolve(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync(resolve(cwd, "bun.lockb"))) return "bun";
+  return "npm";
+}
+
+// src/commands/dev.ts
+import { execSync as execSync2 } from "child_process";
+import { resolve as resolve2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+async function dev(opts) {
+  const args = ["dev"];
+  if (opts.port) args.push("--port", opts.port);
+  if (opts.config) args.push("--config", opts.config);
+  const hasTsx = existsSync2(resolve2(process.cwd(), "node_modules/.bin/tsx"));
+  const cliPath = findCliEntry();
+  if (!cliPath) {
+    console.error("@tsproxy/api not found. Run: npm install @tsproxy/api");
+    process.exit(1);
+  }
+  const cmd = hasTsx ? `npx tsx watch ${cliPath} ${args.join(" ")}` : `node ${cliPath} ${args.join(" ")}`;
+  try {
+    execSync2(cmd, { stdio: "inherit", cwd: process.cwd() });
+  } catch {
+    process.exit(1);
+  }
+}
+function findCliEntry() {
+  const paths = [
+    resolve2(process.cwd(), "node_modules/@tsproxy/api/dist/cli.js"),
+    resolve2(process.cwd(), "node_modules/@tsproxy/api/src/cli.ts")
+  ];
+  for (const p2 of paths) {
+    if (existsSync2(p2)) return p2;
+  }
+  return null;
+}
+
+// src/commands/start.ts
+import { execSync as execSync3 } from "child_process";
+import { resolve as resolve3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+async function start(opts) {
+  const cliPath = resolve3(process.cwd(), "node_modules/@tsproxy/api/dist/cli.js");
+  if (!existsSync3(cliPath)) {
+    console.error("@tsproxy/api not found or not built. Run: npm install @tsproxy/api");
+    process.exit(1);
+  }
+  const args = ["start"];
+  if (opts.port) args.push("--port", opts.port);
+  if (opts.config) args.push("--config", opts.config);
+  try {
+    execSync3(`node ${cliPath} ${args.join(" ")}`, {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+  } catch {
+    process.exit(1);
+  }
+}
+
+// src/commands/build.ts
+import { execSync as execSync4 } from "child_process";
+async function build() {
+  console.log("Building @tsproxy/api for production...");
+  try {
+    execSync4("npx tsup node_modules/@tsproxy/api/src/index.ts node_modules/@tsproxy/api/src/server.ts node_modules/@tsproxy/api/src/cli.ts --format esm --outDir dist", {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+    console.log("Build complete. Start with: tsproxy start");
+  } catch {
+    console.error("Build failed.");
+    process.exit(1);
+  }
+}
+
+// src/commands/seed.ts
+import { readFileSync } from "fs";
+import { resolve as resolve4 } from "path";
+import pc2 from "picocolors";
+async function seed(file, opts) {
+  const proxyUrl = process.env.PROXY_URL || "http://localhost:3000";
+  const apiKey = process.env.PROXY_API_KEY || "change-me";
+  const collection = opts.collection || "products";
+  if (!file) {
+    console.error("Usage: tsproxy seed <file.json> --collection <name>");
+    console.error("  File should be a JSON array of documents.");
+    process.exit(1);
+  }
+  const filePath = resolve4(process.cwd(), file);
+  let documents;
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    if (content.trim().startsWith("[")) {
+      documents = JSON.parse(content);
+    } else {
+      documents = content.trim().split("\n").map((line) => JSON.parse(line));
+    }
+  } catch (err) {
+    console.error(`Failed to read ${filePath}:`, err.message);
+    process.exit(1);
+  }
+  console.log(
+    `Seeding ${pc2.bold(String(documents.length))} documents into ${pc2.bold(collection)} via ingest API...`
+  );
+  const url = `${proxyUrl}/api/ingest/${collection}/documents/import`;
+  const headers = {
+    "Content-Type": "application/json",
+    "X-API-Key": apiKey
+  };
+  if (opts.locale) {
+    headers["X-Locale"] = opts.locale;
+  }
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(documents)
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(
+        pc2.red(`Failed: ${res.status} ${body.error || res.statusText}`)
+      );
+      process.exit(1);
+    }
+    const result = await res.json();
+    const results = Array.isArray(result) ? result : [result];
+    const successes = results.filter((r) => r.success !== false).length;
+    const failures = results.length - successes;
+    console.log(
+      pc2.green(`Imported ${successes} documents`) + (failures > 0 ? pc2.red(` (${failures} failures)`) : "")
+    );
+    if (opts.locales) {
+      console.log("\nTo seed locale-specific collections, run:");
+      console.log(
+        `  tsproxy seed ${file} --collection ${collection} --locale en`
+      );
+      console.log(
+        `  tsproxy seed ${file} --collection ${collection} --locale fr`
+      );
+    }
+  } catch (err) {
+    console.error(pc2.red("Connection failed:"), err.message);
+    console.error("Is the proxy running? Start with: tsproxy dev");
+    process.exit(1);
+  }
+}
+
+// src/commands/migrate.ts
+import { resolve as resolve5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { pathToFileURL } from "url";
+import pc3 from "picocolors";
+async function migrate(opts) {
+  const configPath = findConfig();
+  if (!configPath) {
+    console.error("No tsproxy.config.ts found. Run: tsproxy init");
+    process.exit(1);
+  }
+  let config;
+  try {
+    const mod = await import(pathToFileURL(configPath).href);
+    config = mod.default || mod;
+  } catch (err) {
+    console.error("Failed to load config:", err.message);
+    process.exit(1);
+  }
+  const collections = config.collections || {};
+  const collectionNames = Object.keys(collections);
+  if (collectionNames.length === 0) {
+    console.log("No collections defined in config.");
+    return;
+  }
+  const tsHost = config.typesense?.host || process.env.TYPESENSE_HOST || "localhost";
+  const tsPort = config.typesense?.port || process.env.TYPESENSE_PORT || 8108;
+  const tsProtocol = config.typesense?.protocol || "http";
+  const tsApiKey = config.typesense?.apiKey || process.env.TYPESENSE_API_KEY;
+  if (!tsApiKey) {
+    console.error("TYPESENSE_API_KEY not set.");
+    process.exit(1);
+  }
+  const baseUrl = `${tsProtocol}://${tsHost}:${tsPort}`;
+  let existing = {};
+  try {
+    const res = await fetch(`${baseUrl}/collections`, {
+      headers: { "X-TYPESENSE-API-KEY": tsApiKey }
+    });
+    const cols = await res.json();
+    for (const col of cols) {
+      existing[col.name] = col;
+    }
+  } catch (err) {
+    console.error("Cannot connect to Typesense:", err.message);
+    process.exit(1);
+  }
+  console.log(pc3.bold("\nMigration plan:\n"));
+  const actions = [];
+  for (const [name, def] of Object.entries(collections)) {
+    const names = [name];
+    if (def.locales?.length) {
+      for (const locale of def.locales) {
+        names.push(`${name}_${locale}`);
+      }
+    }
+    for (const colName of names) {
+      if (existing[colName]) {
+        if (opts.drop) {
+          actions.push({
+            type: "drop+create",
+            name: colName,
+            details: `Drop and recreate with ${Object.keys(def.fields || {}).length} fields`
+          });
+        } else {
+          const existingFields = new Set(
+            (existing[colName].fields || []).map((f) => f.name)
+          );
+          const configFields = Object.keys(def.fields || {}).filter(
+            (f) => !def.fields[f].compute
+          );
+          const newFields = configFields.filter((f) => !existingFields.has(f));
+          if (newFields.length > 0) {
+            actions.push({
+              type: "update",
+              name: colName,
+              details: `Add fields: ${newFields.join(", ")}`
+            });
+          } else {
+            actions.push({
+              type: "ok",
+              name: colName,
+              details: "Up to date"
+            });
+          }
+        }
+      } else {
+        actions.push({
+          type: "create",
+          name: colName,
+          details: `Create with ${Object.keys(def.fields || {}).length} fields`
+        });
+      }
+    }
+  }
+  for (const action of actions) {
+    const icon = action.type === "ok" ? pc3.green("\u2713") : action.type === "create" ? pc3.cyan("+") : action.type === "update" ? pc3.yellow("~") : pc3.red("!");
+    console.log(`  ${icon} ${pc3.bold(action.name)} \u2014 ${action.details}`);
+  }
+  const pendingActions = actions.filter((a) => a.type !== "ok");
+  if (pendingActions.length === 0) {
+    console.log(pc3.green("\nAll collections are up to date."));
+    return;
+  }
+  if (!opts.apply) {
+    console.log(
+      pc3.yellow(`
+Dry run \u2014 ${pendingActions.length} change(s). Run with --apply to execute.`)
+    );
+    return;
+  }
+  console.log(pc3.bold("\nApplying...\n"));
+  for (const action of pendingActions) {
+    const colName = action.name;
+    const baseName = colName.includes("_") ? colName.split("_").slice(0, -1).join("_") : colName;
+    const def = collections[baseName] || collections[colName];
+    if (!def) continue;
+    const schema = buildSchema(colName, def);
+    try {
+      if (action.type === "drop+create") {
+        await fetch(`${baseUrl}/collections/${colName}`, {
+          method: "DELETE",
+          headers: { "X-TYPESENSE-API-KEY": tsApiKey }
+        });
+        await fetch(`${baseUrl}/collections`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-TYPESENSE-API-KEY": tsApiKey
+          },
+          body: JSON.stringify(schema)
+        });
+        console.log(`  ${pc3.green("\u2713")} ${colName} \u2014 dropped and recreated`);
+      } else if (action.type === "create") {
+        await fetch(`${baseUrl}/collections`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-TYPESENSE-API-KEY": tsApiKey
+          },
+          body: JSON.stringify(schema)
+        });
+        console.log(`  ${pc3.green("\u2713")} ${colName} \u2014 created`);
+      } else if (action.type === "update") {
+        const existingFields = new Set(
+          (existing[colName].fields || []).map((f) => f.name)
+        );
+        const newFields = Object.entries(def.fields || {}).filter(([name, f]) => !existingFields.has(name) && !f.compute).map(([name, f]) => ({
+          name,
+          type: f.type,
+          ...f.facet ? { facet: true } : {},
+          ...f.optional ? { optional: true } : {}
+        }));
+        await fetch(`${baseUrl}/collections/${colName}`, {
+          method: "PATCH",
+          headers: {
+            "Content-Type": "application/json",
+            "X-TYPESENSE-API-KEY": tsApiKey
+          },
+          body: JSON.stringify({ fields: newFields })
+        });
+        console.log(`  ${pc3.green("\u2713")} ${colName} \u2014 updated`);
+      }
+    } catch (err) {
+      console.error(
+        `  ${pc3.red("\u2717")} ${colName} \u2014 ${err.message}`
+      );
+    }
+  }
+  console.log(pc3.green("\nMigration complete."));
+}
+function buildSchema(name, def) {
+  const fields = Object.entries(def.fields || {}).filter(([, f]) => !f.compute).map(([fieldName, f]) => ({
+    name: fieldName,
+    type: f.type,
+    ...f.facet ? { facet: true } : {},
+    ...f.optional ? { optional: true } : {},
+    ...f.sortable && !["int32", "int64", "float", "bool"].includes(f.type) ? { sort: true } : {},
+    ...f.infix ? { infix: true } : {}
+  }));
+  return {
+    name,
+    fields,
+    ...def.defaultSortBy ? { default_sorting_field: def.defaultSortBy } : {}
+  };
+}
+function findConfig() {
+  const names = ["tsproxy.config.ts", "tsproxy.config.js", "tsproxy.config.mjs"];
+  let dir = process.cwd();
+  const root = resolve5("/");
+  while (dir !== root) {
+    for (const name of names) {
+      const p2 = resolve5(dir, name);
+      if (existsSync4(p2)) return p2;
+    }
+    dir = resolve5(dir, "..");
+  }
+  return null;
+}
+
+// src/commands/health.ts
+import pc4 from "picocolors";
+async function health() {
+  const proxyUrl = process.env.PROXY_URL || "http://localhost:3000";
+  console.log(pc4.bold("\nHealth check\n"));
+  try {
+    const res = await fetch(`${proxyUrl}/api/health`);
+    const data = await res.json();
+    const proxyOk = data.proxy?.status === "ok";
+    const tsOk = data.typesense?.status === "ok";
+    const redisStatus = data.redis?.status;
+    const redisOk = redisStatus === "ok" || redisStatus === "not_configured";
+    console.log(
+      `  ${proxyOk ? pc4.green("\u2713") : pc4.red("\u2717")} Proxy        ${proxyOk ? "ok" : "error"}`
+    );
+    console.log(
+      `  ${tsOk ? pc4.green("\u2713") : pc4.red("\u2717")} Typesense    ${tsOk ? "ok" : data.typesense?.error || "error"} ${pc4.dim(data.typesense?.host || "")}`
+    );
+    console.log(
+      `  ${redisStatus === "ok" ? pc4.green("\u2713") : redisStatus === "not_configured" ? pc4.dim("-") : pc4.red("\u2717")} Redis        ${redisStatus} ${pc4.dim(data.redis?.host || "")}`
+    );
+    console.log(
+      `
+  Status: ${data.status === "healthy" ? pc4.green("healthy") : pc4.red("degraded")}`
+    );
+  } catch (err) {
+    console.error(
+      `  ${pc4.red("\u2717")} Cannot connect to proxy at ${proxyUrl}`
+    );
+    console.error(`    ${err.message}`);
+    console.error("\n  Is the proxy running? Start with: tsproxy dev");
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("tsproxy").description("Typesense search proxy framework").version("0.1.0");
+program.command("init").description("Initialize a new tsproxy project").action(init);
+program.command("dev").description("Start the proxy in development mode").option("-p, --port <port>", "Port to listen on").option("-c, --config <path>", "Path to config file").action(dev);
+program.command("start").description("Start the proxy in production mode").option("-p, --port <port>", "Port to listen on").option("-c, --config <path>", "Path to config file").action(start);
+program.command("build").description("Build the proxy for production").action(build);
+program.command("seed [file]").description("Seed Typesense with data from a JSON/JSONL file").option("--collection <name>", "Collection name").option("--locale <locale>", "Locale for the collection").option("--locales", "Create locale-specific collections").action(seed);
+program.command("migrate").description("Sync Typesense schema with config").option("--apply", "Apply changes (default is dry-run)").option("--drop", "Drop and recreate collections").action(migrate);
+program.command("health").description("Check Typesense and Redis connectivity").action(health);
+program.parse();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@tsproxy/cli",
+  "version": "0.0.1",
+  "description": "CLI for tsproxy — Typesense search proxy framework",
+  "type": "module",
+  "bin": {
+    "tsproxy": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akshitkrnagpal/tsproxy.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "keywords": [
+    "typesense",
+    "search",
+    "proxy",
+    "cli"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "commander": "^13.1.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --target node22",
+    "dev": "tsx src/index.ts"
+  }
+}