@caliber-ai/cli 0.1.0

package/dist/bin.js

@@ -0,0 +1,1395 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  API_URL: () => API_URL,
+  AUTH_DIR: () => AUTH_DIR,
+  AUTH_FILE: () => AUTH_FILE,
+  BACKUPS_DIR: () => BACKUPS_DIR,
+  CALIBER_DIR: () => CALIBER_DIR,
+  CLI_CALLBACK_PORT: () => CLI_CALLBACK_PORT,
+  FRONTEND_URL: () => FRONTEND_URL,
+  MANIFEST_FILE: () => MANIFEST_FILE
+});
+import path from "path";
+import os from "os";
+var API_URL, FRONTEND_URL, CLI_CALLBACK_PORT, AUTH_DIR, AUTH_FILE, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    API_URL = process.env.CALIBER_API_URL || "https://caliber-backend.up.railway.app";
+    FRONTEND_URL = process.env.CALIBER_FRONTEND_URL || "https://caliber-app.up.railway.app";
+    CLI_CALLBACK_PORT = 19284;
+    AUTH_DIR = path.join(os.homedir(), ".caliber");
+    AUTH_FILE = path.join(AUTH_DIR, "auth.json");
+    CALIBER_DIR = ".caliber";
+    MANIFEST_FILE = path.join(CALIBER_DIR, "manifest.json");
+    BACKUPS_DIR = path.join(CALIBER_DIR, "backups");
+  }
+});
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+import readline from "readline";
+import path10 from "path";
+
+// src/auth/token-store.ts
+init_constants();
+import fs from "fs";
+function getStoredAuth() {
+  try {
+    if (!fs.existsSync(AUTH_FILE)) return null;
+    const data = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+    return data;
+  } catch {
+    return null;
+  }
+}
+function storeAuth(auth2) {
+  if (!fs.existsSync(AUTH_DIR)) {
+    fs.mkdirSync(AUTH_DIR, { recursive: true });
+  }
+  const data = {
+    accessToken: auth2.accessToken,
+    refreshToken: auth2.refreshToken,
+    expiresAt: Date.now() + auth2.expiresIn * 1e3,
+    userId: auth2.user.id,
+    email: auth2.user.email
+  };
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function clearAuth() {
+  try {
+    if (fs.existsSync(AUTH_FILE)) fs.unlinkSync(AUTH_FILE);
+  } catch {
+  }
+}
+function isTokenExpired() {
+  const auth2 = getStoredAuth();
+  if (!auth2) return true;
+  return Date.now() >= auth2.expiresAt - 6e4;
+}
+
+// src/commands/login.ts
+import open from "open";
+import ora from "ora";
+import chalk from "chalk";
+
+// src/auth/pkce.ts
+import crypto from "crypto";
+function generatePKCE() {
+  const verifier = crypto.randomBytes(32).toString("base64url");
+  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url");
+  const state = crypto.randomBytes(16).toString("hex");
+  return { verifier, challenge, state };
+}
+
+// src/auth/callback-server.ts
+init_constants();
+import http from "http";
+import { URL as URL2 } from "url";
+function startCallbackServer(expectedState) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      if (!req.url?.startsWith("/callback")) {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const url = new URL2(req.url, `http://127.0.0.1:${CLI_CALLBACK_PORT}`);
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end("<html><body><h2>Authentication failed</h2><p>You can close this tab.</p></body></html>");
+        server.close();
+        reject(new Error(`Auth failed: ${error}`));
+        return;
+      }
+      const state = url.searchParams.get("state");
+      const accessToken = url.searchParams.get("access_token");
+      const refreshToken = url.searchParams.get("refresh_token");
+      const expiresIn = url.searchParams.get("expires_in");
+      const userId = url.searchParams.get("user_id");
+      const email = url.searchParams.get("email");
+      if (!accessToken || !refreshToken || !userId || state !== expectedState) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h2>Invalid callback</h2></body></html>");
+        server.close();
+        reject(new Error("Invalid callback: missing token data or state mismatch"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(`<html><body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #09090b; color: #fafafa;">
+        <div style="text-align: center;">
+          <h2 style="color: #6366f1;">Authentication successful!</h2>
+          <p>You can close this tab and return to your terminal.</p>
+        </div>
+      </body></html>`);
+      server.close();
+      resolve({
+        accessToken,
+        refreshToken,
+        expiresIn: parseInt(expiresIn || "3600", 10),
+        user: { id: userId, email: email || "" }
+      });
+    });
+    server.listen(CLI_CALLBACK_PORT, "127.0.0.1", () => {
+    });
+    server.on("error", (err) => {
+      reject(new Error(`Failed to start callback server: ${err.message}`));
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timed out"));
+    }, 5 * 60 * 1e3);
+  });
+}
+
+// src/commands/login.ts
+init_constants();
+
+// src/telemetry.ts
+init_constants();
+import { PostHog } from "posthog-node";
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+import { randomUUID } from "crypto";
+var POSTHOG_API_KEY = process.env.CALIBER_POSTHOG_KEY || "phc_XXrV0pSX4s2QVxVoOaeuyXDvtlRwPAjovt1ttMGVMPp";
+var DEVICE_ID_FILE = path2.join(AUTH_DIR, "device-id");
+var client = null;
+function getClient() {
+  if (!client) {
+    client = new PostHog(POSTHOG_API_KEY, { flushAt: 1, flushInterval: 0 });
+  }
+  return client;
+}
+function getDeviceId() {
+  try {
+    if (fs2.existsSync(DEVICE_ID_FILE)) {
+      return fs2.readFileSync(DEVICE_ID_FILE, "utf-8").trim();
+    }
+  } catch {
+  }
+  const id = randomUUID();
+  try {
+    if (!fs2.existsSync(AUTH_DIR)) {
+      fs2.mkdirSync(AUTH_DIR, { recursive: true });
+    }
+    fs2.writeFileSync(DEVICE_ID_FILE, id, { mode: 384 });
+  } catch {
+  }
+  return id;
+}
+function isFirstRun() {
+  return !fs2.existsSync(DEVICE_ID_FILE);
+}
+function getDistinctId() {
+  const auth2 = getStoredAuth();
+  return auth2?.userId || getDeviceId();
+}
+var pkg = JSON.parse(
+  fs2.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+);
+function baseProperties() {
+  return {
+    source: "cli",
+    cli_version: pkg.version,
+    os: os2.platform()
+  };
+}
+function trackEvent(event, properties = {}) {
+  try {
+    getClient().capture({
+      distinctId: getDistinctId(),
+      event,
+      properties: { ...baseProperties(), ...properties }
+    });
+  } catch {
+  }
+}
+function identifyUser(userId, email) {
+  try {
+    const ph = getClient();
+    const deviceId = getDeviceId();
+    ph.identify({ distinctId: userId, properties: { email, source: "cli" } });
+    if (deviceId !== userId) {
+      ph.alias({ distinctId: userId, alias: deviceId });
+    }
+  } catch {
+  }
+}
+function countSuggestedFiles(setup) {
+  let count = 0;
+  const claude = setup.claude;
+  const cursor = setup.cursor;
+  if (claude) {
+    if (claude.claudeMd) count++;
+    if (claude.settings) count++;
+    if (claude.settingsLocal) count++;
+    if (Array.isArray(claude.skills)) count += claude.skills.length;
+    if (claude.mcpServers && Object.keys(claude.mcpServers).length > 0) count++;
+  }
+  if (cursor) {
+    if (cursor.cursorrules) count++;
+    if (Array.isArray(cursor.rules)) count += cursor.rules.length;
+    if (cursor.mcpServers && Object.keys(cursor.mcpServers).length > 0) count++;
+  }
+  return count;
+}
+async function shutdownTelemetry() {
+  try {
+    await Promise.race([
+      client?.shutdown(),
+      new Promise((resolve) => setTimeout(resolve, 2e3))
+    ]);
+  } catch {
+  }
+}
+
+// src/commands/login.ts
+async function loginCommand() {
+  const existing = getStoredAuth();
+  if (existing) {
+    console.log(chalk.dim(`Already logged in as ${existing.email}`));
+    console.log(chalk.dim("Run `caliber logout` first to switch accounts."));
+    return;
+  }
+  const { state } = generatePKCE();
+  const redirectUri = `http://127.0.0.1:${CLI_CALLBACK_PORT}/callback`;
+  const authUrl = `${FRONTEND_URL}/auth/cli?redirect_uri=${encodeURIComponent(redirectUri)}&state=${state}`;
+  console.log(chalk.bold("\nOpening browser for authentication...\n"));
+  console.log(chalk.dim(`If the browser doesn't open, visit:
+${authUrl}
+`));
+  const serverPromise = startCallbackServer(state);
+  await open(authUrl);
+  const spinner = ora("Waiting for authentication...").start();
+  try {
+    const result = await serverPromise;
+    storeAuth({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken,
+      expiresIn: result.expiresIn,
+      user: result.user
+    });
+    identifyUser(result.user.id, result.user.email);
+    trackEvent("signin", { method: "cli_pkce" });
+    spinner.succeed(chalk.green(`Logged in as ${result.user.email}`));
+  } catch (err) {
+    spinner.fail(chalk.red(`Authentication failed: ${err instanceof Error ? err.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+
+// src/fingerprint/index.ts
+import crypto2 from "crypto";
+
+// src/fingerprint/git.ts
+import { execSync } from "child_process";
+function getGitRemoteUrl() {
+  try {
+    return execSync("git remote get-url origin", { encoding: "utf-8" }).trim();
+  } catch {
+    return void 0;
+  }
+}
+
+// src/fingerprint/package-json.ts
+import fs3 from "fs";
+import path3 from "path";
+import { globSync } from "glob";
+var NODE_FRAMEWORK_DEPS = {
+  react: "React",
+  next: "Next.js",
+  vue: "Vue",
+  nuxt: "Nuxt",
+  svelte: "Svelte",
+  "@sveltejs/kit": "SvelteKit",
+  angular: "Angular",
+  "@angular/core": "Angular",
+  express: "Express",
+  fastify: "Fastify",
+  hono: "Hono",
+  nestjs: "NestJS",
+  "@nestjs/core": "NestJS",
+  tailwindcss: "Tailwind CSS",
+  prisma: "Prisma",
+  drizzle: "Drizzle",
+  "drizzle-orm": "Drizzle",
+  "@supabase/supabase-js": "Supabase",
+  mongoose: "MongoDB",
+  typeorm: "TypeORM",
+  sequelize: "Sequelize",
+  "better-auth": "Better Auth"
+};
+var PYTHON_FRAMEWORK_DEPS = {
+  fastapi: "FastAPI",
+  django: "Django",
+  flask: "Flask",
+  sqlalchemy: "SQLAlchemy",
+  pydantic: "Pydantic",
+  celery: "Celery",
+  pytest: "pytest",
+  uvicorn: "Uvicorn",
+  starlette: "Starlette",
+  httpx: "HTTPX",
+  alembic: "Alembic",
+  tortoise: "Tortoise ORM",
+  "google-cloud-pubsub": "Google Pub/Sub",
+  stripe: "Stripe",
+  redis: "Redis"
+};
+var WORKSPACE_GLOBS = [
+  "apps/*/package.json",
+  "packages/*/package.json",
+  "services/*/package.json",
+  "libs/*/package.json"
+];
+function detectNodeFrameworks(pkgPath) {
+  try {
+    const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const allDeps = { ...pkg2.dependencies, ...pkg2.devDependencies };
+    const frameworks = [];
+    for (const [dep, framework] of Object.entries(NODE_FRAMEWORK_DEPS)) {
+      if (allDeps[dep]) frameworks.push(framework);
+    }
+    return frameworks;
+  } catch {
+    return [];
+  }
+}
+function detectPythonFrameworks(dir) {
+  const frameworks = [];
+  const candidates = [
+    path3.join(dir, "pyproject.toml"),
+    path3.join(dir, "requirements.txt"),
+    ...globSync("apps/*/pyproject.toml", { cwd: dir, absolute: true }),
+    ...globSync("apps/*/requirements.txt", { cwd: dir, absolute: true }),
+    ...globSync("services/*/pyproject.toml", { cwd: dir, absolute: true })
+  ];
+  for (const filePath of candidates) {
+    if (!fs3.existsSync(filePath)) continue;
+    try {
+      const content = fs3.readFileSync(filePath, "utf-8").toLowerCase();
+      for (const [dep, framework] of Object.entries(PYTHON_FRAMEWORK_DEPS)) {
+        if (content.includes(dep)) frameworks.push(framework);
+      }
+    } catch {
+    }
+  }
+  return frameworks;
+}
+function analyzePackageJson(dir) {
+  const rootPkgPath = path3.join(dir, "package.json");
+  let name;
+  const allFrameworks = [];
+  const languages = [];
+  if (fs3.existsSync(rootPkgPath)) {
+    try {
+      const pkg2 = JSON.parse(fs3.readFileSync(rootPkgPath, "utf-8"));
+      name = pkg2.name;
+      const allDeps = { ...pkg2.dependencies, ...pkg2.devDependencies };
+      allFrameworks.push(...detectNodeFrameworks(rootPkgPath));
+      if (allDeps.typescript || allDeps["@types/node"]) {
+        languages.push("TypeScript");
+      }
+      languages.push("JavaScript");
+    } catch {
+    }
+  }
+  for (const glob of WORKSPACE_GLOBS) {
+    const matches = globSync(glob, { cwd: dir, absolute: true });
+    for (const pkgPath of matches) {
+      allFrameworks.push(...detectNodeFrameworks(pkgPath));
+      try {
+        const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+        const deps = { ...pkg2.dependencies, ...pkg2.devDependencies };
+        if (deps.typescript || deps["@types/node"]) {
+          languages.push("TypeScript");
+        }
+      } catch {
+      }
+    }
+  }
+  allFrameworks.push(...detectPythonFrameworks(dir));
+  return {
+    name,
+    frameworks: [...new Set(allFrameworks)],
+    languages: [...new Set(languages)]
+  };
+}
+
+// src/fingerprint/file-tree.ts
+import fs4 from "fs";
+import path4 from "path";
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  ".cache",
+  ".turbo",
+  "coverage",
+  ".caliber",
+  "__pycache__",
+  ".venv",
+  "vendor",
+  "target"
+]);
+function getFileTree(dir, maxDepth = 3) {
+  const files = [];
+  scan(dir, "", 0, maxDepth, files);
+  return files;
+}
+function scan(base, rel, depth, maxDepth, result) {
+  if (depth > maxDepth) return;
+  const fullPath = path4.join(base, rel);
+  let entries;
+  try {
+    entries = fs4.readdirSync(fullPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && depth === 0 && entry.isDirectory()) continue;
+    if (IGNORE_DIRS.has(entry.name)) continue;
+    const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      result.push(`${relPath}/`);
+      scan(base, relPath, depth + 1, maxDepth, result);
+    } else {
+      result.push(relPath);
+    }
+  }
+}
+
+// src/fingerprint/languages.ts
+import path5 from "path";
+var EXT_TO_LANG = {
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript",
+  ".js": "JavaScript",
+  ".jsx": "JavaScript",
+  ".py": "Python",
+  ".go": "Go",
+  ".rs": "Rust",
+  ".rb": "Ruby",
+  ".java": "Java",
+  ".kt": "Kotlin",
+  ".swift": "Swift",
+  ".cs": "C#",
+  ".cpp": "C++",
+  ".c": "C",
+  ".php": "PHP",
+  ".dart": "Dart",
+  ".ex": "Elixir",
+  ".exs": "Elixir",
+  ".scala": "Scala",
+  ".zig": "Zig"
+};
+function detectLanguages(fileTree) {
+  const langs = /* @__PURE__ */ new Set();
+  for (const file of fileTree) {
+    const ext = path5.extname(file).toLowerCase();
+    if (EXT_TO_LANG[ext]) {
+      langs.add(EXT_TO_LANG[ext]);
+    }
+  }
+  return [...langs];
+}
+
+// src/fingerprint/existing-config.ts
+import fs5 from "fs";
+import path6 from "path";
+function readExistingConfigs(dir) {
+  const configs = {};
+  const claudeMdPath = path6.join(dir, "CLAUDE.md");
+  if (fs5.existsSync(claudeMdPath)) {
+    configs.claudeMd = fs5.readFileSync(claudeMdPath, "utf-8");
+  }
+  const claudeSettingsPath = path6.join(dir, ".claude", "settings.json");
+  if (fs5.existsSync(claudeSettingsPath)) {
+    try {
+      configs.claudeSettings = JSON.parse(fs5.readFileSync(claudeSettingsPath, "utf-8"));
+    } catch {
+    }
+  }
+  const skillsDir = path6.join(dir, ".claude", "skills");
+  if (fs5.existsSync(skillsDir)) {
+    try {
+      const files = fs5.readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
+      configs.claudeSkills = files.map((f) => ({
+        filename: f,
+        content: fs5.readFileSync(path6.join(skillsDir, f), "utf-8")
+      }));
+    } catch {
+    }
+  }
+  const cursorrulesPath = path6.join(dir, ".cursorrules");
+  if (fs5.existsSync(cursorrulesPath)) {
+    configs.cursorrules = fs5.readFileSync(cursorrulesPath, "utf-8");
+  }
+  const cursorRulesDir = path6.join(dir, ".cursor", "rules");
+  if (fs5.existsSync(cursorRulesDir)) {
+    try {
+      const files = fs5.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"));
+      configs.cursorRules = files.map((f) => ({
+        filename: f,
+        content: fs5.readFileSync(path6.join(cursorRulesDir, f), "utf-8")
+      }));
+    } catch {
+    }
+  }
+  return configs;
+}
+
+// src/fingerprint/index.ts
+function collectFingerprint(dir) {
+  const gitRemoteUrl = getGitRemoteUrl();
+  const pkgInfo = analyzePackageJson(dir);
+  const fileTree = getFileTree(dir);
+  const fileLangs = detectLanguages(fileTree);
+  const existingConfigs = readExistingConfigs(dir);
+  const languages = [.../* @__PURE__ */ new Set([...pkgInfo.languages, ...fileLangs])];
+  return {
+    gitRemoteUrl,
+    packageName: pkgInfo.name,
+    languages,
+    frameworks: pkgInfo.frameworks,
+    fileTree,
+    existingConfigs
+  };
+}
+function computeFingerprintHash(fingerprint) {
+  const key = [
+    fingerprint.gitRemoteUrl || "",
+    fingerprint.packageName || ""
+  ].join("::");
+  return crypto2.createHash("sha256").update(key).digest("hex");
+}
+
+// src/api/client.ts
+init_constants();
+async function refreshTokenIfNeeded() {
+  const auth2 = getStoredAuth();
+  if (!auth2) return null;
+  if (!isTokenExpired()) return auth2.accessToken;
+  try {
+    const resp = await fetch(`${API_URL}/api/auth/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refreshToken: auth2.refreshToken })
+    });
+    if (!resp.ok) return null;
+    const { data } = await resp.json();
+    storeAuth({
+      accessToken: data.accessToken,
+      refreshToken: data.refreshToken,
+      expiresIn: data.expiresIn,
+      user: { id: auth2.userId, email: auth2.email }
+    });
+    return data.accessToken;
+  } catch {
+    return null;
+  }
+}
+async function apiRequest(path11, options = {}) {
+  const token = await refreshTokenIfNeeded();
+  if (!token) {
+    throw new Error("Not authenticated. Run `caliber login` first.");
+  }
+  const resp = await fetch(`${API_URL}${path11}`, {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: options.body ? JSON.stringify(options.body) : void 0
+  });
+  if (!resp.ok) {
+    const error = await resp.json().catch(() => ({ error: resp.statusText }));
+    throw new Error(error.error || `API error: ${resp.status}`);
+  }
+  const json = await resp.json();
+  return json.data;
+}
+async function apiStream(path11, body, onChunk, onComplete, onError, onStatus) {
+  const token = await refreshTokenIfNeeded();
+  if (!token) {
+    throw new Error("Not authenticated. Run `caliber login` first.");
+  }
+  const resp = await fetch(`${API_URL}${path11}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!resp.ok || !resp.body) {
+    throw new Error(`API error: ${resp.status}`);
+  }
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6);
+      if (data === "[DONE]") return;
+      try {
+        const parsed = JSON.parse(data);
+        if (parsed.type === "chunk") onChunk(parsed.content);
+        else if (parsed.type === "status" && onStatus) onStatus(parsed.message);
+        else if (parsed.type === "complete") onComplete({ setup: parsed.setup, explanation: parsed.explanation });
+        else if (parsed.type === "error") onError(parsed.message);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/writers/index.ts
+import fs10 from "fs";
+
+// src/writers/claude/index.ts
+import fs6 from "fs";
+import path7 from "path";
+function writeClaudeConfig(config) {
+  const written = [];
+  fs6.writeFileSync("CLAUDE.md", config.claudeMd);
+  written.push("CLAUDE.md");
+  const claudeDir = ".claude";
+  if (!fs6.existsSync(claudeDir)) fs6.mkdirSync(claudeDir, { recursive: true });
+  fs6.writeFileSync(
+    path7.join(claudeDir, "settings.json"),
+    JSON.stringify(config.settings, null, 2)
+  );
+  written.push(path7.join(claudeDir, "settings.json"));
+  fs6.writeFileSync(
+    path7.join(claudeDir, "settings.local.json"),
+    JSON.stringify(config.settingsLocal, null, 2)
+  );
+  written.push(path7.join(claudeDir, "settings.local.json"));
+  if (config.skills?.length) {
+    const skillsDir = path7.join(claudeDir, "skills");
+    if (!fs6.existsSync(skillsDir)) fs6.mkdirSync(skillsDir, { recursive: true });
+    for (const skill of config.skills) {
+      const filename = `${skill.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.md`;
+      const skillPath = path7.join(skillsDir, filename);
+      fs6.writeFileSync(skillPath, skill.content);
+      written.push(skillPath);
+    }
+  }
+  if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
+    const mcpConfig = { mcpServers: config.mcpServers };
+    fs6.writeFileSync(".mcp.json", JSON.stringify(mcpConfig, null, 2));
+    written.push(".mcp.json");
+  }
+  return written;
+}
+
+// src/writers/cursor/index.ts
+import fs7 from "fs";
+import path8 from "path";
+function writeCursorConfig(config) {
+  const written = [];
+  if (config.cursorrules) {
+    fs7.writeFileSync(".cursorrules", config.cursorrules);
+    written.push(".cursorrules");
+  }
+  if (config.rules?.length) {
+    const rulesDir = path8.join(".cursor", "rules");
+    if (!fs7.existsSync(rulesDir)) fs7.mkdirSync(rulesDir, { recursive: true });
+    for (const rule of config.rules) {
+      const rulePath = path8.join(rulesDir, rule.filename);
+      fs7.writeFileSync(rulePath, rule.content);
+      written.push(rulePath);
+    }
+  }
+  if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
+    const cursorDir = ".cursor";
+    if (!fs7.existsSync(cursorDir)) fs7.mkdirSync(cursorDir, { recursive: true });
+    const mcpConfig = { mcpServers: config.mcpServers };
+    fs7.writeFileSync(
+      path8.join(cursorDir, "mcp.json"),
+      JSON.stringify(mcpConfig, null, 2)
+    );
+    written.push(path8.join(cursorDir, "mcp.json"));
+  }
+  return written;
+}
+
+// src/writers/backup.ts
+init_constants();
+import fs8 from "fs";
+import path9 from "path";
+function createBackup(files) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupDir = path9.join(BACKUPS_DIR, timestamp);
+  for (const file of files) {
+    if (!fs8.existsSync(file)) continue;
+    const dest = path9.join(backupDir, file);
+    const destDir = path9.dirname(dest);
+    if (!fs8.existsSync(destDir)) {
+      fs8.mkdirSync(destDir, { recursive: true });
+    }
+    fs8.copyFileSync(file, dest);
+  }
+  return backupDir;
+}
+function restoreBackup(backupDir, file) {
+  const backupFile = path9.join(backupDir, file);
+  if (!fs8.existsSync(backupFile)) return false;
+  const destDir = path9.dirname(file);
+  if (!fs8.existsSync(destDir)) {
+    fs8.mkdirSync(destDir, { recursive: true });
+  }
+  fs8.copyFileSync(backupFile, file);
+  return true;
+}
+
+// src/writers/manifest.ts
+init_constants();
+import fs9 from "fs";
+import crypto3 from "crypto";
+function readManifest() {
+  try {
+    if (!fs9.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs9.readFileSync(MANIFEST_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeManifest(manifest) {
+  if (!fs9.existsSync(CALIBER_DIR)) {
+    fs9.mkdirSync(CALIBER_DIR, { recursive: true });
+  }
+  fs9.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+}
+function fileChecksum(filePath) {
+  const content = fs9.readFileSync(filePath);
+  return crypto3.createHash("sha256").update(content).digest("hex");
+}
+
+// src/writers/index.ts
+function writeSetup(setup) {
+  const filesToWrite = getFilesToWrite(setup);
+  const existingFiles = filesToWrite.filter((f) => fs10.existsSync(f));
+  const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
+  const written = [];
+  if ((setup.targetAgent === "claude" || setup.targetAgent === "both") && setup.claude) {
+    written.push(...writeClaudeConfig(setup.claude));
+  }
+  if ((setup.targetAgent === "cursor" || setup.targetAgent === "both") && setup.cursor) {
+    written.push(...writeCursorConfig(setup.cursor));
+  }
+  ensureGitignore();
+  const entries = written.map((file) => ({
+    path: file,
+    action: existingFiles.includes(file) ? "modified" : "created",
+    checksum: fileChecksum(file),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  writeManifest({ version: 1, backupDir, entries });
+  return { written, backupDir };
+}
+function undoSetup() {
+  const manifest = readManifest();
+  if (!manifest) {
+    throw new Error("No manifest found. Nothing to undo.");
+  }
+  const restored = [];
+  const removed = [];
+  for (const entry of manifest.entries) {
+    if (entry.action === "created") {
+      if (fs10.existsSync(entry.path)) {
+        fs10.unlinkSync(entry.path);
+        removed.push(entry.path);
+      }
+    } else if (entry.action === "modified" && manifest.backupDir) {
+      if (restoreBackup(manifest.backupDir, entry.path)) {
+        restored.push(entry.path);
+      }
+    }
+  }
+  const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
+  if (fs10.existsSync(MANIFEST_FILE2)) {
+    fs10.unlinkSync(MANIFEST_FILE2);
+  }
+  return { restored, removed };
+}
+function getFilesToWrite(setup) {
+  const files = [];
+  if ((setup.targetAgent === "claude" || setup.targetAgent === "both") && setup.claude) {
+    files.push("CLAUDE.md", ".claude/settings.json", ".claude/settings.local.json");
+    if (setup.claude.mcpServers) files.push(".mcp.json");
+    if (setup.claude.skills) {
+      for (const s of setup.claude.skills) {
+        files.push(`.claude/skills/${s.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.md`);
+      }
+    }
+  }
+  if ((setup.targetAgent === "cursor" || setup.targetAgent === "both") && setup.cursor) {
+    if (setup.cursor.cursorrules) files.push(".cursorrules");
+    if (setup.cursor.rules) {
+      for (const r of setup.cursor.rules) files.push(`.cursor/rules/${r.filename}`);
+    }
+    if (setup.cursor.mcpServers) files.push(".cursor/mcp.json");
+  }
+  return files;
+}
+function ensureGitignore() {
+  const gitignorePath = ".gitignore";
+  if (fs10.existsSync(gitignorePath)) {
+    const content = fs10.readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(".caliber/")) {
+      fs10.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+    }
+  } else {
+    fs10.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+  }
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  console.log(chalk2.bold.hex("#6366f1")(`
+   \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557     \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+  \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+  \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551
+   \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D
+  `));
+  console.log(chalk2.dim("  Configure your coding agent environment\n"));
+  let auth2 = getStoredAuth();
+  if (!auth2) {
+    console.log(chalk2.yellow("Not logged in. Starting authentication...\n"));
+    await loginCommand();
+    auth2 = getStoredAuth();
+    if (!auth2) {
+      console.log(chalk2.red("Authentication required. Exiting."));
+      process.exit(1);
+    }
+  }
+  console.log(chalk2.dim(`Authenticated as ${auth2.email}
+`));
+  const spinner = ora2("Analyzing project...").start();
+  const fingerprint = collectFingerprint(process.cwd());
+  const hash = computeFingerprintHash(fingerprint);
+  spinner.succeed("Project analyzed");
+  trackEvent("scan_completed", {
+    languages: fingerprint.languages,
+    frameworks: fingerprint.frameworks,
+    has_existing_config: !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.cursorrules),
+    has_claude_md: !!fingerprint.existingConfigs.claudeMd,
+    has_claude_settings: !!fingerprint.existingConfigs.claudeSettings,
+    has_cursorrules: !!fingerprint.existingConfigs.cursorrules,
+    cursor_rules_count: fingerprint.existingConfigs.cursorRules?.length ?? 0,
+    skills_count: fingerprint.existingConfigs.claudeSkills?.length ?? 0,
+    file_count: fingerprint.fileTree.length
+  });
+  console.log(chalk2.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
+  console.log(chalk2.dim(`  Frameworks: ${fingerprint.frameworks.join(", ") || "none detected"}`));
+  console.log(chalk2.dim(`  Files: ${fingerprint.fileTree.length} found
+`));
+  const matchSpinner = ora2("Checking for existing setup...").start();
+  let existingSetup = null;
+  try {
+    const match = await apiRequest("/api/projects/match", {
+      method: "POST",
+      body: { fingerprintHash: hash }
+    });
+    if (match.setup) {
+      existingSetup = match.setup;
+      trackEvent("existing_config_detected");
+      matchSpinner.succeed("Found existing setup");
+    } else {
+      matchSpinner.info("No existing setup found");
+    }
+  } catch {
+    matchSpinner.info("No existing setup found");
+  }
+  const targetAgent = options.agent || await promptAgent();
+  trackEvent("target_agent_selected", { target_agent: targetAgent });
+  const isEmpty = fingerprint.fileTree.length < 3;
+  if (isEmpty) {
+    fingerprint.description = await promptInput("What will you build in this project?");
+  }
+  let generatedSetup = null;
+  let setupExplanation;
+  trackEvent("generation_started", { target_agent: targetAgent });
+  const generationStart = Date.now();
+  const genSpinner = ora2("Generating setup...").start();
+  await apiStream(
+    "/api/setups/generate",
+    {
+      fingerprint,
+      targetAgent,
+      prompt: fingerprint.description
+    },
+    () => {
+    },
+    (payload) => {
+      generatedSetup = payload.setup;
+      setupExplanation = payload.explanation;
+    },
+    (error) => {
+      trackEvent("error_occurred", { error_type: "generation_failed", error_message: error });
+      genSpinner.fail(`Generation error: ${error}`);
+    },
+    (status) => {
+      genSpinner.text = status;
+    }
+  );
+  if (!generatedSetup) {
+    genSpinner.fail("Failed to generate setup.");
+    process.exit(1);
+  }
+  trackEvent("generation_completed", {
+    target_agent: targetAgent,
+    duration_ms: Date.now() - generationStart,
+    files_suggested: countSuggestedFiles(generatedSetup)
+  });
+  genSpinner.succeed("Setup generated");
+  printSetupSummary(generatedSetup);
+  let action = await promptAction();
+  while (action === "explain") {
+    if (setupExplanation) {
+      console.log(chalk2.bold("\nWhy this setup?\n"));
+      console.log(chalk2.dim(setupExplanation));
+      console.log("");
+    } else {
+      console.log(chalk2.dim("\nNo explanation available for this setup.\n"));
+    }
+    action = await promptAction();
+  }
+  if (action === "decline") {
+    trackEvent("setup_declined");
+    console.log(chalk2.dim("Setup declined. No files were modified."));
+    return;
+  }
+  if (action === "refine") {
+    generatedSetup = await refineLoop(generatedSetup, targetAgent);
+    if (!generatedSetup) {
+      trackEvent("generation_cancelled");
+      console.log(chalk2.dim("Refinement cancelled. No files were modified."));
+      return;
+    }
+  }
+  if (options.dryRun) {
+    console.log(chalk2.yellow("\n[Dry run] Would write the following files:"));
+    console.log(JSON.stringify(generatedSetup, null, 2));
+    return;
+  }
+  const writeSpinner = ora2("Writing config files...").start();
+  try {
+    const result = writeSetup(generatedSetup);
+    writeSpinner.succeed("Config files written");
+    trackEvent("setup_applied", { files_written: result.written.length, target_agent: targetAgent });
+    for (const file of result.written) {
+      trackEvent("config_file_written", { file_type: path10.extname(file) || path10.basename(file) });
+    }
+    console.log(chalk2.bold("\nFiles created/updated:"));
+    for (const file of result.written) {
+      console.log(`  ${chalk2.green("\u2713")} ${file}`);
+    }
+    if (result.backupDir) {
+      console.log(chalk2.dim(`
+  Backups saved to ${result.backupDir}`));
+    }
+  } catch (err) {
+    writeSpinner.fail("Failed to write files");
+    console.error(chalk2.red(err instanceof Error ? err.message : "Unknown error"));
+    process.exit(1);
+  }
+  try {
+    const project = await apiRequest("/api/projects", {
+      method: "POST",
+      body: {
+        fingerprintHash: hash,
+        name: fingerprint.packageName || "untitled",
+        gitRemoteUrl: fingerprint.gitRemoteUrl,
+        description: fingerprint.description
+      }
+    });
+    trackEvent("project_created", { project_name: fingerprint.packageName || "untitled" });
+    await apiRequest(`/api/setups/project/${project.id}`, {
+      method: "POST",
+      body: {
+        targetAgent,
+        config: generatedSetup,
+        isMaster: true
+      }
+    });
+  } catch (err) {
+    console.log(chalk2.yellow(`
+  Warning: Could not save project to server.`));
+    console.log(chalk2.dim(`  ${err instanceof Error ? err.message : String(err)}`));
+    console.log(chalk2.dim(`  Your local setup is unaffected.
+`));
+  }
+  console.log(chalk2.bold.green("\nSetup complete! Your coding agent is now configured."));
+  console.log(chalk2.dim("Run `caliber undo` to revert changes.\n"));
+}
+async function refineLoop(currentSetup, _targetAgent) {
+  const history = [];
+  let refinementRound = 0;
+  while (true) {
+    const message = await promptInput("\nWhat would you like to change?");
+    if (!message || message.toLowerCase() === "done" || message.toLowerCase() === "accept") {
+      return currentSetup;
+    }
+    if (message.toLowerCase() === "cancel") {
+      return null;
+    }
+    refinementRound++;
+    trackEvent("refinement_message_sent", { refinement_round: refinementRound });
+    let refined = null;
+    const refineSpinner = ora2("Refining setup...").start();
+    await apiStream(
+      "/api/setups/refine",
+      { currentSetup, message, conversationHistory: history },
+      () => {
+      },
+      (payload) => {
+        refined = payload.setup;
+      },
+      (error) => {
+        refineSpinner.fail(`Refinement error: ${error}`);
+      },
+      (status) => {
+        refineSpinner.text = status;
+      }
+    );
+    if (refined) {
+      currentSetup = refined;
+      history.push({ role: "user", content: message });
+      history.push({ role: "assistant", content: JSON.stringify(refined) });
+      refineSpinner.succeed("Setup updated");
+      printSetupSummary(refined);
+      console.log(chalk2.dim('Type "done" to accept, or describe more changes.'));
+    }
+  }
+}
+function promptInput(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(chalk2.cyan(`${question} `), (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function promptAgent() {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log(chalk2.bold("Which coding agent are you using?"));
+    console.log("  1. Claude Code");
+    console.log("  2. Cursor");
+    console.log("  3. Both");
+    rl.question(chalk2.cyan("\nChoose (1-3): "), (answer) => {
+      rl.close();
+      const map = { "1": "claude", "2": "cursor", "3": "both" };
+      resolve(map[answer.trim()] || "claude");
+    });
+  });
+}
+function promptAction() {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log(chalk2.bold("What would you like to do?"));
+    console.log("  1. Accept and apply");
+    console.log("  2. Refine via chat");
+    console.log("  3. Explain recommendations");
+    console.log("  4. Decline");
+    rl.question(chalk2.cyan("\nChoose (1-4): "), (answer) => {
+      rl.close();
+      const map = {
+        "1": "accept",
+        "2": "refine",
+        "3": "explain",
+        "4": "decline"
+      };
+      resolve(map[answer.trim()] || "accept");
+    });
+  });
+}
+function printSetupSummary(setup) {
+  const claude = setup.claude;
+  const cursor = setup.cursor;
+  console.log("");
+  if (claude) {
+    if (claude.claudeMd) {
+      console.log(`  ${chalk2.green("+")} CLAUDE.md ${chalk2.dim("\u2014 project guidelines, commands, conventions")}`);
+    }
+    if (claude.settings) {
+      console.log(`  ${chalk2.green("+")} .claude/settings.json ${chalk2.dim("\u2014 tool permissions & hooks")}`);
+    }
+    if (claude.settingsLocal) {
+      console.log(`  ${chalk2.green("+")} .claude/settings.local.json ${chalk2.dim("\u2014 local dev permissions")}`);
+    }
+    const skills = claude.skills;
+    if (Array.isArray(skills) && skills.length > 0) {
+      console.log(`  ${chalk2.green("+")} ${skills.length} skill${skills.length > 1 ? "s" : ""}:`);
+      for (const skill of skills) {
+        console.log(`    ${chalk2.dim("\u2022")} ${skill.name}`);
+      }
+    }
+    const mcpServers = claude.mcpServers;
+    if (mcpServers && Object.keys(mcpServers).length > 0) {
+      const names = Object.keys(mcpServers);
+      console.log(`  ${chalk2.green("+")} ${names.length} MCP server${names.length > 1 ? "s" : ""}:`);
+      for (const name of names) {
+        console.log(`    ${chalk2.dim("\u2022")} ${name}`);
+      }
+    }
+  }
+  if (cursor) {
+    if (cursor.cursorrules) {
+      console.log(`  ${chalk2.green("+")} .cursorrules ${chalk2.dim("\u2014 coding rules for Cursor")}`);
+    }
+    const rules = cursor.rules;
+    if (Array.isArray(rules) && rules.length > 0) {
+      console.log(`  ${chalk2.green("+")} ${rules.length} Cursor rule${rules.length > 1 ? "s" : ""}:`);
+      for (const rule of rules) {
+        console.log(`    ${chalk2.dim("\u2022")} ${rule.filename}`);
+      }
+    }
+    const mcpServers = cursor.mcpServers;
+    if (mcpServers && Object.keys(mcpServers).length > 0) {
+      const names = Object.keys(mcpServers);
+      console.log(`  ${chalk2.green("+")} ${names.length} MCP server${names.length > 1 ? "s" : ""}:`);
+      for (const name of names) {
+        console.log(`    ${chalk2.dim("\u2022")} ${name}`);
+      }
+    }
+  }
+  console.log("");
+}
+
+// src/commands/undo.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+function undoCommand() {
+  const spinner = ora3("Reverting setup...").start();
+  try {
+    const { restored, removed } = undoSetup();
+    if (restored.length === 0 && removed.length === 0) {
+      spinner.info("Nothing to undo.");
+      return;
+    }
+    spinner.succeed("Setup reverted successfully.\n");
+    trackEvent("setup_undone", { restored: restored.length, removed: removed.length });
+    if (restored.length > 0) {
+      console.log(chalk3.cyan("  Restored from backup:"));
+      for (const file of restored) {
+        console.log(`    ${chalk3.green("\u21A9")} ${file}`);
+      }
+    }
+    if (removed.length > 0) {
+      console.log(chalk3.cyan("  Removed:"));
+      for (const file of removed) {
+        console.log(`    ${chalk3.red("\u2717")} ${file}`);
+      }
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail(chalk3.red(err instanceof Error ? err.message : "Undo failed"));
+    process.exit(1);
+  }
+}
+
+// src/commands/status.ts
+import chalk4 from "chalk";
+import fs11 from "fs";
+function statusCommand(options) {
+  const auth2 = getStoredAuth();
+  const manifest = readManifest();
+  if (options.json) {
+    console.log(JSON.stringify({
+      authenticated: !!auth2,
+      email: auth2?.email,
+      manifest
+    }, null, 2));
+    return;
+  }
+  console.log(chalk4.bold("\nCaliber Status\n"));
+  if (auth2) {
+    console.log(`  Auth: ${chalk4.green("Logged in")} as ${auth2.email}`);
+  } else {
+    console.log(`  Auth: ${chalk4.yellow("Not logged in")}`);
+  }
+  if (!manifest) {
+    console.log(`  Setup: ${chalk4.dim("No setup applied")}`);
+    console.log(chalk4.dim("\n  Run `caliber init` to get started.\n"));
+    return;
+  }
+  console.log(`  Files managed: ${chalk4.cyan(manifest.entries.length.toString())}`);
+  for (const entry of manifest.entries) {
+    const exists = fs11.existsSync(entry.path);
+    const icon = exists ? chalk4.green("\u2713") : chalk4.red("\u2717");
+    console.log(`    ${icon} ${entry.path} (${entry.action})`);
+  }
+  console.log("");
+}
+
+// src/commands/update.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+import readline2 from "readline";
+async function updateCommand(options) {
+  const auth2 = getStoredAuth();
+  if (!auth2) {
+    console.log(chalk5.red("Not logged in. Run `caliber login` first."));
+    process.exit(1);
+  }
+  const manifest = readManifest();
+  if (!manifest) {
+    console.log(chalk5.yellow("No existing setup found. Run `caliber init` first."));
+    process.exit(1);
+  }
+  const spinner = ora4("Re-analyzing project...").start();
+  const fingerprint = collectFingerprint(process.cwd());
+  spinner.succeed("Project re-analyzed");
+  trackEvent("scan_completed", {
+    languages: fingerprint.languages,
+    frameworks: fingerprint.frameworks,
+    has_existing_config: !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.cursorrules),
+    has_claude_md: !!fingerprint.existingConfigs.claudeMd,
+    has_claude_settings: !!fingerprint.existingConfigs.claudeSettings,
+    has_cursorrules: !!fingerprint.existingConfigs.cursorrules,
+    cursor_rules_count: fingerprint.existingConfigs.cursorRules?.length ?? 0,
+    skills_count: fingerprint.existingConfigs.claudeSkills?.length ?? 0,
+    file_count: fingerprint.fileTree.length
+  });
+  let generatedSetup = null;
+  trackEvent("generation_started", { target_agent: "both" });
+  const generationStart = Date.now();
+  const genSpinner = ora4("Regenerating setup...").start();
+  await apiStream(
+    "/api/setups/generate",
+    {
+      fingerprint,
+      targetAgent: "both"
+    },
+    () => {
+    },
+    (payload) => {
+      generatedSetup = payload.setup;
+    },
+    (error) => {
+      trackEvent("error_occurred", { error_type: "generation_failed", error_message: error });
+      genSpinner.fail(`Generation error: ${error}`);
+    },
+    (status) => {
+      genSpinner.text = status;
+    }
+  );
+  if (!generatedSetup) {
+    genSpinner.fail("Failed to regenerate setup.");
+    process.exit(1);
+  }
+  genSpinner.succeed("Setup regenerated");
+  trackEvent("generation_completed", {
+    target_agent: "both",
+    duration_ms: Date.now() - generationStart,
+    files_suggested: countSuggestedFiles(generatedSetup)
+  });
+  if (options.dryRun) {
+    console.log(chalk5.yellow("\n[Dry run] Would write:"));
+    console.log(JSON.stringify(generatedSetup, null, 2));
+    return;
+  }
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question(chalk5.cyan("\n\nApply updated setup? (y/n): "), resolve);
+  });
+  rl.close();
+  if (answer.trim().toLowerCase() !== "y") {
+    trackEvent("generation_cancelled");
+    console.log(chalk5.dim("Update cancelled."));
+    return;
+  }
+  const writeSpinner = ora4("Updating config files...").start();
+  const result = writeSetup(generatedSetup);
+  writeSpinner.succeed("Config files updated");
+  trackEvent("setup_updated", { files_written: result.written.length });
+  for (const file of result.written) {
+    console.log(`  ${chalk5.green("\u2713")} ${file}`);
+  }
+  console.log("");
+}
+
+// src/commands/logout.ts
+import chalk6 from "chalk";
+function logoutCommand() {
+  const auth2 = getStoredAuth();
+  if (!auth2) {
+    console.log(chalk6.dim("Not currently logged in."));
+    return;
+  }
+  clearAuth();
+  trackEvent("logout");
+  console.log(chalk6.green("Logged out successfully."));
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("caliber").description("Configure your coding agent environment").version("0.1.0");
+program.command("init").description("Initialize coding agent setup for this project").option("--agent <type>", "Target agent: claude, cursor, or both").option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").action(initCommand);
+program.command("undo").description("Revert all config changes made by Caliber").action(undoCommand);
+program.command("status").description("Show current Caliber setup status").option("--json", "Output as JSON").action(statusCommand);
+program.command("update").description("Re-analyze project and update setup").option("--dry-run", "Preview changes without writing files").action(updateCommand);
+program.command("login").description("Authenticate with Caliber").action(loginCommand);
+program.command("logout").description("Clear stored credentials").action(logoutCommand);
+
+// src/bin.ts
+var firstRun = isFirstRun();
+getDeviceId();
+if (firstRun) {
+  trackEvent("cli_installed");
+}
+var auth = getStoredAuth();
+if (auth) {
+  identifyUser(auth.userId, auth.email);
+}
+process.on("SIGINT", () => process.exit(130));
+process.on("SIGTERM", () => process.exit(143));
+program.parseAsync().finally(async () => {
+  await shutdownTelemetry();
+  process.exit(0);
+});
+//# sourceMappingURL=bin.js.map