npm - @vocoder/cli - Versions diffs - 0.1.4 → 0.1.7 - Mend

@vocoder/cli 0.1.4 → 0.1.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/README.md +173 -45
package/dist/bin.mjs +1803 -1679
package/dist/bin.mjs.map +1 -1
package/dist/chunk-OC5N5C5X.mjs +546 -0
package/dist/chunk-OC5N5C5X.mjs.map +1 -0
package/dist/lib.d.mts +175 -0
package/dist/lib.mjs +15 -0
package/dist/lib.mjs.map +1 -0
package/package.json +8 -2

package/dist/bin.mjs CHANGED Viewed

@@ -1,11 +1,320 @@
 #!/usr/bin/env node
+import {
+  StringExtractor,
+  buildInstallCommand,
+  detectLocalEcosystem,
+  getPackagesToInstall,
+  getSetupSnippets
+} from "./chunk-OC5N5C5X.mjs";
 // src/bin.ts
 import { Command } from "commander";
 // src/commands/init.ts
+import * as p5 from "@clack/prompts";
+// src/utils/auth-store.ts
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function getAuthFilePath() {
+  return join(homedir(), ".config", "vocoder", "auth.json");
+}
+function readAuthData() {
+  const filePath = getAuthFilePath();
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    const data = parsed;
+    if (typeof data.token !== "string" || typeof data.apiUrl !== "string" || typeof data.userId !== "string" || typeof data.email !== "string" || typeof data.createdAt !== "string") {
+      return null;
+    }
+    return {
+      token: data.token,
+      apiUrl: data.apiUrl,
+      userId: data.userId,
+      email: data.email,
+      name: typeof data.name === "string" ? data.name : null,
+      createdAt: data.createdAt
+    };
+  } catch {
+    return null;
+  }
+}
+function writeAuthData(data) {
+  const filePath = getAuthFilePath();
+  const dir = dirname(filePath);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function clearAuthData() {
+  const filePath = getAuthFilePath();
+  try {
+    unlinkSync(filePath);
+  } catch {
+  }
+}
+// src/utils/github-connect.ts
 import * as p from "@clack/prompts";
 import chalk from "chalk";
+import { spawn } from "child_process";
+// src/utils/local-server.ts
+import { createServer } from "http";
+import { URL as URL2 } from "url";
+function startCallbackServer() {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    let callbackResolve = null;
+    let callbackReject = null;
+    const callbackPromise = new Promise((res, rej) => {
+      callbackResolve = res;
+      callbackReject = rej;
+    });
+    const server = createServer((req, res) => {
+      if (!req.url) {
+        res.writeHead(400);
+        res.end();
+        return;
+      }
+      let pathname;
+      let params;
+      try {
+        const parsed = new URL2(req.url, "http://localhost");
+        pathname = parsed.pathname;
+        params = Object.fromEntries(parsed.searchParams.entries());
+      } catch {
+        res.writeHead(400);
+        res.end("Bad request");
+        return;
+      }
+      if (pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(
+        '<!DOCTYPE html><html><head><title>Authenticated</title></head><body style="font-family:sans-serif;text-align:center;padding:3rem;"><h2>Authenticated</h2><p>Return to your terminal to continue. You can close this tab.</p></body></html>'
+      );
+      if (callbackResolve) {
+        callbackResolve(params);
+        callbackResolve = null;
+      }
+      setImmediate(() => server.close());
+    });
+    server.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        if (callbackReject) callbackReject(err);
+        reject(err);
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      if (settled) return;
+      settled = true;
+      const port = server.address().port;
+      resolve2({
+        port,
+        waitForCallback: () => callbackPromise,
+        close: () => server.close()
+      });
+    });
+  });
+}
+// src/utils/github-connect.ts
+async function tryOpenBrowser(url) {
+  if (!process.stdout.isTTY || process.env.CI === "true") {
+    return false;
+  }
+  const platform = process.platform;
+  let command;
+  let args;
+  if (platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    command = "rundll32";
+    args = ["url.dll,FileProtocolHandler", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+  return new Promise((resolve2) => {
+    try {
+      const child = spawn(command, args, {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      });
+      let settled = false;
+      child.once("spawn", () => {
+        if (settled) return;
+        settled = true;
+        child.unref();
+        resolve2(true);
+      });
+      child.once("error", () => {
+        if (settled) return;
+        settled = true;
+        resolve2(false);
+      });
+      setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        resolve2(false);
+      }, 300);
+    } catch {
+      resolve2(false);
+    }
+  });
+}
+async function runGitHubInstallFlow(params) {
+  let server = null;
+  try {
+    server = await startCallbackServer();
+  } catch {
+  }
+  const { installUrl } = await params.api.startCliGitHubInstall(params.userToken, {
+    organizationId: params.organizationId,
+    callbackPort: server?.port
+  });
+  p.log.info("Opening GitHub to install the Vocoder App...");
+  p.note(installUrl, "Install URL");
+  if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
+    const shouldOpen = params.yes ? true : await p.confirm({ message: "Open in your browser?" });
+    if (p.isCancel(shouldOpen)) {
+      server?.close();
+      return null;
+    }
+    if (shouldOpen) {
+      const opened = await tryOpenBrowser(installUrl);
+      if (!opened) {
+        p.log.info("Could not open a browser automatically. Use the URL above.");
+      }
+    }
+  }
+  const connectSpinner = p.spinner();
+  connectSpinner.start("Waiting for GitHub App installation...");
+  if (server) {
+    try {
+      const params_timeout = 15 * 60 * 1e3;
+      const callbackParams = await Promise.race([
+        server.waitForCallback(),
+        new Promise((resolve2) => setTimeout(() => resolve2(null), params_timeout))
+      ]);
+      server.close();
+      if (!callbackParams) {
+        connectSpinner.stop("GitHub App installation timed out");
+        p.log.error("The installation flow timed out. Run `vocoder init` again.");
+        return null;
+      }
+      if (callbackParams.error) {
+        connectSpinner.stop("GitHub App installation failed");
+        p.log.error(callbackParams.error);
+        return null;
+      }
+      const { organizationId, connectionLabel, workspace_created } = callbackParams;
+      if (!organizationId || !connectionLabel) {
+        connectSpinner.stop("GitHub App installation incomplete");
+        p.log.error("Missing organization or connection data from callback.");
+        return null;
+      }
+      connectSpinner.stop(`Connected to GitHub as ${chalk.bold(connectionLabel)}`);
+      const orgName = workspace_created ? connectionLabel : organizationId;
+      return {
+        organizationId,
+        organizationName: orgName,
+        connectionLabel
+      };
+    } catch {
+      server.close();
+      connectSpinner.stop("GitHub App installation failed");
+      return null;
+    }
+  }
+  connectSpinner.stop("Could not detect GitHub App installation automatically");
+  p.log.warn("Complete the installation in your browser, then run `vocoder init` again.");
+  return null;
+}
+async function runGitHubDiscoveryFlow(params) {
+  let server = null;
+  try {
+    server = await startCallbackServer();
+  } catch {
+  }
+  const { oauthUrl } = await params.api.startCliGitHubOAuth(params.userToken, {
+    organizationId: params.organizationId,
+    callbackPort: server?.port
+  });
+  p.log.info("Opening GitHub to authorize your account...");
+  p.note("Complete authorization in your browser.");
+  if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
+    const shouldOpen = params.yes ? true : await p.confirm({ message: "Open in your browser?" });
+    if (p.isCancel(shouldOpen)) {
+      server?.close();
+      return null;
+    }
+    if (shouldOpen) {
+      const opened = await tryOpenBrowser(oauthUrl);
+      if (!opened) {
+        p.log.info(`Could not open browser automatically. Visit: ${oauthUrl}`);
+      }
+    }
+  }
+  const oauthSpinner = p.spinner();
+  oauthSpinner.start("Waiting for GitHub authorization...");
+  if (server) {
+    try {
+      const timeoutMs = 10 * 60 * 1e3;
+      const callbackParams = await Promise.race([
+        server.waitForCallback(),
+        new Promise((resolve2) => setTimeout(() => resolve2(null), timeoutMs))
+      ]);
+      server.close();
+      if (!callbackParams) {
+        oauthSpinner.stop("GitHub authorization timed out");
+        return null;
+      }
+      if (callbackParams.error) {
+        oauthSpinner.stop("GitHub authorization failed");
+        p.log.error(callbackParams.error);
+        return null;
+      }
+    } catch {
+      server.close();
+      oauthSpinner.stop("GitHub authorization failed");
+      return null;
+    }
+  }
+  oauthSpinner.stop("GitHub account authorized");
+  const discoveryResult = await params.api.getCliGitHubDiscovery(params.userToken);
+  return discoveryResult.installations;
+}
+async function selectGitHubInstallation(installations, canInstallNew) {
+  const options = installations.map((inst) => ({
+    value: String(inst.installationId),
+    label: inst.accountLogin,
+    hint: [
+      inst.accountType === "Organization" ? "organization" : "personal",
+      inst.conflictLabel ? `connected to ${inst.conflictLabel}` : "",
+      inst.isSuspended ? "suspended" : ""
+    ].filter(Boolean).join(" \xB7 ") || void 0
+  }));
+  if (canInstallNew) {
+    options.push({ value: "install_new", label: "Install on a new account" });
+  }
+  const selected = await p.select({
+    message: "Select a GitHub installation",
+    options
+  });
+  if (p.isCancel(selected)) return null;
+  if (selected === "install_new") return "install_new";
+  return Number(selected);
+}
 // src/utils/api.ts
 function isLimitErrorResponse(value) {
@@ -255,85 +564,329 @@ var VocoderAPI = class {
     }
     return payload;
   }
+  // ── CLI Auth endpoints (no project API key needed) ──────────────────────────
   /**
-   * Look up whether a project already exists for a given repo + scope.
-   * Returns { projectId, projectName, organizationName } or null if not found.
+   * Start a CLI auth session. Returns `{ sessionId, verificationUrl, expiresAt }`.
+   * `sessionId` is the raw poll token — keep it secret, used for polling.
    */
-  async lookupProjectByRepo(params) {
-    try {
-      const response = await fetch(`${this.apiUrl}/api/cli/init/lookup`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          repo: params.repoCanonical,
-          scopePath: params.scopePath
-        })
+  async startCliAuthSession(callbackPort, repoCanonical) {
+    const response = await fetch(`${this.apiUrl}/api/cli/auth/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ...callbackPort != null ? { callbackPort } : {},
+        ...repoCanonical ? { repoCanonical } : {}
+      })
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to start auth session (${response.status})`),
+        status: response.status,
+        payload
       });
-      if (response.status === 404) return null;
-      if (!response.ok) return null;
-      return await response.json();
-    } catch {
-      return null;
     }
+    return payload;
   }
-};
-// src/utils/git-identity.ts
-import { execSync } from "child_process";
-import { relative, resolve } from "path";
-function safeExec(command) {
-  try {
-    const output = execSync(command, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
-    }).trim();
-    return output.length > 0 ? output : null;
-  } catch {
-    return null;
-  }
-}
-function normalizePath(pathname) {
-  const cleaned = pathname.replace(/^\/+/, "").replace(/\.git$/i, "").trim();
-  if (!cleaned || !cleaned.includes("/")) {
-    return null;
-  }
-  return cleaned;
-}
-function parseRemoteUrl(remoteUrl) {
-  const trimmed = remoteUrl.trim();
-  if (!trimmed) {
-    return null;
+  /**
+   * Poll for CLI auth session completion.
+   * Returns `{ token }` on success, throws on failure/expiry.
+   * The server returns HTTP 202 while still pending.
+   */
+  async pollCliAuthSession(pollToken) {
+    const response = await fetch(
+      `${this.apiUrl}/api/cli/auth/session?session=${encodeURIComponent(pollToken)}`
+    );
+    const payload = await readPayload(response);
+    if (response.status === 202) {
+      return { status: "pending" };
+    }
+    if (response.status === 410) {
+      return {
+        status: "failed",
+        reason: extractErrorMessage(payload, "Auth session expired or failed")
+      };
+    }
+    if (!response.ok) {
+      return {
+        status: "failed",
+        reason: extractErrorMessage(payload, `Auth session error (${response.status})`)
+      };
+    }
+    const result = payload;
+    if (!result.token) {
+      return { status: "failed", reason: "No token in response" };
+    }
+    return {
+      status: "complete",
+      token: result.token,
+      ...result.organizationId ? { organizationId: result.organizationId } : {}
+    };
   }
-  if (!trimmed.includes("://")) {
-    const scpMatch = trimmed.match(/^(?:.+@)?([^:]+):(.+)$/);
-    if (scpMatch) {
-      const host = (scpMatch[1] || "").toLowerCase();
-      const ownerRepoPath = normalizePath(scpMatch[2] || "");
-      if (!host || !ownerRepoPath) {
-        return null;
-      }
-      return { host, ownerRepoPath };
+  /**
+   * Validate a CLI user token and return the authenticated user's info.
+   * Used by the CLI to verify stored credentials on startup.
+   */
+  async getCliUserInfo(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/auth/me`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Token validation failed (${response.status})`),
+        status: response.status,
+        payload
+      });
     }
-    return null;
+    return payload;
   }
-  try {
-    const parsed = new URL(trimmed);
-    const host = parsed.hostname.toLowerCase();
-    const ownerRepoPath = normalizePath(decodeURIComponent(parsed.pathname));
-    if (!host || !ownerRepoPath) {
-      return null;
+  /**
+   * Revoke the given CLI user token server-side.
+   */
+  async revokeCliToken(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/auth/token`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    if (!response.ok) {
+      const payload = await readPayload(response);
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Token revocation failed (${response.status})`),
+        status: response.status,
+        payload
+      });
     }
-    return { host, ownerRepoPath };
-  } catch {
-    return null;
   }
-}
-function toCanonical(host, ownerRepoPath) {
-  if (host.includes("github.com")) {
-    return `github:${ownerRepoPath.toLowerCase()}`;
+  // ── Workspaces ────────────────────────────────────────────────────────────────
+  async listWorkspaces(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/workspaces`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to list workspaces (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
   }
-  if (host.includes("gitlab.com")) {
-    return `gitlab:${ownerRepoPath.toLowerCase()}`;
+  // ── CLI GitHub endpoints ──────────────────────────────────────────────────────
+  async startCliGitHubInstall(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/install/start`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${userToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to start GitHub install (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  /**
+   * Start the "link existing installation" discovery flow.
+   * Unlike startCliGitHubOAuth, this requires no bearer token — the Vocoder
+   * account is created from the OAuth code in the callback.
+   */
+  async startCliGitHubLinkSession(sessionId, callbackPort) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/oauth/link-start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sessionId, ...callbackPort != null ? { callbackPort } : {} })
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to start GitHub link session (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async startCliGitHubOAuth(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/oauth/start`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${userToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to start GitHub OAuth (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async getCliGitHubDiscovery(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/discovery`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to fetch GitHub discovery (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async claimCliGitHubInstallation(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/claim`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${userToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to claim GitHub installation (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  // ── Locales ───────────────────────────────────────────────────────────────────
+  async listLocales(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/locales`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to list locales (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    const result = payload;
+    return result.locales;
+  }
+  // ── Project creation ──────────────────────────────────────────────────────────
+  async createProject(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/projects`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${userToken}`
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to create project (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  // ── Project lookup ────────────────────────────────────────────────────────────
+  /**
+   * Look up whether a project already exists for a given repo + scope.
+   * Returns { projectId, projectName, organizationName } or null if not found.
+   */
+  async lookupProjectByRepo(params) {
+    try {
+      const response = await fetch(`${this.apiUrl}/api/cli/init/lookup`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          repo: params.repoCanonical,
+          scopePath: params.scopePath
+        })
+      });
+      if (response.status === 404) return null;
+      if (!response.ok) return null;
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+};
+// src/commands/init.ts
+import chalk6 from "chalk";
+import { execSync as execSync3 } from "child_process";
+import { config as loadEnv } from "dotenv";
+// src/utils/git-identity.ts
+import { execSync } from "child_process";
+import { relative, resolve } from "path";
+function safeExec(command) {
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    return output.length > 0 ? output : null;
+  } catch {
+    return null;
+  }
+}
+function normalizePath(pathname) {
+  const cleaned = pathname.replace(/^\/+/, "").replace(/\.git$/i, "").trim();
+  if (!cleaned || !cleaned.includes("/")) {
+    return null;
+  }
+  return cleaned;
+}
+function parseRemoteUrl(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (!trimmed.includes("://")) {
+    const scpMatch = trimmed.match(/^(?:.+@)?([^:]+):(.+)$/);
+    if (scpMatch) {
+      const host = (scpMatch[1] || "").toLowerCase();
+      const ownerRepoPath = normalizePath(scpMatch[2] || "");
+      if (!host || !ownerRepoPath) {
+        return null;
+      }
+      return { host, ownerRepoPath };
+    }
+    return null;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    const host = parsed.hostname.toLowerCase();
+    const ownerRepoPath = normalizePath(decodeURIComponent(parsed.pathname));
+    if (!host || !ownerRepoPath) {
+      return null;
+    }
+    return { host, ownerRepoPath };
+  } catch {
+    return null;
+  }
+}
+function toCanonical(host, ownerRepoPath) {
+  if (host.includes("github.com")) {
+    return `github:${ownerRepoPath.toLowerCase()}`;
+  }
+  if (host.includes("gitlab.com")) {
+    return `gitlab:${ownerRepoPath.toLowerCase()}`;
   }
   if (host.includes("bitbucket.org")) {
     return `bitbucket:${ownerRepoPath.toLowerCase()}`;
@@ -374,18 +927,563 @@ function resolveGitContext() {
   return { identity, warnings };
 }
+// src/utils/project-create.ts
+import * as p3 from "@clack/prompts";
+import chalk4 from "chalk";
+// src/utils/locale-search.ts
+import { Prompt, isCancel as isCancel2 } from "@clack/core";
+import * as p2 from "@clack/prompts";
+import chalk2 from "chalk";
+var S_BAR = "\u2502";
+var S_BAR_END = "\u2514";
+var S_ACTIVE = "\u25C6";
+var S_SUBMIT = "\u25C6";
+var S_CANCEL = "\u25A0";
+var S_ERROR = "\u25B2";
+var noColor = process.env.NO_COLOR === "1" || process.env.FORCE_COLOR === "0";
+var dim = (s) => noColor ? s : chalk2.gray(s);
+var cyan = (s) => noColor ? s : chalk2.cyan(s);
+var grn = (s) => noColor ? s : chalk2.green(s);
+var ylw = (s) => noColor ? s : chalk2.yellow(s);
+var red = (s) => noColor ? s : chalk2.red(s);
+var bld = (s) => noColor ? s : chalk2.bold(s);
+function symbol(state) {
+  switch (state) {
+    case "submit":
+      return grn(S_SUBMIT);
+    case "cancel":
+      return red(S_CANCEL);
+    case "error":
+      return ylw(S_ERROR);
+    default:
+      return cyan(S_ACTIVE);
+  }
+}
+var MAX_VISIBLE = 12;
+function filterLocales(options, query) {
+  if (!query.trim()) return options;
+  const lower = query.toLowerCase();
+  return options.filter(
+    (o) => o.bcp47.toLowerCase().includes(lower) || o.label.toLowerCase().includes(lower)
+  );
+}
+function buildList(filtered, cursor, scrollOffset, selected) {
+  const isMulti = selected !== null;
+  const end = Math.min(filtered.length, scrollOffset + MAX_VISIBLE);
+  const visibleLines = [];
+  for (let i = scrollOffset; i < end; i++) {
+    const opt = filtered[i];
+    const isCursor = i === cursor;
+    const isChecked = isMulti && selected.has(opt.bcp47);
+    const icon = isMulti ? isChecked ? isCursor ? grn("\u25FC") : "\u25FC" : isCursor ? grn("\u25FB") : dim("\u25FB") : isCursor ? grn("\u25CF") : dim("\u25CB");
+    visibleLines.push(`${cyan(S_BAR)}  ${icon}  ${isCursor ? bld(opt.label) : opt.label}`);
+  }
+  const hidden = filtered.length - (end - scrollOffset);
+  if (hidden > 0) visibleLines.push(dim(`${S_BAR}  ${hidden} more \u2014 keep typing to narrow`));
+  if (filtered.length === 0) visibleLines.push(dim(`${S_BAR}  No matches`));
+  if (isMulti && selected.size > 0) {
+    visibleLines.push(dim(`${S_BAR}  ${selected.size} selected \u2014 Enter to confirm`));
+  }
+  return visibleLines.join("\n");
+}
+async function runFilterablePrompt(opts) {
+  const { message, options, multi } = opts;
+  let filter = "";
+  let cursor = 0;
+  let scrollOffset = 0;
+  const selected = new Set(multi ? opts.initialValues ?? [] : []);
+  if (!multi && opts.initialValue) {
+    const idx = options.findIndex((o) => o.bcp47 === opts.initialValue);
+    if (idx >= 0) cursor = idx;
+  }
+  const getFiltered = () => filterLocales(options, filter);
+  const clampCursor = (filtered) => {
+    if (cursor >= filtered.length) cursor = Math.max(0, filtered.length - 1);
+    if (cursor < scrollOffset) scrollOffset = cursor;
+    if (cursor >= scrollOffset + MAX_VISIBLE) scrollOffset = cursor - MAX_VISIBLE + 1;
+    if (scrollOffset < 0) scrollOffset = 0;
+  };
+  const prompt = new Prompt(
+    {
+      initialValue: !multi ? options[cursor]?.bcp47 ?? null : null,
+      validate() {
+        const f = getFiltered();
+        if (multi && selected.size === 0) return "At least one target language is required.";
+        if (!multi && !f[cursor]) return "Please select a language.";
+        return void 0;
+      },
+      render() {
+        const filtered = getFiltered();
+        clampCursor(filtered);
+        const hdr = `${dim(S_BAR)}
+${symbol(this.state)}  ${message}
+`;
+        const hint = filter.length > 0 ? filter : dim("type to filter, \u2191\u2193 navigate" + (multi ? ", space select" : ""));
+        switch (this.state) {
+          case "submit": {
+            const val = multi ? Array.from(selected).map((id) => options.find((o) => o.bcp47 === id)?.label ?? id).join(", ") : options.find((o) => o.bcp47 === this.value)?.label ?? "";
+            return `${hdr}${dim(S_BAR)}  ${bld(val || dim("none"))}`;
+          }
+          case "cancel":
+            return `${hdr}${dim(S_BAR)}`;
+          case "error":
+            return [
+              hdr.trimEnd(),
+              `${ylw(S_BAR)}  ${dim("/")} ${hint}`,
+              buildList(filtered, cursor, scrollOffset, multi ? selected : null),
+              `${ylw(S_BAR_END)}  ${ylw(this.error)}`,
+              ""
+            ].join("\n");
+          default:
+            return [
+              hdr.trimEnd(),
+              `${cyan(S_BAR)}  ${dim("/")} ${hint}`,
+              buildList(filtered, cursor, scrollOffset, multi ? selected : null),
+              `${cyan(S_BAR_END)}`,
+              ""
+            ].join("\n");
+        }
+      }
+    },
+    false
+    // trackValue=false — we manage value manually
+  );
+  prompt.on("key", (key) => {
+    if (!key || key === " ") return;
+    const cp = key.codePointAt(0) ?? 0;
+    if (cp === 127 || cp === 8) {
+      filter = filter.slice(0, -1);
+      cursor = 0;
+      scrollOffset = 0;
+    } else if (cp >= 32 && cp !== 127) {
+      filter += key;
+      cursor = 0;
+      scrollOffset = 0;
+    }
+  });
+  prompt.on("cursor", (action) => {
+    const filtered = getFiltered();
+    switch (action) {
+      case "up":
+        cursor = Math.max(0, cursor - 1);
+        break;
+      case "down":
+        cursor = Math.min(Math.max(filtered.length - 1, 0), cursor + 1);
+        break;
+      case "space":
+        if (multi) {
+          const opt = filtered[cursor];
+          if (opt) {
+            if (selected.has(opt.bcp47)) selected.delete(opt.bcp47);
+            else selected.add(opt.bcp47);
+          }
+        }
+        break;
+    }
+    if (!multi) {
+      const opt = getFiltered()[cursor];
+      prompt.value = opt?.bcp47 ?? null;
+    }
+  });
+  prompt.on("finalize", () => {
+    if (prompt.state === "submit") {
+      if (multi) {
+        prompt.value = Array.from(selected);
+      } else {
+        const f = getFiltered();
+        prompt.value = f[cursor]?.bcp47 ?? null;
+      }
+    }
+  });
+  const result = await prompt.prompt();
+  if (isCancel2(result)) return null;
+  return result;
+}
+async function searchSelectLocale(options, message, initialValue) {
+  const result = await runFilterablePrompt({ message, options, multi: false, initialValue });
+  return typeof result === "string" ? result : null;
+}
+async function searchMultiSelectLocales(options, message, initialValues) {
+  const result = await runFilterablePrompt({ message, options, multi: true, initialValues });
+  if (result === null) return null;
+  const picks = result;
+  if (picks.length === 0) {
+    p2.log.warn("At least one target language is required. Please select at least one.");
+    return searchMultiSelectLocales(options, message, initialValues);
+  }
+  return picks;
+}
+// src/utils/branch-select.ts
+import { Prompt as Prompt2, isCancel as isCancel3 } from "@clack/core";
+import chalk3 from "chalk";
+import { execSync as execSync2 } from "child_process";
+var S_BAR2 = "\u2502";
+var S_BAR_END2 = "\u2514";
+var S_ACTIVE2 = "\u25C6";
+var S_SUBMIT2 = "\u25C6";
+var S_CANCEL2 = "\u25A0";
+var S_ERROR2 = "\u25B2";
+var noColor2 = process.env.NO_COLOR === "1" || process.env.FORCE_COLOR === "0";
+var dim2 = (s) => noColor2 ? s : chalk3.gray(s);
+var cyan2 = (s) => noColor2 ? s : chalk3.cyan(s);
+var grn2 = (s) => noColor2 ? s : chalk3.green(s);
+var ylw2 = (s) => noColor2 ? s : chalk3.yellow(s);
+var red2 = (s) => noColor2 ? s : chalk3.red(s);
+var bld2 = (s) => noColor2 ? s : chalk3.bold(s);
+function symbol2(state) {
+  switch (state) {
+    case "submit":
+      return grn2(S_SUBMIT2);
+    case "cancel":
+      return red2(S_CANCEL2);
+    case "error":
+      return ylw2(S_ERROR2);
+    default:
+      return cyan2(S_ACTIVE2);
+  }
+}
+function detectGitBranches(cwd) {
+  const workDir = cwd ?? process.cwd();
+  try {
+    const localOut = execSync2("git branch", { cwd: workDir, stdio: "pipe" }).toString();
+    const localBranches = localOut.split("\n").filter(Boolean).map((b) => b.replace(/^\*?\s*/, "").trim()).filter(Boolean);
+    let remoteBranches = [];
+    try {
+      const remoteOut = execSync2("git branch -r", { cwd: workDir, stdio: "pipe" }).toString();
+      remoteBranches = remoteOut.split("\n").map((b) => b.trim()).filter((b) => b && !b.includes("HEAD")).map((b) => b.replace(/^[^/]+\//, ""));
+    } catch {
+    }
+    const branches = [.../* @__PURE__ */ new Set([...localBranches, ...remoteBranches])].sort();
+    let defaultBranch = "main";
+    try {
+      const ref = execSync2("git symbolic-ref refs/remotes/origin/HEAD", { cwd: workDir, stdio: "pipe" }).toString().trim();
+      defaultBranch = ref.split("/").pop() ?? "main";
+    } catch {
+    }
+    return {
+      branches: branches.length > 0 ? branches : [defaultBranch],
+      defaultBranch
+    };
+  } catch {
+    return { branches: ["main"], defaultBranch: "main" };
+  }
+}
+var INVALID_CHARS = /[\s?^~:[\]\\]/;
+function validateBranchPattern(pattern) {
+  const t = pattern.trim();
+  if (!t) return "Pattern cannot be empty";
+  if (INVALID_CHARS.test(t)) return "Invalid characters \u2014 avoid spaces, ?, ^, ~, :, [, ], \\";
+  if (t.startsWith("/") || t.endsWith("/")) return "Cannot start or end with /";
+  if (t.includes("//")) return "Cannot contain //";
+  return null;
+}
+var MAX_VISIBLE2 = 10;
+function buildItems(branches, defaultBranch, customPatterns) {
+  const items = branches.map((b) => ({
+    value: b,
+    label: b === defaultBranch ? `${b} (default branch)` : b
+  }));
+  for (const pt of customPatterns) {
+    if (!branches.includes(pt)) {
+      items.push({ value: pt, label: pt, isCustom: true });
+    }
+  }
+  return items;
+}
+function filterItems(items, query) {
+  if (!query.trim()) return items;
+  const lower = query.toLowerCase();
+  return items.filter((i) => i.value.toLowerCase().includes(lower));
+}
+function buildList2(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor) {
+  const lines = [];
+  const end = Math.min(filtered.length, scrollOffset + MAX_VISIBLE2);
+  for (let i = scrollOffset; i < end; i++) {
+    const item = filtered[i];
+    const isCursor = i === cursor && !addCursor;
+    const isChecked = selected.has(item.value);
+    const icon = isChecked ? isCursor ? grn2("\u25FC") : "\u25FC" : isCursor ? grn2("\u25FB") : dim2("\u25FB");
+    let label = item.isCustom ? `${item.label} ${dim2("(custom)")}` : item.label;
+    if (isCursor) label = bld2(label);
+    lines.push(`${cyan2(S_BAR2)}  ${icon}  ${label}`);
+  }
+  const trimmed = filter.trim();
+  const allItems = [...filtered];
+  const isNewPattern = trimmed.length > 0 && !allItems.some((i) => i.value === trimmed) && !customPatterns.includes(trimmed);
+  if (isNewPattern) {
+    const err = validateBranchPattern(trimmed);
+    const icon = addCursor ? grn2("\u25FB") : dim2("\u25FB");
+    const label = err ? `${ylw2("+")}  ${dim2(`"${trimmed}" \u2014 ${err}`)}` : `${grn2("+")}  Add "${trimmed}" as branch pattern`;
+    lines.push(`${cyan2(S_BAR2)}  ${icon}  ${label}`);
+  } else if (filtered.length === 0 && trimmed.length === 0) {
+    lines.push(dim2(`${S_BAR2}  No branches detected`));
+  }
+  const hidden = filtered.length - (end - scrollOffset);
+  if (hidden > 0) lines.push(dim2(`${S_BAR2}  ${hidden} more`));
+  if (selected.size > 0) lines.push(dim2(`${S_BAR2}  ${selected.size} selected \u2014 Enter to confirm`));
+  return lines.join("\n");
+}
+async function filterableBranchSelect(params) {
+  const { message, branches, defaultBranch } = params;
+  let filter = "";
+  let cursor = 0;
+  let scrollOffset = 0;
+  let addCursor = false;
+  const customPatterns = [];
+  const selected = new Set(params.initialValues ?? [defaultBranch]);
+  const getItems = () => buildItems(branches, defaultBranch, customPatterns);
+  const getFiltered = () => filterItems(getItems(), filter);
+  const isNewPattern = () => {
+    const t = filter.trim();
+    if (!t) return false;
+    return !getItems().some((i) => i.value === t) && !customPatterns.includes(t);
+  };
+  const clampCursor = (filtered) => {
+    const hasAdd = isNewPattern();
+    const max = filtered.length - 1 + (hasAdd ? 1 : 0);
+    if (cursor > max && !addCursor) cursor = Math.max(0, max);
+    if (!addCursor) {
+      if (cursor < scrollOffset) scrollOffset = cursor;
+      if (cursor >= scrollOffset + MAX_VISIBLE2) scrollOffset = cursor - MAX_VISIBLE2 + 1;
+      if (scrollOffset < 0) scrollOffset = 0;
+    }
+  };
+  const prompt = new Prompt2(
+    {
+      validate() {
+        if (selected.size === 0) return "At least one branch is required.";
+        return void 0;
+      },
+      render() {
+        const filtered = getFiltered();
+        clampCursor(filtered);
+        const hdr = `${dim2(S_BAR2)}
+${symbol2(this.state)}  ${message}
+`;
+        const hint = filter.length > 0 ? filter : dim2("type to filter or add pattern, \u2191\u2193 navigate, space select");
+        switch (this.state) {
+          case "submit": {
+            const summary = selected.size > 0 ? bld2(Array.from(selected).join(", ")) : dim2("none");
+            return `${hdr}${dim2(S_BAR2)}  ${summary}`;
+          }
+          case "cancel":
+            return `${hdr}${dim2(S_BAR2)}`;
+          case "error":
+            return [
+              hdr.trimEnd(),
+              `${ylw2(S_BAR2)}  ${dim2("/")} ${hint}`,
+              buildList2(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor),
+              `${ylw2(S_BAR_END2)}  ${ylw2(this.error)}`,
+              ""
+            ].join("\n");
+          default:
+            return [
+              hdr.trimEnd(),
+              `${cyan2(S_BAR2)}  ${dim2("/")} ${hint}`,
+              buildList2(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor),
+              `${cyan2(S_BAR_END2)}`,
+              ""
+            ].join("\n");
+        }
+      }
+    },
+    false
+  );
+  prompt.on("key", (key) => {
+    if (!key || key === " ") return;
+    const cp = key.codePointAt(0) ?? 0;
+    if (cp === 127 || cp === 8) {
+      filter = filter.slice(0, -1);
+      cursor = 0;
+      scrollOffset = 0;
+      addCursor = false;
+    } else if (cp >= 32 && cp !== 127) {
+      filter += key;
+      cursor = 0;
+      scrollOffset = 0;
+      addCursor = false;
+    }
+  });
+  prompt.on("cursor", (action) => {
+    const filtered = getFiltered();
+    const hasAdd = isNewPattern();
+    switch (action) {
+      case "up":
+        if (addCursor) {
+          addCursor = false;
+          cursor = Math.max(0, filtered.length - 1);
+        } else cursor = Math.max(0, cursor - 1);
+        break;
+      case "down":
+        if (!addCursor && cursor >= filtered.length - 1 && hasAdd) addCursor = true;
+        else if (!addCursor) cursor = Math.min(filtered.length - 1, cursor + 1);
+        break;
+      case "space":
+        if (addCursor) {
+          const t = filter.trim();
+          const err = validateBranchPattern(t);
+          if (!err) {
+            customPatterns.push(t);
+            selected.add(t);
+            filter = "";
+            cursor = 0;
+            scrollOffset = 0;
+            addCursor = false;
+          }
+        } else {
+          const item = filtered[cursor];
+          if (item) {
+            if (selected.has(item.value)) selected.delete(item.value);
+            else selected.add(item.value);
+          }
+        }
+        break;
+    }
+  });
+  prompt.on("finalize", () => {
+    if (prompt.state === "submit") {
+      prompt.value = Array.from(selected);
+    }
+  });
+  const result = await prompt.prompt();
+  if (isCancel3(result)) return null;
+  return result;
+}
+// src/utils/project-create.ts
+function buildLocaleOptions(locales) {
+  return locales.map((l) => ({
+    bcp47: l.code,
+    label: `${l.name} \u2014 ${l.code}`
+  }));
+}
+function buildLanguageOptions(locales) {
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const l of locales) {
+    const family = l.code.split("-")[0].toLowerCase();
+    const opt = { bcp47: l.code, label: `${l.name} \u2014 ${l.code}` };
+    const existing = byFamily.get(family);
+    if (!existing || l.code.length < existing.bcp47.length) {
+      byFamily.set(family, opt);
+    }
+  }
+  return Array.from(byFamily.values());
+}
+async function runProjectCreate(params) {
+  const { api, userToken, organizationId, repoCanonical } = params;
+  const projectName = (params.defaultName ?? "my-project").trim();
+  p3.log.success(`Project: ${chalk4.bold(projectName)}`);
+  let rawLocales;
+  try {
+    rawLocales = await api.listLocales(userToken);
+  } catch {
+    p3.log.error("Failed to fetch supported locales. Check your connection and try again.");
+    return null;
+  }
+  const languageOptions = buildLanguageOptions(rawLocales);
+  const localeOptions = buildLocaleOptions(rawLocales);
+  const sourceLocale = await searchSelectLocale(
+    languageOptions,
+    "Source language (the language your code is written in)",
+    params.defaultSourceLocale ?? "en"
+  );
+  if (sourceLocale === null) return null;
+  const targetOptions = localeOptions.filter((opt) => opt.bcp47 !== sourceLocale);
+  const targetLocales = await searchMultiSelectLocales(
+    targetOptions,
+    "Target languages (languages to translate into)"
+  );
+  if (targetLocales === null) return null;
+  if (targetLocales.length === 0) {
+    p3.log.warn("No target languages selected \u2014 you can add them later from the dashboard.");
+  }
+  const detected = detectGitBranches();
+  const initialBranches = params.defaultBranches?.length ? params.defaultBranches : [detected.defaultBranch];
+  let targetBranches = [];
+  {
+    let initial = initialBranches;
+    while (targetBranches.length === 0) {
+      const result = await filterableBranchSelect({
+        message: "Target branches (translations will run when you push to these)",
+        branches: detected.branches,
+        defaultBranch: detected.defaultBranch,
+        initialValues: initial
+      });
+      if (result === null) return null;
+      if (result.length === 0) {
+        p3.log.warn("At least one branch is required. Please select at least one.");
+        initial = [detected.defaultBranch];
+      } else {
+        targetBranches = result;
+      }
+    }
+  }
+  try {
+    const result = await api.createProject(userToken, {
+      organizationId,
+      name: projectName,
+      sourceLocale,
+      targetLocales,
+      targetBranches,
+      translationTriggers: ["push"],
+      scopePaths: [],
+      repoCanonical
+    });
+    p3.log.success(`Project ${chalk4.bold(result.projectName)} created!`);
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    p3.log.error(`Failed to create project: ${message}`);
+    return null;
+  }
+}
+// src/utils/workspace.ts
+import * as p4 from "@clack/prompts";
+import chalk5 from "chalk";
+async function selectWorkspace(result) {
+  const { workspaces, canCreateWorkspace } = result;
+  if (workspaces.length === 0) {
+    return { action: "create" };
+  }
+  const options = workspaces.map((ws) => ({
+    value: ws.id,
+    label: ws.name,
+    hint: [
+      ws.projectCount > 0 ? `${ws.projectCount} project${ws.projectCount !== 1 ? "s" : ""}` : "",
+      ws.connectionLabel ? `GitHub: ${ws.connectionLabel}` : ""
+    ].filter(Boolean).join(" \xB7 ") || void 0
+  }));
+  if (canCreateWorkspace) {
+    options.push({ value: "create", label: "Create new workspace" });
+  }
+  const selected = await p4.select({
+    message: "Select workspace",
+    options
+  });
+  if (p4.isCancel(selected)) {
+    return { action: "cancelled" };
+  }
+  if (selected === "create") {
+    return { action: "create" };
+  }
+  const workspace = workspaces.find((ws) => ws.id === selected);
+  if (!workspace) {
+    return { action: "cancelled" };
+  }
+  return { action: "use", workspace };
+}
 // src/commands/init.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
+loadEnv();
 var SUBSCRIPTION_SETTINGS_PATH = "/dashboard/workspace/settings?tab=subscription";
-function parseTargetLocales(value) {
-  if (!value) return void 0;
-  const locales = value.split(",").map((locale) => locale.trim()).filter(Boolean);
-  return locales.length > 0 ? locales : void 0;
-}
 async function sleep(ms) {
   await new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-async function tryOpenBrowser(url) {
+async function tryOpenBrowser2(url) {
   if (!process.stdout.isTTY || process.env.CI === "true") {
     return false;
   }
@@ -403,7 +1501,7 @@ async function tryOpenBrowser(url) {
   }
   return await new Promise((resolve2) => {
     try {
-      const child = spawn(command, args, {
+      const child = spawn2(command, args, {
         detached: true,
         stdio: "ignore",
         windowsHide: true
@@ -438,132 +1536,555 @@ function getSubscriptionSettingsUrl(apiUrl) {
   return new URL(SUBSCRIPTION_SETTINGS_PATH, apiUrl).toString();
 }
 function printPlanLimitMessage(apiUrl, message) {
-  p.log.error(`You are over your plan limits.
+  p5.log.error(`You are over your plan limits.
    ${message}`);
-  p.log.info(`Manage subscription: ${getSubscriptionSettingsUrl(apiUrl)}`);
+  p5.log.info(`Manage subscription: ${getSubscriptionSettingsUrl(apiUrl)}`);
 }
-function printNextSteps(projectName, organizationName) {
-  p.log.info(`Project:   ${chalk.bold(projectName)}`);
-  p.log.info(`Workspace: ${chalk.bold(organizationName)}`);
-  p.log.info("");
-  p.log.info("Next steps:");
-  p.log.info(`  1. Add ${chalk.cyan("@vocoder/unplugin")} to your build config`);
-  p.log.info(`  2. Wrap translatable strings with ${chalk.green("<T>")}...${chalk.green("</T>")}`);
-  p.log.info("  3. Push to trigger extraction + translation");
+function runScaffold(params) {
+  const { projectName, organizationName, sourceLocale, translationTriggers } = params;
+  p5.log.info(`Project:   ${chalk6.bold(projectName)}`);
+  p5.log.info(`Workspace: ${chalk6.bold(organizationName)}`);
+  const detection = detectLocalEcosystem();
+  if (detection.ecosystem) {
+    const frameworkLabel = detection.framework ?? detection.ecosystem;
+    const pmLabel = detection.packageManager;
+    p5.log.info(`Detected:  ${chalk6.bold(frameworkLabel)} (${pmLabel})`);
+  }
+  const packagesToInstall = getPackagesToInstall(detection);
+  if (packagesToInstall.length > 0) {
+    const installCmd = buildInstallCommand(detection.packageManager, packagesToInstall);
+    p5.log.info("");
+    const installSpinner = p5.spinner();
+    installSpinner.start(`Installing ${packagesToInstall.join(", ")}...`);
+    try {
+      execSync3(installCmd, { stdio: "pipe", cwd: process.cwd() });
+      installSpinner.stop(`Installed ${packagesToInstall.join(", ")}`);
+    } catch {
+      installSpinner.stop("Package installation failed");
+      p5.log.warn(`Run manually: ${chalk6.cyan(installCmd)}`);
+    }
+  } else if (detection.ecosystem) {
+    p5.log.info(`Packages:  ${chalk6.green("already installed")}`);
+  }
+  const snippets = getSetupSnippets({
+    framework: detection.framework,
+    ecosystem: detection.ecosystem,
+    sourceLocale,
+    translationTriggers
+  });
+  let stepNum = 1;
+  if (snippets.pluginStep) {
+    p5.log.message("");
+    p5.log.step(`${chalk6.bold(`Step ${stepNum}:`)} Add the plugin to ${chalk6.cyan(snippets.pluginStep.file)}`);
+    printCodeBlock(snippets.pluginStep.code);
+    stepNum++;
+  }
+  if (snippets.providerStep) {
+    p5.log.step(`${chalk6.bold(`Step ${stepNum}:`)} Add the provider to ${chalk6.cyan(snippets.providerStep.file)}`);
+    printCodeBlock(snippets.providerStep.code);
+    stepNum++;
+  }
+  p5.log.step(`${chalk6.bold(`Step ${stepNum}:`)} Wrap translatable strings`);
+  printCodeBlock(snippets.wrapStep.code);
+  p5.log.message("");
+  for (const line of snippets.whatsNext.split("\n")) {
+    p5.log.success(line);
+  }
+}
+function printMcpSetup(apiKey) {
+  const addCommand = `claude mcp add --scope project --transport stdio \\
+  --env VOCODER_API_KEY=${apiKey} \\
+  vocoder -- npx -y @vocoder/mcp`;
+  const teamConfig = JSON.stringify(
+    {
+      mcpServers: {
+        vocoder: {
+          type: "stdio",
+          command: "npx",
+          args: ["-y", "@vocoder/mcp"],
+          env: { VOCODER_API_KEY: "${env:VOCODER_API_KEY}" }
+        }
+      }
+    },
+    null,
+    2
+  );
+  p5.log.message("");
+  p5.log.message(chalk6.bold("Use Vocoder with Claude Code"));
+  p5.log.message("Run this to add the MCP server to your project:");
+  p5.log.message("");
+  printCodeBlock(addCommand);
+  p5.log.message("");
+  p5.log.message("To share with your team, commit " + chalk6.cyan(".mcp.json") + " with an env var reference");
+  p5.log.message("so each developer supplies their own key:");
+  p5.log.message("");
+  printCodeBlock(teamConfig);
+  p5.log.message("");
+  p5.log.message(chalk6.gray("Setup instructions: https://vocoder.app/docs/mcp"));
+}
+function printCodeBlock(code) {
+  const lines = code.split("\n");
+  const maxLen = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  const bar = chalk6.gray("\u2502");
+  const pad = (s) => s + " ".repeat(maxLen - s.length);
+  process.stdout.write(`${chalk6.gray("\u2502")}
+`);
+  process.stdout.write(`${chalk6.gray("\u2502")}  ${chalk6.gray("\u250C" + "\u2500".repeat(maxLen + 2) + "\u2510")}
+`);
+  for (const line of lines) {
+    process.stdout.write(`${chalk6.gray("\u2502")}  ${bar} ${pad(line)} ${bar}
+`);
+  }
+  process.stdout.write(`${chalk6.gray("\u2502")}  ${chalk6.gray("\u2514" + "\u2500".repeat(maxLen + 2) + "\u2518")}
+`);
+}
+async function verifyStoredToken(api, token) {
+  try {
+    return await api.getCliUserInfo(token);
+  } catch {
+    clearAuthData();
+    return null;
+  }
+}
+async function runAuthFlow(api, options, reauth = false, repoCanonical) {
+  let server = null;
+  if (!options.ci) {
+    try {
+      server = await startCallbackServer();
+    } catch {
+    }
+  }
+  const session = await api.startCliAuthSession(server?.port, repoCanonical);
+  const browserUrl = reauth ? session.verificationUrl : session.installUrl ?? session.verificationUrl;
+  const expiresAt = new Date(session.expiresAt).getTime();
+  if (options.ci) {
+    process.stdout.write(`VOCODER_AUTH_URL: ${browserUrl}
+`);
+    process.stdout.write(`VOCODER_SESSION_ID: ${session.sessionId}
+`);
+  } else if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
+    if (reauth) {
+      if (!options.yes) {
+        const shouldOpen = await p5.confirm({ message: "Open your browser to sign in again?" });
+        if (p5.isCancel(shouldOpen)) {
+          server?.close();
+          p5.cancel("Setup cancelled.");
+          return null;
+        }
+        if (!shouldOpen) {
+          p5.log.info("Open the URL above manually in your browser to continue.");
+        } else {
+          const opened = await tryOpenBrowser2(browserUrl);
+          if (!opened) {
+            p5.note(browserUrl, "Sign In");
+            p5.log.info("Open the URL above manually to continue.");
+          }
+        }
+      } else {
+        await tryOpenBrowser2(browserUrl);
+      }
+    } else {
+      let isLinkFlow = false;
+      if (!options.yes) {
+        const connectChoice = await p5.select({
+          message: "Vocoder needs to be installed on your GitHub account to get started",
+          options: [
+            { value: "install", label: "Install GitHub App", hint: "recommended" },
+            { value: "link", label: "Already installed? Link your account" }
+          ]
+        });
+        if (p5.isCancel(connectChoice)) {
+          server?.close();
+          p5.cancel("Setup cancelled.");
+          return null;
+        }
+        isLinkFlow = connectChoice === "link";
+      }
+      let urlToOpen = browserUrl;
+      if (isLinkFlow) {
+        try {
+          const linkSession = await api.startCliGitHubLinkSession(
+            session.sessionId,
+            server?.port
+          );
+          urlToOpen = linkSession.oauthUrl;
+        } catch {
+          urlToOpen = browserUrl;
+        }
+      }
+      const opened = await tryOpenBrowser2(urlToOpen);
+      if (!opened) {
+        p5.log.warn("Could not open your browser automatically.");
+        p5.note(urlToOpen, "GitHub");
+        p5.log.info("Open the URL above to continue.");
+      }
+    }
+  }
+  const authSpinner = p5.spinner();
+  authSpinner.start("Waiting for GitHub authorization...");
+  let rawToken = null;
+  let callbackOrganizationId;
+  let callbackDiscoveryReady = false;
+  if (server) {
+    try {
+      const deadline = Math.min(expiresAt, Date.now() + 10 * 60 * 1e3);
+      const timeoutMs = deadline - Date.now();
+      const params = await Promise.race([
+        server.waitForCallback(),
+        new Promise((resolve2) => setTimeout(() => resolve2(null), timeoutMs))
+      ]);
+      if (params && typeof params.token === "string") {
+        rawToken = params.token;
+        if (typeof params.organizationId === "string" && params.organizationId) {
+          callbackOrganizationId = params.organizationId;
+        }
+        if (params.discovery_ready === "1") {
+          callbackDiscoveryReady = true;
+        }
+      }
+    } catch {
+    } finally {
+      server.close();
+    }
+  }
+  if (!rawToken) {
+    while (Date.now() < expiresAt) {
+      const result = await api.pollCliAuthSession(session.sessionId);
+      if (result.status === "complete") {
+        rawToken = result.token;
+        if (result.organizationId) {
+          callbackOrganizationId = result.organizationId;
+        }
+        break;
+      }
+      if (result.status === "failed") {
+        authSpinner.stop();
+        p5.log.error(result.reason);
+        return null;
+      }
+      await sleep(2e3);
+    }
+  }
+  if (!rawToken) {
+    authSpinner.stop();
+    p5.log.error("The authentication link expired. Run `vocoder init` again.");
+    return null;
+  }
+  const userInfo = await api.getCliUserInfo(rawToken);
+  authSpinner.stop();
+  p5.log.success(`Authenticated as ${chalk6.bold(userInfo.email)}`);
+  return { token: rawToken, ...userInfo, organizationId: callbackOrganizationId, discoveryReady: callbackDiscoveryReady };
 }
 async function init(options = {}) {
   const apiUrl = options.apiUrl || process.env.VOCODER_API_URL || "https://vocoder.app";
-  p.intro("Vocoder Setup");
-  const spinner4 = p.spinner();
+  p5.intro("Vocoder Setup");
   try {
     const gitContext = resolveGitContext();
     const identity = gitContext.identity;
     if (gitContext.warnings.length > 0) {
       for (const warning of gitContext.warnings) {
-        p.log.warn(warning);
+        p5.log.warn(warning);
       }
     }
     if (identity) {
-      spinner4.start("Checking for existing project...");
-      const api2 = new VocoderAPI({ apiUrl, apiKey: "" });
-      const existing = await api2.lookupProjectByRepo({
+      const anonApi = new VocoderAPI({ apiUrl, apiKey: "" });
+      const existing = await anonApi.lookupProjectByRepo({
         repoCanonical: identity.repoCanonical,
         scopePath: identity.repoScopePath
       });
       if (existing) {
-        spinner4.stop("Found existing project!");
-        p.outro("Vocoder is already set up for this repository.");
-        printNextSteps(existing.projectName, existing.organizationName);
+        runScaffold({
+          projectName: existing.projectName,
+          organizationName: existing.organizationName,
+          sourceLocale: existing.sourceLocale ?? "en",
+          translationTriggers: existing.translationTriggers ?? ["push"]
+        });
+        p5.outro("Vocoder is already set up for this repository.");
         return 0;
       }
-      spinner4.stop("No existing project found for this repo.");
     }
-    spinner4.start("Creating setup session");
     const api = new VocoderAPI({ apiUrl, apiKey: "" });
-    const start = await api.startInitSession({
-      projectName: options.projectName,
-      sourceLocale: options.sourceLocale,
-      targetLocales: parseTargetLocales(options.targetLocales),
-      ...identity?.repoCanonical ? { repoCanonical: identity.repoCanonical } : {},
-      ...identity ? { repoScopePath: identity.repoScopePath } : {}
-    });
-    spinner4.stop("Setup session created");
-    const verificationUrlString = start.verificationUrl;
-    p.log.info("Create a project in your browser to continue.");
-    p.note(verificationUrlString, "Setup URL");
-    if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
-      const shouldOpen = options.yes ? true : await p.confirm({ message: "Open this URL in your browser?" });
-      if (p.isCancel(shouldOpen)) {
-        p.cancel("Setup cancelled.");
-        return 1;
+    let userToken;
+    let userEmail;
+    let userName;
+    let authOrganizationId;
+    let authDiscoveryReady = false;
+    const stored = readAuthData();
+    if (stored && stored.apiUrl === apiUrl) {
+      const verified = await verifyStoredToken(api, stored.token);
+      if (verified) {
+        p5.log.success(`Authenticated as ${chalk6.bold(verified.email)}`);
+        userToken = stored.token;
+        userEmail = verified.email;
+        userName = verified.name;
+      } else {
+        p5.log.warn("Stored credentials expired \u2014 signing in again");
+        const authResult = await runAuthFlow(
+          api,
+          options,
+          /* reauth */
+          true
+        );
+        if (!authResult) return 1;
+        userToken = authResult.token;
+        userEmail = authResult.email;
+        userName = authResult.name;
+        authOrganizationId = authResult.organizationId;
+        authDiscoveryReady = authResult.discoveryReady ?? false;
+        writeAuthData({
+          token: userToken,
+          apiUrl,
+          userId: authResult.userId,
+          email: userEmail,
+          name: userName,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
       }
-      if (shouldOpen) {
-        const opened = await tryOpenBrowser(verificationUrlString);
-        if (opened) {
-          p.log.info("Opened your browser.");
+    } else {
+      const authResult = await runAuthFlow(api, options, false, identity?.repoCanonical);
+      if (!authResult) return 1;
+      userToken = authResult.token;
+      userEmail = authResult.email;
+      userName = authResult.name;
+      authOrganizationId = authResult.organizationId;
+      writeAuthData({
+        token: userToken,
+        apiUrl,
+        userId: authResult.userId,
+        email: userEmail,
+        name: userName,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    let selectedWorkspaceId;
+    let selectedWorkspaceName;
+    if (authOrganizationId) {
+      const workspaceData = await api.listWorkspaces(userToken);
+      const ws = workspaceData.workspaces.find((w) => w.id === authOrganizationId);
+      selectedWorkspaceId = authOrganizationId;
+      selectedWorkspaceName = ws?.name ?? userEmail;
+      p5.log.success(`Connected as ${chalk6.bold(userEmail)} \u2014 workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+    } else {
+      const discoveryResult = await api.getCliGitHubDiscovery(userToken).catch(() => null);
+      const cachedInstallations = discoveryResult?.installations ?? [];
+      if (cachedInstallations.length > 0) {
+        if (identity?.repoCanonical) {
+          const repoOwner = identity.repoCanonical.split(":")[1]?.split("/")[0]?.toLowerCase();
+          if (repoOwner) {
+            const hasMatchingAccount = cachedInstallations.some(
+              (i) => i.accountLogin.toLowerCase() === repoOwner
+            );
+            if (!hasMatchingAccount) {
+              p5.log.warn(
+                `None of your GitHub App installations belong to "${repoOwner}", the account that owns this repository.
+  The project will be created but translations won't trigger automatically.
+  To fix: install the Vocoder GitHub App on "${repoOwner}" instead.`
+              );
+            }
+          }
+        }
+        const validInstallations = cachedInstallations.filter(
+          (i) => !i.isSuspended && !i.conflictLabel
+        );
+        let selectedInstallationId = null;
+        if (validInstallations.length === 1 && cachedInstallations.length === 1) {
+          selectedInstallationId = validInstallations[0].installationId;
         } else {
-          p.log.info("Could not open a browser automatically. Use the URL above.");
+          selectedInstallationId = await selectGitHubInstallation(
+            cachedInstallations.map((inst) => ({
+              installationId: inst.installationId,
+              accountLogin: inst.accountLogin,
+              accountType: inst.accountType,
+              isSuspended: inst.isSuspended,
+              conflictLabel: inst.conflictLabel
+            })),
+            false
+          );
         }
-      }
-    }
-    const expiresAt = new Date(start.expiresAt).getTime();
-    spinner4.start("Waiting for setup to complete...");
-    while (Date.now() < expiresAt) {
-      const status = await api.getInitSessionStatus({
-        sessionId: start.sessionId,
-        pollToken: start.poll.token
-      });
-      if (status.status === "pending") {
-        const pendingMessage = status.message?.trim();
-        if (pendingMessage) {
-          spinner4.message(`Waiting for setup to complete... (${pendingMessage})`);
+        if (selectedInstallationId === null || selectedInstallationId === "install_new") {
+          p5.cancel("Setup cancelled. Re-run `vocoder init` and choose Install GitHub App.");
+          return 1;
         }
-        await sleep((status.pollIntervalSeconds || start.poll.intervalSeconds) * 1e3);
-        continue;
-      }
-      if (status.status === "failed") {
-        spinner4.stop("Setup failed");
-        if (isPlanLimitFailure(status.message)) {
-          printPlanLimitMessage(apiUrl, status.message);
+        const claimResult = await api.claimCliGitHubInstallation(userToken, {
+          installationId: String(selectedInstallationId),
+          organizationId: null
+        });
+        selectedWorkspaceId = claimResult.organizationId;
+        selectedWorkspaceName = claimResult.organizationName;
+        p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+      } else {
+        const workspaceData = await api.listWorkspaces(userToken);
+        if (workspaceData.workspaces.length === 1 && !workspaceData.canCreateWorkspace) {
+          const ws = workspaceData.workspaces[0];
+          selectedWorkspaceId = ws.id;
+          selectedWorkspaceName = ws.name;
+          p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
         } else {
-          p.log.error(status.message);
+          const workspaceResult = await selectWorkspace(workspaceData);
+          if (workspaceResult.action === "cancelled") {
+            p5.cancel("Setup cancelled.");
+            return 1;
+          }
+          if (workspaceResult.action === "use") {
+            selectedWorkspaceId = workspaceResult.workspace.id;
+            selectedWorkspaceName = workspaceResult.workspace.name;
+            p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+          } else {
+            const connectChoice = await p5.select({
+              message: "Connect your new workspace to GitHub",
+              options: [
+                { value: "install", label: "Install the Vocoder GitHub App" },
+                { value: "link", label: "Link an existing installation" }
+              ]
+            });
+            if (p5.isCancel(connectChoice)) {
+              p5.cancel("Setup cancelled.");
+              return 1;
+            }
+            if (connectChoice === "install") {
+              const connectResult = await runGitHubInstallFlow({
+                api,
+                userToken,
+                yes: options.yes
+              });
+              if (!connectResult) {
+                p5.log.error("GitHub App installation did not complete. Run `vocoder init` again.");
+                return 1;
+              }
+              selectedWorkspaceId = connectResult.organizationId;
+              selectedWorkspaceName = connectResult.organizationName;
+              p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+            } else {
+              const installations = await runGitHubDiscoveryFlow({
+                api,
+                userToken,
+                yes: options.yes
+              });
+              if (!installations) return 1;
+              if (installations.length === 0) {
+                p5.log.warn("No GitHub installations found. Install the Vocoder GitHub App first.");
+                const installNow = await p5.confirm({ message: "Open GitHub to install the App?" });
+                if (p5.isCancel(installNow) || !installNow) return 1;
+                const connectResult = await runGitHubInstallFlow({
+                  api,
+                  userToken,
+                  yes: options.yes
+                });
+                if (!connectResult) return 1;
+                selectedWorkspaceId = connectResult.organizationId;
+                selectedWorkspaceName = connectResult.organizationName;
+              } else {
+                const selectedInstallationId = await selectGitHubInstallation(
+                  installations.map((inst) => ({
+                    installationId: inst.installationId,
+                    accountLogin: inst.accountLogin,
+                    accountType: inst.accountType,
+                    isSuspended: inst.isSuspended,
+                    conflictLabel: inst.conflictLabel
+                  })),
+                  true
+                );
+                if (selectedInstallationId === null) {
+                  p5.cancel("Setup cancelled.");
+                  return 1;
+                }
+                if (selectedInstallationId === "install_new") {
+                  const connectResult = await runGitHubInstallFlow({
+                    api,
+                    userToken,
+                    yes: options.yes
+                  });
+                  if (!connectResult) return 1;
+                  selectedWorkspaceId = connectResult.organizationId;
+                  selectedWorkspaceName = connectResult.organizationName;
+                } else {
+                  const claimResult = await api.claimCliGitHubInstallation(userToken, {
+                    installationId: String(selectedInstallationId),
+                    organizationId: null
+                  });
+                  selectedWorkspaceId = claimResult.organizationId;
+                  selectedWorkspaceName = claimResult.organizationName;
+                }
+              }
+              p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+            }
+          }
         }
-        p.cancel("Setup could not be completed.");
-        return 1;
-      }
-      if (status.status === "completed") {
-        spinner4.stop("Setup complete!");
-        const { credentials } = status;
-        p.outro("Vocoder initialized successfully!");
-        printNextSteps(credentials.projectName, credentials.organizationName);
-        return 0;
       }
     }
-    spinner4.stop("Setup timed out");
-    p.log.error("Setup timed out. Run `vocoder init` again.");
-    p.cancel("Setup could not be completed.");
-    return 1;
+    const projectResult = await runProjectCreate({
+      api,
+      userToken,
+      organizationId: selectedWorkspaceId,
+      defaultName: identity?.repoCanonical ? identity.repoCanonical.split("/").pop() : void 0,
+      defaultSourceLocale: "en",
+      repoCanonical: identity?.repoCanonical,
+      defaultBranches: ["main"]
+    });
+    if (!projectResult) {
+      p5.log.error("Project creation failed. Run `vocoder init` again.");
+      return 1;
+    }
+    if (!projectResult.repositoryBound && identity?.repoCanonical) {
+      p5.log.warn(
+        `This repository isn't accessible to your GitHub App installation.
+Translations won't run automatically until you grant access.
+  To fix: go to your GitHub App installation settings and add this
+  repository to the allowed list, or switch to "All repositories".
+` + (projectResult.configureUrl ? `
+  ${chalk6.dim(projectResult.configureUrl)}
+` : "")
+      );
+    }
+    runScaffold({
+      projectName: projectResult.projectName,
+      organizationName: selectedWorkspaceName,
+      sourceLocale: projectResult.sourceLocale,
+      translationTriggers: projectResult.translationTriggers
+    });
+    printMcpSetup(projectResult.apiKey);
+    p5.outro("You're all set.");
+    return 0;
   } catch (error) {
-    spinner4.stop();
     if (error instanceof Error) {
       if (isPlanLimitFailure(error.message)) {
         printPlanLimitMessage(apiUrl, error.message);
         return 1;
       }
-      p.log.error(`Error: ${error.message}`);
+      p5.log.error(`Error: ${error.message}`);
     } else {
-      p.log.error("Unknown setup error");
+      p5.log.error("Unknown setup error");
     }
     return 1;
   }
 }
+// src/commands/logout.ts
+import * as p6 from "@clack/prompts";
+async function logout(options = {}) {
+  const stored = readAuthData();
+  if (!stored) {
+    p6.log.info("Not currently authenticated.");
+    return 0;
+  }
+  const apiUrl = options.apiUrl ?? stored.apiUrl ?? "https://vocoder.app";
+  const api = new VocoderAPI({ apiUrl, apiKey: "" });
+  try {
+    await api.revokeCliToken(stored.token);
+  } catch {
+  }
+  clearAuthData();
+  p6.log.success(`Logged out (was ${stored.email})`);
+  return 0;
+}
 // src/commands/sync.ts
-import * as p2 from "@clack/prompts";
-import { createHash as createHash2, randomUUID } from "crypto";
+import * as p7 from "@clack/prompts";
+import { createHash, randomUUID } from "crypto";
 // src/utils/branch.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 var REGEX_SPECIAL_CHARS = /[.+?^${}()|[\]\\]/g;
 function escapeRegexChar(value) {
   return value.replace(REGEX_SPECIAL_CHARS, "\\$&");
@@ -585,7 +2106,7 @@ function detectBranch(override) {
     return envBranch;
   }
   try {
-    const branch = execSync2("git rev-parse --abbrev-ref HEAD", {
+    const branch = execSync4("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
@@ -629,12 +2150,12 @@ function matchBranchPattern(branch, pattern) {
 }
 // src/commands/sync.ts
-import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 // src/utils/config.ts
-import chalk2 from "chalk";
-import { config as loadEnv } from "dotenv";
-loadEnv();
+import chalk7 from "chalk";
+import { config as loadEnv2 } from "dotenv";
+loadEnv2();
 function validateLocalConfig(config) {
   if (!config.apiKey || config.apiKey.length === 0) {
     throw new Error("VOCODER_API_KEY is required. Set it in your .env file.");
@@ -715,317 +2236,45 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
       configSources.maxWaitMs = "environment";
     }
   }
-  let noFallback = false;
-  if (typeof cliOptions.noFallback === "boolean") {
-    noFallback = cliOptions.noFallback;
-    configSources.noFallback = "CLI flag";
-  } else if (envSyncNoFallback) {
-    noFallback = ["1", "true", "yes", "on"].includes(envSyncNoFallback.toLowerCase());
-    configSources.noFallback = "environment";
-  }
-  if (verbose) {
-    console.log(chalk2.dim("\n   Configuration sources:"));
-    console.log(chalk2.dim(`     Include patterns: ${configSources.extractionPattern}`));
-    if (excludePattern.length > 0) {
-      console.log(chalk2.dim(`     Exclude patterns: ${configSources.excludePattern}`));
-    }
-    console.log(chalk2.dim(`     API key: ${configSources.apiKey}`));
-    console.log(chalk2.dim(`     API URL: ${configSources.apiUrl}
-`));
-    console.log(chalk2.dim(`     Sync mode: ${configSources.mode}`));
-    if (maxWaitMs) {
-      console.log(chalk2.dim(`     Max wait: ${configSources.maxWaitMs}`));
-    }
-    console.log(chalk2.dim(`     No fallback: ${configSources.noFallback}
-`));
-  }
-  return {
-    extractionPattern,
-    excludePattern,
-    apiKey,
-    apiUrl,
-    mode,
-    maxWaitMs,
-    noFallback,
-    configSources
-  };
-}
-// src/utils/extract.ts
-import { createHash } from "crypto";
-import { readFileSync } from "fs";
-import { parse } from "@babel/parser";
-import babelTraverse from "@babel/traverse";
-import { glob } from "glob";
-import { relative as pathRelative } from "path";
-var traverse = babelTraverse.default || babelTraverse;
-var StringExtractor = class {
-  /**
-   * Extract strings from all files matching the pattern(s)
-   *
-   * @param pattern - Glob pattern(s) to include
-   * @param projectRoot - Project root directory
-   * @param excludePattern - Glob pattern(s) to exclude (optional)
-   */
-  async extractFromProject(pattern, projectRoot = process.cwd(), excludePattern) {
-    const includePatterns = Array.isArray(pattern) ? pattern : [pattern];
-    const defaultIgnore = ["**/node_modules/**", "**/.next/**", "**/dist/**", "**/build/**"];
-    const ignorePatterns = excludePattern ? [...defaultIgnore, ...Array.isArray(excludePattern) ? excludePattern : [excludePattern]] : defaultIgnore;
-    const allFiles = /* @__PURE__ */ new Set();
-    for (const includePattern of includePatterns) {
-      const files = await glob(includePattern, {
-        cwd: projectRoot,
-        absolute: true,
-        ignore: ignorePatterns
-      });
-      files.forEach((file) => allFiles.add(file));
-    }
-    const allStrings = [];
-    const sortedFiles = Array.from(allFiles).sort();
-    for (const file of sortedFiles) {
-      try {
-        const strings = await this.extractFromFile(file, projectRoot);
-        allStrings.push(...strings);
-      } catch (error) {
-        console.warn(`Warning: Failed to extract from ${file}:`, error);
-      }
-    }
-    const unique = this.deduplicateStrings(allStrings);
-    return unique;
-  }
-  /**
-   * Extract strings from a single file
-   */
-  async extractFromFile(filePath, projectRoot) {
-    const code = readFileSync(filePath, "utf-8");
-    const strings = [];
-    const relativeFilePath = pathRelative(projectRoot, filePath).split("\\").join("/");
-    try {
-      const ast = parse(code, {
-        sourceType: "module",
-        plugins: ["jsx", "typescript"]
-      });
-      const vocoderImports = /* @__PURE__ */ new Map();
-      const tFunctionNames = /* @__PURE__ */ new Set();
-      traverse(ast, {
-        // Track imports of <T> component and t function
-        ImportDeclaration: (path) => {
-          const source = path.node.source.value;
-          if (source === "@vocoder/react") {
-            path.node.specifiers.forEach((spec) => {
-              if (spec.type === "ImportSpecifier") {
-                const imported = spec.imported.type === "Identifier" ? spec.imported.name : null;
-                const local = spec.local.name;
-                if (imported === "T") {
-                  vocoderImports.set(local, "T");
-                }
-                if (imported === "t") {
-                  tFunctionNames.add(local);
-                }
-                if (imported === "useVocoder") {
-                }
-              }
-            });
-          }
-        },
-        // Track destructured 't' from useVocoder hook
-        VariableDeclarator: (path) => {
-          const init2 = path.node.init;
-          if (init2 && init2.type === "CallExpression" && init2.callee.type === "Identifier" && init2.callee.name === "useVocoder" && path.node.id.type === "ObjectPattern") {
-            path.node.id.properties.forEach((prop) => {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "t") {
-                const localName = prop.value.type === "Identifier" ? prop.value.name : "t";
-                tFunctionNames.add(localName);
-              }
-            });
-          }
-        },
-        // Extract from t() function calls
-        CallExpression: (path) => {
-          const callee = path.node.callee;
-          const isTFunction = callee.type === "Identifier" && tFunctionNames.has(callee.name);
-          if (!isTFunction) return;
-          const firstArg = path.node.arguments[0];
-          if (!firstArg) return;
-          let text = null;
-          if (firstArg.type === "StringLiteral") {
-            text = firstArg.value;
-          } else if (firstArg.type === "TemplateLiteral") {
-            text = this.extractTemplateText(firstArg);
-          }
-          if (!text || text.trim().length === 0) return;
-          const secondArg = path.node.arguments[1];
-          let context;
-          let formality;
-          let explicitKey;
-          if (secondArg && secondArg.type === "ObjectExpression") {
-            secondArg.properties.forEach((prop) => {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
-                if (prop.key.name === "context" && prop.value.type === "StringLiteral") {
-                  context = prop.value.value;
-                }
-                if (prop.key.name === "formality" && prop.value.type === "StringLiteral") {
-                  formality = prop.value.value;
-                }
-                if (prop.key.name === "id" && prop.value.type === "StringLiteral") {
-                  explicitKey = prop.value.value.trim();
-                }
-              }
-            });
-          }
-          const line = path.node.loc?.start.line || 0;
-          const column = path.node.loc?.start.column || 0;
-          const key = explicitKey && explicitKey.length > 0 ? explicitKey : this.generateStableKey({
-            filePath: relativeFilePath,
-            kind: "t-call",
-            line,
-            column
-          });
-          strings.push({
-            key,
-            text: text.trim(),
-            file: filePath,
-            line,
-            context,
-            formality
-          });
-        },
-        // Extract from JSX elements
-        JSXElement: (path) => {
-          const opening = path.node.openingElement;
-          const tagName = opening.name.type === "JSXIdentifier" ? opening.name.name : null;
-          if (!tagName) return;
-          const isTranslationComponent = vocoderImports.has(tagName);
-          if (!isTranslationComponent) return;
-          const msgAttribute = this.getStringAttribute(opening.attributes, "msg");
-          const text = msgAttribute || this.extractTextContent(path.node.children);
-          if (!text || text.trim().length === 0) return;
-          const id = this.getStringAttribute(opening.attributes, "id");
-          const context = this.getStringAttribute(opening.attributes, "context");
-          const formality = this.getStringAttribute(
-            opening.attributes,
-            "formality"
-          );
-          const line = path.node.loc?.start.line || 0;
-          const column = path.node.loc?.start.column || 0;
-          const key = id && id.trim().length > 0 ? id.trim() : this.generateStableKey({
-            filePath: relativeFilePath,
-            kind: "jsx",
-            line,
-            column
-          });
-          strings.push({
-            key,
-            text: text.trim(),
-            file: filePath,
-            line,
-            context,
-            formality
-          });
-        }
-      });
-    } catch (error) {
-      throw new Error(
-        `Failed to parse ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-    return strings;
-  }
-  /**
-   * Extract text from template literal
-   * Converts template literals like `Hello ${name}` to `Hello {name}`
-   */
-  extractTemplateText(node) {
-    let text = "";
-    for (let i = 0; i < node.quasis.length; i++) {
-      const quasi = node.quasis[i];
-      text += quasi.value.raw;
-      if (i < node.expressions.length) {
-        const expr = node.expressions[i];
-        if (expr.type === "Identifier") {
-          text += `{${expr.name}}`;
-        } else {
-          text += "{value}";
-        }
-      }
-    }
-    return text;
-  }
-  /**
-   * Extract text content from JSX children
-   */
-  extractTextContent(children) {
-    let text = "";
-    for (const child of children) {
-      if (child.type === "JSXText") {
-        text += child.value;
-      } else if (child.type === "JSXExpressionContainer") {
-        const expr = child.expression;
-        if (expr.type === "Identifier") {
-          text += `{${expr.name}}`;
-        } else if (expr.type === "StringLiteral") {
-          text += expr.value;
-        } else if (expr.type === "TemplateLiteral") {
-          text += this.extractTemplateText(expr);
-        }
-      }
-    }
-    return text;
-  }
-  /**
-   * Get string value from JSX attribute
-   * Handles both string literals and template literals
-   */
-  getStringAttribute(attributes, name) {
-    const attr = attributes.find(
-      (a) => a.type === "JSXAttribute" && a.name.name === name
-    );
-    if (!attr || !attr.value) return void 0;
-    if (attr.value.type === "StringLiteral") {
-      return attr.value.value;
-    }
-    if (attr.value.type === "JSXExpressionContainer") {
-      const expr = attr.value.expression;
-      if (expr.type === "TemplateLiteral") {
-        return this.extractTemplateText(expr);
-      }
-      if (expr.type === "StringLiteral") {
-        return expr.value;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Deduplicate strings (keep first occurrence)
-   */
-  deduplicateStrings(strings) {
-    const seen = /* @__PURE__ */ new Map();
-    const unique = [];
-    for (const str of strings) {
-      const dedupeKey = `${str.text}|${str.context || ""}|${str.formality || ""}`;
-      const existingIndex = seen.get(dedupeKey);
-      if (existingIndex === void 0) {
-        seen.set(dedupeKey, unique.length);
-        unique.push(str);
-        continue;
-      }
-      const existing = unique[existingIndex];
-      if (existing && str.key < existing.key) {
-        existing.key = str.key;
-      }
-    }
-    return unique;
-  }
-  generateStableKey(params) {
-    const payload = `${params.filePath}|${params.kind}|${params.line}:${params.column}`;
-    const digest = createHash("sha1").update(payload).digest("hex");
-    return `SK_${digest.slice(0, 24).toUpperCase()}`;
+  let noFallback = false;
+  if (typeof cliOptions.noFallback === "boolean") {
+    noFallback = cliOptions.noFallback;
+    configSources.noFallback = "CLI flag";
+  } else if (envSyncNoFallback) {
+    noFallback = ["1", "true", "yes", "on"].includes(envSyncNoFallback.toLowerCase());
+    configSources.noFallback = "environment";
   }
-};
+  if (verbose) {
+    console.log(chalk7.dim("\n   Configuration sources:"));
+    console.log(chalk7.dim(`     Include patterns: ${configSources.extractionPattern}`));
+    if (excludePattern.length > 0) {
+      console.log(chalk7.dim(`     Exclude patterns: ${configSources.excludePattern}`));
+    }
+    console.log(chalk7.dim(`     API key: ${configSources.apiKey}`));
+    console.log(chalk7.dim(`     API URL: ${configSources.apiUrl}
+`));
+    console.log(chalk7.dim(`     Sync mode: ${configSources.mode}`));
+    if (maxWaitMs) {
+      console.log(chalk7.dim(`     Max wait: ${configSources.maxWaitMs}`));
+    }
+    console.log(chalk7.dim(`     No fallback: ${configSources.noFallback}
+`));
+  }
+  return {
+    extractionPattern,
+    excludePattern,
+    apiKey,
+    apiUrl,
+    mode,
+    maxWaitMs,
+    noFallback,
+    configSources
+  };
+}
 // src/commands/sync.ts
-import chalk3 from "chalk";
-import { join } from "path";
+import chalk8 from "chalk";
+import { join as join2 } from "path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1071,9 +2320,9 @@ function parseTranslations(value) {
 }
 function getCacheFilePath(projectRoot, branch) {
   const slug = branch.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40);
-  const branchHash = createHash2("sha1").update(branch).digest("hex").slice(0, 12);
+  const branchHash = createHash("sha1").update(branch).digest("hex").slice(0, 12);
   const filename = `${slug || "branch"}-${branchHash}.json`;
-  return join(projectRoot, ".vocoder", "cache", "sync", filename);
+  return join2(projectRoot, "node_modules", ".vocoder", "cache", "sync", filename);
 }
 function readLocalSnapshotCache(params) {
   const candidateBranches = params.branch === "main" ? ["main"] : [params.branch, "main"];
@@ -1109,7 +2358,7 @@ function readLocalSnapshotCache(params) {
 }
 function writeLocalSnapshotCache(params) {
   const cacheFilePath = getCacheFilePath(params.projectRoot, params.branch);
-  mkdirSync(join(params.projectRoot, ".vocoder", "cache", "sync"), {
+  mkdirSync2(join2(params.projectRoot, "node_modules", ".vocoder", "cache", "sync"), {
     recursive: true
   });
   const payload = {
@@ -1123,7 +2372,7 @@ function writeLocalSnapshotCache(params) {
     ...params.localeMetadata ? { localeMetadata: params.localeMetadata } : {},
     translations: params.translations
   };
-  writeFileSync(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
+  writeFileSync2(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
   return cacheFilePath;
 }
 function resolveEffectiveModeFromPolicy(params) {
@@ -1278,12 +2527,12 @@ async function fetchApiSnapshot(api, params) {
 async function sync(options = {}) {
   const startTime = Date.now();
   const projectRoot = process.cwd();
-  p2.intro("Vocoder Sync");
-  const spinner4 = p2.spinner();
+  p7.intro("Vocoder Sync");
+  const spinner4 = p7.spinner();
   try {
     spinner4.start("Detecting branch");
     const branch = detectBranch(options.branch);
-    spinner4.stop(`Branch: ${chalk3.cyan(branch)}`);
+    spinner4.stop(`Branch: ${chalk8.cyan(branch)}`);
     spinner4.start("Loading project configuration");
     const mergedConfig = await getMergedConfig(options, options.verbose);
     const localConfig = {
@@ -1308,12 +2557,12 @@ async function sync(options = {}) {
     };
     spinner4.stop("Project configuration loaded");
     if (!options.force && !isTargetBranch(branch, config.targetBranches)) {
-      p2.log.warn(
-        `Skipping translations (${chalk3.cyan(branch)} is not a target branch)`
+      p7.log.warn(
+        `Skipping translations (${chalk8.cyan(branch)} is not a target branch)`
       );
-      p2.log.info(`Target branches: ${config.targetBranches.join(", ")}`);
-      p2.log.info("Use --force to translate anyway");
-      p2.outro("");
+      p7.log.info(`Target branches: ${config.targetBranches.join(", ")}`);
+      p7.log.info("Use --force to translate anyway");
+      p7.outro("");
       return 0;
     }
     const patternsDisplay = Array.isArray(config.extractionPattern) ? config.extractionPattern.join(", ") : config.extractionPattern;
@@ -1326,22 +2575,22 @@ async function sync(options = {}) {
     );
     if (extractedStrings.length === 0) {
       spinner4.stop("No translatable strings found");
-      p2.log.warn("Make sure you are using <T> components from @vocoder/react");
-      p2.outro("");
+      p7.log.warn("Make sure you are wrapping translatable strings with Vocoder");
+      p7.outro("");
       return 0;
     }
     spinner4.stop(
-      `Extracted ${chalk3.cyan(extractedStrings.length)} strings from ${chalk3.cyan(patternsDisplay)}`
+      `Extracted ${chalk8.cyan(extractedStrings.length)} strings from ${chalk8.cyan(patternsDisplay)}`
     );
     if (options.verbose) {
       const sampleLines = extractedStrings.slice(0, 5).map((s) => `  "${s.text}" (${s.file}:${s.line})`);
       if (extractedStrings.length > 5) {
         sampleLines.push(`  ... and ${extractedStrings.length - 5} more`);
       }
-      p2.note(sampleLines.join("\n"), "Sample strings");
+      p7.note(sampleLines.join("\n"), "Sample strings");
     }
     if (options.dryRun) {
-      p2.note(
+      p7.note(
         [
           `Strings: ${extractedStrings.length}`,
           `Branch: ${branch}`,
@@ -1352,19 +2601,19 @@ async function sync(options = {}) {
         ].join("\n"),
         "Dry run - would translate"
       );
-      p2.outro("No API calls made.");
+      p7.outro("No API calls made.");
       return 0;
     }
     const repoIdentity = resolveGitRepositoryIdentity();
     if (!repoIdentity && options.verbose) {
-      p2.log.warn(
+      p7.log.warn(
         "Could not detect git remote origin. Sync will continue without repo metadata."
       );
     }
     const stringEntries = buildStringEntries(extractedStrings);
     const sourceStrings = stringEntries.map((entry) => entry.text);
     if (options.verbose && stringEntries.length !== extractedStrings.length) {
-      p2.log.info(
+      p7.log.info(
         `Deduped ${extractedStrings.length} extracted entries into ${stringEntries.length} unique source strings`
       );
     }
@@ -1380,38 +2629,38 @@ async function sync(options = {}) {
       },
       repoIdentity ?? void 0
     );
-    spinner4.stop(`Submitted to API - Batch ${chalk3.cyan(batchResponse.batchId)}`);
+    spinner4.stop(`Submitted to API - Batch ${chalk8.cyan(batchResponse.batchId)}`);
     const effectiveMode = batchResponse.effectiveMode ?? resolveEffectiveModeFromPolicy({
       branch,
       requestedMode,
       policy: config.syncPolicy
     });
     if (options.verbose) {
-      p2.log.info(`Requested mode: ${requestedMode}`);
-      p2.log.info(`Effective mode: ${effectiveMode}`);
-      p2.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
+      p7.log.info(`Requested mode: ${requestedMode}`);
+      p7.log.info(`Effective mode: ${effectiveMode}`);
+      p7.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
       if (batchResponse.queueStatus) {
-        p2.log.info(`Queue status: ${batchResponse.queueStatus}`);
+        p7.log.info(`Queue status: ${batchResponse.queueStatus}`);
       }
     }
     if (batchResponse.status === "UP_TO_DATE" && batchResponse.noChanges) {
-      p2.log.success("No changes detected - strings are up to date");
+      p7.log.success("No changes detected - strings are up to date");
     }
-    p2.log.info(`New strings: ${chalk3.cyan(batchResponse.newStrings)}`);
+    p7.log.info(`New strings: ${chalk8.cyan(batchResponse.newStrings)}`);
     if (batchResponse.deletedStrings && batchResponse.deletedStrings > 0) {
-      p2.log.info(
-        `Deleted strings: ${chalk3.yellow(batchResponse.deletedStrings)} (archived)`
+      p7.log.info(
+        `Deleted strings: ${chalk8.yellow(batchResponse.deletedStrings)} (archived)`
       );
     }
-    p2.log.info(`Total strings: ${chalk3.cyan(batchResponse.totalStrings)}`);
+    p7.log.info(`Total strings: ${chalk8.cyan(batchResponse.totalStrings)}`);
     if (batchResponse.newStrings === 0) {
-      p2.log.success("No new strings - using existing translations");
+      p7.log.success("No new strings - using existing translations");
     } else {
-      p2.log.info(
+      p7.log.info(
         `Syncing to ${config.targetLocales.length} locales (${config.targetLocales.join(", ")})`
       );
       if (batchResponse.estimatedTime) {
-        p2.log.info(`Estimated time: ~${batchResponse.estimatedTime}s`);
+        p7.log.info(`Estimated time: ~${batchResponse.estimatedTime}s`);
       }
     }
     let artifacts = null;
@@ -1449,7 +2698,7 @@ async function sync(options = {}) {
         if (effectiveMode === "required") {
           throw waitError;
         }
-        p2.log.warn(`Best-effort wait ended early: ${waitError.message}`);
+        p7.log.warn(`Best-effort wait ended early: ${waitError.message}`);
       }
     }
     if (!artifacts) {
@@ -1483,7 +2732,7 @@ async function sync(options = {}) {
           spinner4.stop("Failed to fetch API snapshot");
           if (options.verbose) {
             const message = error instanceof Error ? error.message : "Unknown snapshot fetch error";
-            p2.log.warn(`Snapshot fetch error: ${message}`);
+            p7.log.warn(`Snapshot fetch error: ${message}`);
           }
         }
       }
@@ -1516,1217 +2765,89 @@ async function sync(options = {}) {
         completedAt: artifacts.completedAt ?? (artifacts.source === "fresh" ? (/* @__PURE__ */ new Date()).toISOString() : null)
       });
       if (options.verbose) {
-        p2.log.info(`Cached snapshot: ${cachePath}`);
+        p7.log.info(`Cached snapshot: ${cachePath}`);
       }
     } catch (error) {
       if (options.verbose) {
         const message = error instanceof Error ? error.message : "Unknown cache write error";
-        p2.log.warn(`Failed to write local snapshot cache: ${message}`);
+        p7.log.warn(`Failed to write local snapshot cache: ${message}`);
       }
     }
     if (artifacts.source !== "fresh") {
       const sourceLabel = artifacts.source === "local-cache" ? "local cached snapshot" : "completed API snapshot";
-      p2.log.warn(
+      p7.log.warn(
         `Using ${sourceLabel}. New strings may appear after the background sync completes.`
       );
     }
     const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
-    p2.outro(`Sync complete! (${duration}s)`);
-    p2.log.info("Translations will be injected at build time by @vocoder/unplugin.");
-    p2.log.info("Just use <VocoderProvider> and <T> \u2014 no manual imports needed.");
+    p7.outro(`Sync complete! (${duration}s)`);
+    p7.log.info("Translations will be injected at build time by @vocoder/unplugin.");
+    p7.log.info("Just use <VocoderProvider> and <T> \u2014 no manual imports needed.");
     return 0;
   } catch (error) {
     spinner4.stop();
     if (error instanceof VocoderAPIError && error.syncPolicyError) {
-      p2.log.error(error.syncPolicyError.message);
+      p7.log.error(error.syncPolicyError.message);
       const guidance = getSyncPolicyErrorGuidance(error.syncPolicyError);
       for (const line of guidance) {
-        p2.log.info(line);
+        p7.log.info(line);
       }
       return 1;
     }
     if (error instanceof VocoderAPIError && error.limitError) {
       const { limitError } = error;
-      p2.log.error(limitError.message);
+      p7.log.error(limitError.message);
       const guidance = getLimitErrorGuidance(limitError);
       for (const line of guidance) {
-        p2.log.info(line);
+        p7.log.info(line);
       }
       return 1;
     }
     if (error instanceof Error) {
-      p2.log.error(error.message);
+      p7.log.error(error.message);
       if (error.message.includes("VOCODER_API_KEY")) {
-        p2.log.warn("VOCODER_API_KEY is only needed for `vocoder sync` (CLI push).");
-        p2.log.info("  Create one at: https://vocoder.app/dashboard");
-        p2.log.info('  Then: export VOCODER_API_KEY="vc_..." or add it to .env');
-        p2.log.info("");
-        p2.log.info("  Note: If you use @vocoder/unplugin, `vocoder sync` is optional.");
-        p2.log.info("  Translations are fetched automatically at build time.");
+        p7.log.warn("VOCODER_API_KEY is only needed for `vocoder sync` (CLI push).");
+        p7.log.info("  Create one at: https://vocoder.app/dashboard");
+        p7.log.info('  Then: export VOCODER_API_KEY="vc_..." or add it to .env');
+        p7.log.info("");
+        p7.log.info("  Note: If you use @vocoder/unplugin, `vocoder sync` is optional.");
+        p7.log.info("  Translations are fetched automatically at build time.");
       } else if (error.message.includes("git branch")) {
-        p2.log.warn("Run from a git repository, or use:");
-        p2.log.info("  vocoder sync --branch main");
+        p7.log.warn("Run from a git repository, or use:");
+        p7.log.info("  vocoder sync --branch main");
       }
       if (options.verbose) {
-        p2.log.info(`Full error: ${error.stack ?? error}`);
+        p7.log.info(`Full error: ${error.stack ?? error}`);
       }
     }
     return 1;
   }
 }
-// src/commands/wrap.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { relative as relative2 } from "path";
-import * as p3 from "@clack/prompts";
-import chalk4 from "chalk";
-// src/utils/wrap/analyzer.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { parse as parse2 } from "@babel/parser";
-import babelTraverse2 from "@babel/traverse";
-import { glob as glob2 } from "glob";
-// src/utils/wrap/heuristics.ts
-var URL_REGEX = /^(https?:\/\/|\/\/|mailto:|tel:|ftp:\/\/)/i;
-var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-var FILE_PATH_REGEX = /^(\.{0,2}\/|[a-zA-Z]:\\)/;
-var COLOR_HEX_REGEX = /^#([0-9a-fA-F]{3,8})$/;
-var COLOR_FUNC_REGEX = /^(rgb|rgba|hsl|hsla)\s*\(/i;
-var CAMEL_CASE_REGEX = /^[a-z][a-zA-Z0-9]*$/;
-var PASCAL_CASE_REGEX = /^[A-Z][a-zA-Z0-9]*$/;
-var SCREAMING_SNAKE_REGEX = /^[A-Z][A-Z0-9_]+$/;
-var KEBAB_CASE_REGEX = /^[a-z][a-z0-9-]+$/;
-var MIME_TYPE_REGEX = /^(application|text|image|audio|video|font|multipart)\//;
-var DATE_FORMAT_REGEX = /^[YMDHhmsaAZz\-\/\.\s:,]+$/;
-var CSS_UNIT_REGEX = /^\d+(\.\d+)?(px|em|rem|vh|vw|%|ch|ex|pt|pc|in|cm|mm)$/;
-var TAILWIND_REGEX = /^[a-z][\w-]*(\s+[a-z][\w-]*)*$/;
-var TAILWIND_PREFIXES = [
-  "flex",
-  "grid",
-  "block",
-  "inline",
-  "hidden",
-  "absolute",
-  "relative",
-  "fixed",
-  "sticky",
-  "top",
-  "bottom",
-  "left",
-  "right",
-  "inset",
-  "w-",
-  "h-",
-  "min-",
-  "max-",
-  "p-",
-  "px-",
-  "py-",
-  "pt-",
-  "pb-",
-  "pl-",
-  "pr-",
-  "m-",
-  "mx-",
-  "my-",
-  "mt-",
-  "mb-",
-  "ml-",
-  "mr-",
-  "text-",
-  "font-",
-  "leading-",
-  "tracking-",
-  "bg-",
-  "border-",
-  "rounded-",
-  "shadow-",
-  "opacity-",
-  "z-",
-  "gap-",
-  "space-",
-  "items-",
-  "justify-",
-  "self-",
-  "place-",
-  "overflow-",
-  "cursor-",
-  "transition-",
-  "duration-",
-  "ease-",
-  "sm:",
-  "md:",
-  "lg:",
-  "xl:",
-  "2xl:",
-  "dark:",
-  "hover:",
-  "focus:",
-  "active:",
-  "group-",
-  "peer-"
-];
-var NON_TRANSLATABLE_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "className",
-  "class",
-  "href",
-  "src",
-  "id",
-  "key",
-  "ref",
-  "style",
-  "data-testid",
-  "data-cy",
-  "data-test",
-  "type",
-  "name",
-  "value",
-  "action",
-  "method",
-  "encType",
-  "target",
-  "rel",
-  "role",
-  "tabIndex",
-  "htmlFor",
-  "for",
-  "width",
-  "height",
-  "viewBox",
-  "xmlns",
-  "fill",
-  "stroke",
-  "onClick",
-  "onChange",
-  "onSubmit",
-  "onBlur",
-  "onFocus",
-  "onKeyDown",
-  "onKeyUp",
-  "onKeyPress",
-  "onMouseEnter",
-  "onMouseLeave"
-]);
-var TRANSLATABLE_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "title",
-  "placeholder",
-  "alt",
-  "aria-label",
-  "aria-description",
-  "aria-placeholder",
-  "aria-roledescription",
-  "aria-valuetext",
-  "label",
-  "description",
-  "message",
-  "heading",
-  "caption",
-  "helperText",
-  "errorMessage",
-  "successMessage",
-  "tooltip"
-]);
-var NON_TRANSLATABLE_CALLS = /* @__PURE__ */ new Set([
-  "console.log",
-  "console.warn",
-  "console.error",
-  "console.info",
-  "console.debug",
-  "require",
-  "import",
-  "addEventListener",
-  "removeEventListener",
-  "querySelector",
-  "querySelectorAll",
-  "getElementById",
-  "getAttribute",
-  "setAttribute",
-  "createElement",
-  "JSON.parse",
-  "JSON.stringify",
-  "parseInt",
-  "parseFloat",
-  "encodeURIComponent",
-  "decodeURIComponent",
-  "encodeURI",
-  "decodeURI",
-  "RegExp"
-]);
-var TRANSLATABLE_VAR_NAMES = /* @__PURE__ */ new Set([
-  "label",
-  "message",
-  "title",
-  "description",
-  "heading",
-  "text",
-  "caption",
-  "subtitle",
-  "tooltip",
-  "errorMessage",
-  "successMessage",
-  "warningMessage",
-  "infoMessage",
-  "placeholder",
-  "helperText",
-  "hint",
-  "buttonText",
-  "linkText",
-  "headerText",
-  "footerText",
-  "confirmText",
-  "cancelText",
-  "submitText",
-  "greeting",
-  "welcome",
-  "instructions"
-]);
-function classifyString(text, context, metadata = {}) {
-  const trimmed = text.trim();
-  if (trimmed.length === 0) {
-    return { translatable: false, confidence: "high", reason: "Empty or whitespace-only" };
-  }
-  if (trimmed.length === 1) {
-    return { translatable: false, confidence: "high", reason: "Single character" };
-  }
-  if (!/[a-zA-Z]/.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "No alphabetic characters" };
-  }
-  if (URL_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "URL" };
-  }
-  if (EMAIL_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "Email address" };
-  }
-  if (FILE_PATH_REGEX.test(trimmed) && !trimmed.includes(" ")) {
-    return { translatable: false, confidence: "high", reason: "File path" };
-  }
-  if (COLOR_HEX_REGEX.test(trimmed) || COLOR_FUNC_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "Color code" };
-  }
-  if (CSS_UNIT_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "CSS unit value" };
-  }
-  if (MIME_TYPE_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "MIME type" };
-  }
-  if (DATE_FORMAT_REGEX.test(trimmed) && trimmed.length > 1) {
-    return { translatable: false, confidence: "high", reason: "Date format string" };
-  }
-  if (context === "jsx-attribute" && metadata.attributeName) {
-    if (NON_TRANSLATABLE_ATTRIBUTES.has(metadata.attributeName)) {
-      return { translatable: false, confidence: "high", reason: `Non-translatable attribute: ${metadata.attributeName}` };
-    }
-    if (metadata.attributeName.startsWith("data-") && !TRANSLATABLE_ATTRIBUTES.has(metadata.attributeName)) {
-      return { translatable: false, confidence: "high", reason: "data-* attribute" };
-    }
-    if (metadata.attributeName.startsWith("on") && metadata.attributeName.length > 2) {
-      const thirdChar = metadata.attributeName[2];
-      if (thirdChar && thirdChar === thirdChar.toUpperCase()) {
-        return { translatable: false, confidence: "high", reason: "Event handler attribute" };
-      }
-    }
-    if (TRANSLATABLE_ATTRIBUTES.has(metadata.attributeName)) {
-      return { translatable: true, confidence: "high", reason: `Translatable attribute: ${metadata.attributeName}` };
-    }
-  }
-  if (context === "jsx-text") {
-    const hasWords = /[a-zA-Z]{2,}/.test(trimmed);
-    if (hasWords) {
-      return { translatable: true, confidence: "high", reason: "JSX text with words" };
-    }
-  }
-  if (!trimmed.includes(" ") && (CAMEL_CASE_REGEX.test(trimmed) || PASCAL_CASE_REGEX.test(trimmed) || SCREAMING_SNAKE_REGEX.test(trimmed) || KEBAB_CASE_REGEX.test(trimmed))) {
-    return { translatable: false, confidence: "high", reason: "Code identifier" };
-  }
-  if (isTailwindClasses(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "CSS/Tailwind classes" };
-  }
-  if (metadata.isInsideCallExpression) {
-    if (NON_TRANSLATABLE_CALLS.has(metadata.isInsideCallExpression)) {
-      return { translatable: false, confidence: "high", reason: `Inside ${metadata.isInsideCallExpression}()` };
-    }
-  }
-  if (metadata.parentType === "ThrowStatement" || metadata.isInsideCallExpression === "Error") {
-    return { translatable: false, confidence: "high", reason: "Error message" };
-  }
-  if ((context === "string-literal" || context === "template-literal") && metadata.parentType === "VariableDeclarator") {
-    return { translatable: true, confidence: "medium", reason: "String in variable declaration" };
-  }
-  const wordCount = trimmed.split(/\s+/).length;
-  if (wordCount >= 3) {
-    return { translatable: true, confidence: "medium", reason: `Multi-word string (${wordCount} words)` };
-  }
-  if (wordCount === 2 && /[a-zA-Z]{2,}/.test(trimmed)) {
-    return { translatable: true, confidence: "low", reason: "Short phrase (2 words)" };
-  }
-  if (/^[A-Z][a-z]/.test(trimmed) && context !== "string-literal") {
-    return { translatable: true, confidence: "low", reason: "Capitalized word, possibly UI text" };
-  }
-  return { translatable: false, confidence: "low", reason: "Ambiguous single-word string" };
-}
-function isTranslatableVarName(name) {
-  const lower = name.toLowerCase();
-  for (const varName of TRANSLATABLE_VAR_NAMES) {
-    if (lower === varName.toLowerCase() || lower.endsWith(varName.toLowerCase())) {
-      return true;
-    }
-  }
-  return false;
-}
-function isTailwindClasses(text) {
-  if (!TAILWIND_REGEX.test(text)) return false;
-  const parts = text.split(/\s+/);
-  let tailwindCount = 0;
-  for (const part of parts) {
-    if (TAILWIND_PREFIXES.some((prefix) => part.startsWith(prefix))) {
-      tailwindCount++;
-    }
-  }
-  return tailwindCount > parts.length / 2;
-}
-// src/utils/wrap/analyzer.ts
-var traverse2 = babelTraverse2.default || babelTraverse2;
-var StringAnalyzer = class {
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  /**
-   * Analyze all files matching the given patterns and return wrap candidates.
-   */
-  async analyzeProject(options, projectRoot = process.cwd()) {
-    const includePatterns = options.include?.length ? options.include : ["src/**/*.{tsx,jsx,ts,js}"];
-    const defaultIgnore = [
-      "**/node_modules/**",
-      "**/.next/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/*.test.*",
-      "**/*.spec.*",
-      "**/*.stories.*",
-      "**/__tests__/**"
-    ];
-    const ignorePatterns = options.exclude ? [...defaultIgnore, ...options.exclude] : defaultIgnore;
-    const allFiles = /* @__PURE__ */ new Set();
-    for (const pattern of includePatterns) {
-      const files = await glob2(pattern, {
-        cwd: projectRoot,
-        absolute: true,
-        ignore: ignorePatterns
-      });
-      files.forEach((file) => allFiles.add(file));
-    }
-    const allCandidates = [];
-    for (const file of allFiles) {
-      try {
-        const candidates = this.analyzeFile(file);
-        allCandidates.push(...candidates);
-      } catch (error) {
-        if (options.verbose) {
-          const msg = error instanceof Error ? error.message : "Unknown error";
-          console.warn(`Warning: Failed to analyze ${file}: ${msg}`);
-        }
-      }
-    }
-    return allCandidates;
-  }
-  /**
-   * Analyze a single file and return wrap candidates.
-   */
-  analyzeFile(filePath) {
-    const code = readFileSync3(filePath, "utf-8");
-    return this.analyzeCode(code, filePath);
-  }
-  /**
-   * Analyze source code and return wrap candidates.
-   */
-  analyzeCode(code, filePath = "<input>") {
-    const candidates = [];
-    const ast = parse2(code, {
-      sourceType: "module",
-      plugins: ["jsx", "typescript"]
-    });
-    const vocoderImports = /* @__PURE__ */ new Map();
-    const tFunctionNames = /* @__PURE__ */ new Set();
-    traverse2(ast, {
-      // Track imports from @vocoder/react
-      ImportDeclaration: (path) => {
-        const source = path.node.source.value;
-        if (source === this.adapter.importSource) {
-          path.node.specifiers.forEach((spec) => {
-            if (spec.type === "ImportSpecifier") {
-              const imported = spec.imported.type === "Identifier" ? spec.imported.name : null;
-              const local = spec.local.name;
-              if (imported === this.adapter.componentName) {
-                vocoderImports.set(local, this.adapter.componentName);
-              }
-              if (imported === this.adapter.functionName) {
-                tFunctionNames.add(local);
-              }
-              if (imported === this.adapter.hookName) {
-                vocoderImports.set(local, this.adapter.hookName);
-              }
-            }
-          });
-        }
-      },
-      // Track destructured t from useVocoder()
-      VariableDeclarator: (path) => {
-        const init2 = path.node.init;
-        if (init2 && init2.type === "CallExpression" && init2.callee.type === "Identifier" && init2.callee.name === this.adapter.hookName && path.node.id.type === "ObjectPattern") {
-          path.node.id.properties.forEach((prop) => {
-            if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === this.adapter.functionName) {
-              const localName = prop.value.type === "Identifier" ? prop.value.name : this.adapter.functionName;
-              tFunctionNames.add(localName);
-            }
-          });
-        }
-      },
-      // Find bare JSX text
-      JSXText: (path) => {
-        const text = path.node.value;
-        const trimmed = text.trim();
-        if (!trimmed) return;
-        const ancestors = path.getAncestry().map((a) => a.node);
-        if (this.adapter.isAlreadyWrapped(ancestors, vocoderImports)) return;
-        const classification = classifyString(trimmed, "jsx-text", {
-          isInsideComponent: true
-        });
-        if (classification.translatable) {
-          candidates.push({
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            column: path.node.loc?.start.column || 0,
-            text: trimmed,
-            confidence: classification.confidence,
-            strategy: "T-component",
-            context: "jsx-text",
-            reason: classification.reason
-          });
-        }
-      },
-      // Find translatable JSX attributes
-      JSXAttribute: (path) => {
-        const attrName = path.node.name?.name;
-        if (!attrName) return;
-        const value = path.node.value;
-        if (!value) return;
-        let text = null;
-        let context = "jsx-attribute";
-        if (value.type === "StringLiteral") {
-          text = value.value;
-        } else if (value.type === "JSXExpressionContainer" && value.expression.type === "StringLiteral") {
-          text = value.expression.value;
-        }
-        if (!text || !text.trim()) return;
-        if (value.type === "JSXExpressionContainer" && value.expression.type === "CallExpression") {
-          if (this.adapter.isAlreadyWrappedCall(value.expression, tFunctionNames)) return;
-        }
-        const classification = classifyString(text.trim(), context, {
-          attributeName: attrName,
-          isInsideComponent: true
-        });
-        if (classification.translatable) {
-          candidates.push({
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            column: path.node.loc?.start.column || 0,
-            text: text.trim(),
-            confidence: classification.confidence,
-            strategy: "t-function",
-            context,
-            reason: classification.reason
-          });
-        }
-      },
-      // Find string literals in non-JSX contexts
-      StringLiteral: (path) => {
-        if (path.parent.type === "ImportDeclaration") return;
-        if (path.parent.type === "ExportDeclaration") return;
-        if (path.parent.type === "JSXAttribute") return;
-        if (path.parent.type === "JSXExpressionContainer" && path.parentPath?.parent?.type === "JSXAttribute") return;
-        if (path.parent.type === "JSXExpressionContainer") return;
-        if (path.parent.type === "ObjectProperty" && path.parent.key === path.node) return;
-        if (path.parent.type === "TSLiteralType") return;
-        if (isInsideTCall(path, tFunctionNames)) return;
-        const text = path.node.value;
-        if (!text.trim()) return;
-        const callExpr = getEnclosingCallExpression(path);
-        const parentType = path.parent.type;
-        const classification = classifyString(text.trim(), "string-literal", {
-          parentType,
-          isInsideCallExpression: callExpr,
-          isInsideComponent: false
-        });
-        let { confidence } = classification;
-        if (parentType === "VariableDeclarator" && path.parent.id?.type === "Identifier") {
-          const varName = path.parent.id.name;
-          if (isTranslatableVarName(varName) && classification.translatable) {
-            confidence = "high";
-          }
-        }
-        if (classification.translatable) {
-          candidates.push({
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            column: path.node.loc?.start.column || 0,
-            text: text.trim(),
-            confidence,
-            strategy: "t-function",
-            context: "string-literal",
-            reason: classification.reason
-          });
-        }
-      },
-      // Find template literals
-      TemplateLiteral: (path) => {
-        if (path.parent.type === "ImportDeclaration") return;
-        if (path.parent.type === "TaggedTemplateExpression") return;
-        if (isInsideTCall(path, tFunctionNames)) return;
-        const quasis = path.node.quasis;
-        if (quasis.length === 0) return;
-        const parts = [];
-        for (let i = 0; i < quasis.length; i++) {
-          const quasi = quasis[i];
-          parts.push(quasi.value.raw);
-          if (i < path.node.expressions.length) {
-            const expr = path.node.expressions[i];
-            if (expr.type === "Identifier") {
-              parts.push(`{${expr.name}}`);
-            } else {
-              parts.push("{value}");
-            }
-          }
-        }
-        const text = parts.join("").trim();
-        if (!text) return;
-        const callExpr = getEnclosingCallExpression(path);
-        const parentType = path.parent.type;
-        const classification = classifyString(text, "template-literal", {
-          parentType,
-          isInsideCallExpression: callExpr,
-          isInsideComponent: false
-        });
-        if (classification.translatable) {
-          candidates.push({
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            column: path.node.loc?.start.column || 0,
-            text,
-            confidence: classification.confidence,
-            strategy: "t-function",
-            context: "template-literal",
-            reason: classification.reason
-          });
-        }
-      }
-    });
-    return candidates;
-  }
-};
-function isInsideTCall(path, tNames) {
-  let current = path.parentPath;
-  while (current) {
-    if (current.node.type === "CallExpression") {
-      const callee = current.node.callee;
-      if (callee.type === "Identifier" && tNames.has(callee.name)) {
-        return true;
-      }
-    }
-    current = current.parentPath;
-  }
-  return false;
-}
-function getEnclosingCallExpression(path) {
-  let current = path.parentPath;
-  while (current) {
-    if (current.node.type === "CallExpression") {
-      const callee = current.node.callee;
-      if (callee.type === "Identifier") {
-        return callee.name;
-      }
-      if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.property.type === "Identifier") {
-        return `${callee.object.name}.${callee.property.name}`;
-      }
-    }
-    if (current.node.type === "NewExpression") {
-      const callee = current.node.callee;
-      if (callee.type === "Identifier") {
-        return callee.name;
-      }
-    }
-    current = current.parentPath;
-  }
-  return void 0;
-}
-// src/utils/wrap/transformer.ts
-import * as recast from "recast";
-import { parse as babelParse } from "@babel/parser";
-var babelParser = {
-  parse(source) {
-    return babelParse(source, {
-      sourceType: "module",
-      plugins: ["jsx", "typescript"],
-      tokens: true
-    });
-  }
-};
-var StringTransformer = class {
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  /**
-   * Transform a file by wrapping the given candidates.
-   * Returns the transformed source code.
-   */
-  transform(code, candidates, filePath = "<input>") {
-    const ast = recast.parse(code, { parser: babelParser });
-    const b = recast.types.builders;
-    const wrapped = [];
-    const skipped = [];
-    const usedStrategies = /* @__PURE__ */ new Set();
-    const componentsNeedingHook = /* @__PURE__ */ new Set();
-    const candidatesByLocation = /* @__PURE__ */ new Map();
-    for (const c of candidates) {
-      candidatesByLocation.set(`${c.line}:${c.column}`, c);
-    }
-    let existingImportDecl = null;
-    const existingSpecifiers = /* @__PURE__ */ new Set();
-    const adapter = this.adapter;
-    recast.visit(ast, {
-      visitImportDeclaration(path) {
-        const source = path.node.source.value;
-        if (source === adapter.importSource) {
-          existingImportDecl = path;
-          for (const spec of path.node.specifiers || []) {
-            if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier") {
-              existingSpecifiers.add(spec.imported.name);
-            }
-          }
-        }
-        this.traverse(path);
-      },
-      visitJSXText(path) {
-        const loc = path.node.loc;
-        if (!loc) {
-          this.traverse(path);
-          return;
-        }
-        const key = `${loc.start.line}:${loc.start.column}`;
-        const candidate = candidatesByLocation.get(key);
-        if (!candidate || candidate.strategy !== "T-component") {
-          this.traverse(path);
-          return;
-        }
-        const tOpen = b.jsxOpeningElement(
-          b.jsxIdentifier(adapter.componentName),
-          []
-        );
-        const tClose = b.jsxClosingElement(
-          b.jsxIdentifier(adapter.componentName)
-        );
-        const tElement = b.jsxElement(
-          tOpen,
-          tClose,
-          [b.jsxText(candidate.text)]
-        );
-        path.replace(tElement);
-        wrapped.push(candidate);
-        usedStrategies.add("T-component");
-        candidatesByLocation.delete(key);
-        return false;
-      },
-      visitJSXAttribute(path) {
-        const loc = path.node.loc;
-        if (!loc) {
-          this.traverse(path);
-          return;
-        }
-        const key = `${loc.start.line}:${loc.start.column}`;
-        const candidate = candidatesByLocation.get(key);
-        if (!candidate || candidate.strategy !== "t-function") {
-          this.traverse(path);
-          return;
-        }
-        const value = path.node.value;
-        if (!value) {
-          this.traverse(path);
-          return;
-        }
-        const tCall = b.callExpression(
-          b.identifier(adapter.functionName),
-          [b.stringLiteral(candidate.text)]
-        );
-        const exprContainer = b.jsxExpressionContainer(tCall);
-        path.node.value = exprContainer;
-        const componentFunc = findEnclosingComponent(path);
-        if (componentFunc) {
-          componentsNeedingHook.add(componentFunc);
-        }
-        wrapped.push(candidate);
-        usedStrategies.add("t-function");
-        candidatesByLocation.delete(key);
-        this.traverse(path);
-      },
-      visitStringLiteral(path) {
-        const loc = path.node.loc;
-        if (!loc) {
-          this.traverse(path);
-          return;
-        }
-        const key = `${loc.start.line}:${loc.start.column}`;
-        const candidate = candidatesByLocation.get(key);
-        if (!candidate || candidate.strategy !== "t-function") {
-          this.traverse(path);
-          return;
-        }
-        if (path.parent.node.type === "JSXAttribute") {
-          this.traverse(path);
-          return;
-        }
-        const tCall = b.callExpression(
-          b.identifier(adapter.functionName),
-          [b.stringLiteral(candidate.text)]
-        );
-        path.replace(tCall);
-        const componentFunc = findEnclosingComponent(path);
-        if (componentFunc) {
-          componentsNeedingHook.add(componentFunc);
-        }
-        wrapped.push(candidate);
-        usedStrategies.add("t-function");
-        candidatesByLocation.delete(key);
-        return false;
-      }
-    });
-    for (const candidate of candidatesByLocation.values()) {
-      skipped.push(candidate);
-    }
-    if (componentsNeedingHook.size > 0) {
-      this.injectUseVocoderHooks(ast, componentsNeedingHook, b);
-    }
-    this.manageImports(ast, usedStrategies, existingImportDecl, existingSpecifiers, componentsNeedingHook.size > 0, b);
-    const output = recast.print(ast).code;
-    return {
-      file: filePath,
-      output,
-      wrappedCount: wrapped.length,
-      wrapped,
-      skipped
-    };
-  }
-  /**
-   * Inject `const { t } = useVocoder();` at the top of component functions.
-   */
-  injectUseVocoderHooks(ast, componentFuncs, b) {
-    const adapterFunctionName = this.adapter.functionName;
-    const adapterHookName = this.adapter.hookName;
-    const buildHookDecl = () => b.variableDeclaration("const", [
-      b.variableDeclarator(
-        b.objectPattern([
-          b.property.from({
-            kind: "init",
-            key: b.identifier(adapterFunctionName),
-            value: b.identifier(adapterFunctionName),
-            shorthand: true
-          })
-        ]),
-        b.callExpression(b.identifier(adapterHookName), [])
-      )
-    ]);
-    recast.visit(ast, {
-      visitFunction(path) {
-        if (componentFuncs.has(path.node)) {
-          const body = path.node.body;
-          if (body.type === "BlockStatement") {
-            const alreadyHasHook = body.body.some((stmt) => {
-              if (stmt.type !== "VariableDeclaration") return false;
-              return stmt.declarations.some(
-                (decl) => decl.init?.type === "CallExpression" && decl.init.callee?.type === "Identifier" && decl.init.callee.name === "useVocoder"
-              );
-            });
-            if (!alreadyHasHook) {
-              body.body.unshift(buildHookDecl());
-            }
-          }
-        }
-        this.traverse(path);
-      },
-      visitArrowFunctionExpression(path) {
-        if (componentFuncs.has(path.node)) {
-          const body = path.node.body;
-          if (body.type === "BlockStatement") {
-            const alreadyHasHook = body.body.some((stmt) => {
-              if (stmt.type !== "VariableDeclaration") return false;
-              return stmt.declarations.some(
-                (decl) => decl.init?.type === "CallExpression" && decl.init.callee?.type === "Identifier" && decl.init.callee.name === "useVocoder"
-              );
-            });
-            if (!alreadyHasHook) {
-              body.body.unshift(buildHookDecl());
-            }
-          }
-        }
-        this.traverse(path);
-      }
-    });
-  }
-  /**
-   * Add or update @vocoder/react imports.
-   */
-  manageImports(ast, usedStrategies, existingImportPath, existingSpecifiers, needsHook, b) {
-    if (usedStrategies.size === 0) return;
-    const neededSpecifiers = /* @__PURE__ */ new Set();
-    if (usedStrategies.has("T-component")) {
-      neededSpecifiers.add(this.adapter.componentName);
-    }
-    if (usedStrategies.has("t-function") && needsHook) {
-      neededSpecifiers.add(this.adapter.hookName);
-    }
-    const missingSpecifiers = [];
-    for (const spec of neededSpecifiers) {
-      if (!existingSpecifiers.has(spec)) {
-        missingSpecifiers.push(spec);
-      }
-    }
-    if (missingSpecifiers.length === 0) return;
-    if (existingImportPath) {
-      for (const name of missingSpecifiers) {
-        const specifier = b.importSpecifier(b.identifier(name), b.identifier(name));
-        existingImportPath.node.specifiers.push(specifier);
-      }
-    } else {
-      const specifiers = missingSpecifiers.map(
-        (name) => b.importSpecifier(b.identifier(name), b.identifier(name))
-      );
-      const importDecl = b.importDeclaration(
-        specifiers,
-        b.stringLiteral(this.adapter.importSource)
-      );
-      const body = ast.program.body;
-      let lastImportIndex = -1;
-      for (let i = 0; i < body.length; i++) {
-        if (body[i].type === "ImportDeclaration") {
-          lastImportIndex = i;
-        }
-      }
-      if (lastImportIndex >= 0) {
-        body.splice(lastImportIndex + 1, 0, importDecl);
-      } else {
-        body.unshift(importDecl);
-      }
-    }
-  }
-};
-function findEnclosingComponent(path) {
-  let current = path.parent;
-  while (current) {
-    const node = current.node;
-    if (node.type === "FunctionDeclaration" && node.id?.name) {
-      const name = node.id.name;
-      if (/^[A-Z]/.test(name)) return node;
-    }
-    if (node.type === "ArrowFunctionExpression") {
-      const parent = current.parent?.node;
-      if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") {
-        const name = parent.id.name;
-        if (/^[A-Z]/.test(name)) return node;
-      }
-    }
-    if (node.type === "FunctionExpression") {
-      const parent = current.parent?.node;
-      if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") {
-        const name = parent.id.name;
-        if (/^[A-Z]/.test(name)) return node;
-      }
-    }
-    current = current.parent;
-  }
-  return null;
-}
-// src/utils/wrap/adapters/react.ts
-var reactAdapter = {
-  name: "react",
-  extensions: [".tsx", ".jsx", ".ts", ".js"],
-  importSource: "@vocoder/react",
-  componentName: "T",
-  functionName: "t",
-  hookName: "useVocoder",
-  translatableAttributes: [
-    "title",
-    "placeholder",
-    "alt",
-    "aria-label",
-    "aria-description",
-    "aria-placeholder",
-    "aria-roledescription",
-    "aria-valuetext",
-    "label",
-    "description",
-    "message",
-    "heading",
-    "caption",
-    "helperText",
-    "errorMessage",
-    "successMessage",
-    "tooltip"
-  ],
-  nonTranslatableAttributes: [
-    "className",
-    "class",
-    "href",
-    "src",
-    "id",
-    "key",
-    "ref",
-    "style",
-    "data-testid",
-    "data-cy",
-    "data-test",
-    "type",
-    "name",
-    "value",
-    "action",
-    "method",
-    "encType",
-    "target",
-    "rel",
-    "role",
-    "tabIndex",
-    "htmlFor",
-    "for",
-    "width",
-    "height",
-    "viewBox",
-    "xmlns",
-    "fill",
-    "stroke"
-  ],
-  isAlreadyWrapped(ancestors, imports) {
-    for (const ancestor of ancestors) {
-      if (ancestor.type === "JSXElement") {
-        const opening = ancestor.openingElement;
-        if (opening && opening.name && opening.name.type === "JSXIdentifier") {
-          const tagName = opening.name.name;
-          if (imports.has(tagName) && imports.get(tagName) === "T") {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
-  },
-  isAlreadyWrappedCall(node, tNames) {
-    if (node.type === "CallExpression") {
-      const callee = node.callee;
-      if (callee.type === "Identifier" && tNames.has(callee.name)) {
-        return true;
-      }
-    }
-    return false;
-  },
-  getRequiredImports(strategies) {
-    const specifiers = [];
-    if (strategies.has("T-component")) {
-      specifiers.push("T");
-    }
-    if (strategies.has("t-function")) {
-      specifiers.push("useVocoder");
-    }
-    return { specifiers, source: "@vocoder/react" };
+// src/commands/whoami.ts
+import * as p8 from "@clack/prompts";
+import chalk9 from "chalk";
+async function whoami(options = {}) {
+  const stored = readAuthData();
+  if (!stored) {
+    p8.log.info("Not logged in. Run `vocoder init` to authenticate.");
+    return 1;
   }
-};
-// src/commands/wrap.ts
-var CONFIDENCE_ORDER = ["high", "medium", "low"];
-function meetsConfidenceThreshold(candidate, threshold) {
-  return CONFIDENCE_ORDER.indexOf(candidate) <= CONFIDENCE_ORDER.indexOf(threshold);
-}
-async function wrap(options = {}) {
-  const startTime = Date.now();
-  const projectRoot = process.cwd();
-  const confidenceThreshold = options.confidence || "high";
-  p3.intro("Vocoder Wrap");
-  const spinner4 = p3.spinner();
+  const apiUrl = options.apiUrl ?? stored.apiUrl ?? "https://vocoder.app";
+  const api = new VocoderAPI({ apiUrl, apiKey: "" });
   try {
-    spinner4.start("Scanning files for unwrapped strings");
-    const analyzer = new StringAnalyzer(reactAdapter);
-    const allCandidates = await analyzer.analyzeProject(options, projectRoot);
-    if (allCandidates.length === 0) {
-      spinner4.stop("No unwrapped strings found");
-      p3.log.info("All user-facing strings appear to be wrapped already.");
-      p3.outro("");
-      return 0;
-    }
-    spinner4.stop(
-      `Found ${chalk4.cyan(allCandidates.length)} candidate strings`
-    );
-    const filtered = allCandidates.filter(
-      (c) => meetsConfidenceThreshold(c.confidence, confidenceThreshold)
-    );
-    if (filtered.length === 0) {
-      p3.log.warn(
-        `No strings meet the ${chalk4.bold(confidenceThreshold)} confidence threshold.`
-      );
-      p3.log.info("Try --confidence medium or --confidence low to see more candidates.");
-      p3.outro("");
-      return 0;
-    }
-    p3.log.info(
-      `${filtered.length} strings meet ${chalk4.bold(confidenceThreshold)} confidence threshold`
-    );
-    const byFile = /* @__PURE__ */ new Map();
-    for (const c of filtered) {
-      const existing = byFile.get(c.file) || [];
-      existing.push(c);
-      byFile.set(c.file, existing);
-    }
-    if (options.dryRun) {
-      const lines = [];
-      for (const [file, candidates] of byFile) {
-        const relPath = relative2(projectRoot, file);
-        lines.push(chalk4.bold(relPath));
-        for (const c of candidates) {
-          const confidenceColor = c.confidence === "high" ? chalk4.green : c.confidence === "medium" ? chalk4.yellow : chalk4.red;
-          const strategyLabel = c.strategy === "T-component" ? "<T>" : "t()";
-          lines.push(
-            `  ${chalk4.dim(`L${c.line}`)} ${confidenceColor(`[${c.confidence}]`)} ${chalk4.cyan(strategyLabel)} "${truncate(c.text, 50)}"`
-          );
-          if (options.verbose) {
-            lines.push(chalk4.dim(`        ${c.reason}`));
-          }
-        }
-        lines.push("");
-      }
-      lines.push(summarizeCandidates(filtered));
-      p3.note(lines.join("\n"), "Dry run \u2014 would wrap");
-      p3.outro("Run without --dry-run to apply changes.");
-      return 0;
-    }
-    let accepted;
-    if (options.interactive) {
-      accepted = await interactiveConfirm(byFile, projectRoot);
-      if (accepted.length === 0) {
-        p3.log.warn("No strings selected for wrapping.");
-        p3.outro("");
-        return 0;
-      }
-    } else {
-      accepted = filtered;
-    }
-    spinner4.start("Wrapping strings");
-    const transformer = new StringTransformer(reactAdapter);
-    let totalWrapped = 0;
-    let filesModified = 0;
-    const acceptedByFile = /* @__PURE__ */ new Map();
-    for (const c of accepted) {
-      const existing = acceptedByFile.get(c.file) || [];
-      existing.push(c);
-      acceptedByFile.set(c.file, existing);
-    }
-    for (const [file, candidates] of acceptedByFile) {
-      const code = readFileSync4(file, "utf-8");
-      const result = transformer.transform(code, candidates, file);
-      if (result.wrappedCount > 0) {
-        writeFileSync2(file, result.output, "utf-8");
-        totalWrapped += result.wrappedCount;
-        filesModified++;
-      }
-      if (options.verbose && result.skipped.length > 0) {
-        const relPath = relative2(projectRoot, file);
-        p3.log.info(`Skipped ${result.skipped.length} strings in ${relPath}`);
-      }
+    const info = await api.getCliUserInfo(stored.token);
+    p8.log.info(`Logged in as ${chalk9.bold(info.email)}`);
+    if (info.name) {
+      p8.log.info(`Name: ${info.name}`);
     }
-    spinner4.stop(
-      `Wrapped ${chalk4.cyan(totalWrapped)} strings across ${chalk4.cyan(filesModified)} files`
-    );
-    const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
-    p3.outro(`Done! (${duration}s)`);
-    p3.log.info("Next steps:");
-    p3.log.info("  1. Review the changes (git diff)");
-    p3.log.info("  2. Run your tests to verify nothing broke");
-    p3.log.info('  3. Run "vocoder sync" to extract and translate');
+    p8.log.info(`API: ${apiUrl}`);
     return 0;
-  } catch (error) {
-    spinner4.stop();
-    if (error instanceof Error) {
-      p3.log.error(error.message);
-      if (options.verbose) {
-        p3.log.info(`Full error: ${error.stack ?? error}`);
-      }
-    }
+  } catch {
+    p8.log.error("Stored credentials are invalid or expired. Run `vocoder init` to re-authenticate.");
     return 1;
   }
 }
-async function interactiveConfirm(byFile, projectRoot) {
-  const accepted = [];
-  p3.log.info("Interactive mode \u2014 confirm each string:");
-  for (const [file, candidates] of byFile) {
-    const relPath = relative2(projectRoot, file);
-    p3.log.step(chalk4.bold(relPath));
-    let skipFile = false;
-    for (const c of candidates) {
-      if (skipFile) break;
-      const strategyLabel = c.strategy === "T-component" ? "<T>" : "t()";
-      const label = `L${c.line} ${strategyLabel} "${truncate(c.text, 50)}"`;
-      const action = await p3.select({
-        message: label,
-        options: [
-          { value: "yes", label: "Yes, wrap this string" },
-          { value: "no", label: "No, skip" },
-          { value: "all", label: "Accept all remaining" },
-          { value: "skip", label: "Skip this file" },
-          { value: "quit", label: "Quit" }
-        ]
-      });
-      if (p3.isCancel(action) || action === "quit") {
-        return accepted;
-      }
-      if (action === "yes") {
-        accepted.push(c);
-      } else if (action === "all") {
-        accepted.push(c);
-        const remaining = candidates.slice(candidates.indexOf(c) + 1);
-        accepted.push(...remaining);
-        for (const [, moreCandidates] of byFile) {
-          if (moreCandidates !== candidates) {
-            accepted.push(...moreCandidates);
-          }
-        }
-        return accepted;
-      } else if (action === "skip") {
-        skipFile = true;
-      }
-    }
-  }
-  return accepted;
-}
-function truncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen - 3) + "...";
-}
-function summarizeCandidates(candidates) {
-  let high = 0;
-  let medium = 0;
-  let low = 0;
-  let tComponent = 0;
-  let tFunction = 0;
-  for (const c of candidates) {
-    if (c.confidence === "high") high++;
-    else if (c.confidence === "medium") medium++;
-    else low++;
-    if (c.strategy === "T-component") tComponent++;
-    else tFunction++;
-  }
-  const parts = [];
-  if (high > 0) parts.push(chalk4.green(`${high} high`));
-  if (medium > 0) parts.push(chalk4.yellow(`${medium} medium`));
-  if (low > 0) parts.push(chalk4.red(`${low} low`));
-  return `${candidates.length} total (${parts.join(", ")}) | ${tComponent} <T>, ${tFunction} t()`;
-}
 // src/bin.ts
 function collect(value, previous = []) {
@@ -2734,15 +2855,18 @@ function collect(value, previous = []) {
 }
 async function runCommand(command, options) {
   const exitCode = await command(options);
-  process.exitCode = exitCode;
+  process.exit(exitCode);
 }
 var program = new Command();
-program.name("vocoder").description("Vocoder CLI - Sync translations for your application").version("0.1.2");
-program.command("sync").description("Extract strings and sync translations").option("--include <pattern>", "Glob pattern(s) to include (can be used multiple times)", collect, []).option("--exclude <pattern>", "Glob pattern(s) to exclude (can be used multiple times)", collect, []).option("--branch <name>", "Override branch detection").option("--force", "Sync even if not a target branch").option("--mode <mode>", "Sync mode: auto|required|best-effort").option("--max-wait-ms <ms>", "Max wait time before fallback (ms)", (value) => Number.parseInt(value, 10)).option("--no-fallback", "Fail instead of using fallback artifacts").option("--dry-run", "Show what would be synced without doing it").option("--verbose", "Show detailed progress").action((options) => runCommand(sync, {
-  ...options,
-  noFallback: options.noFallback ? true : void 0
-}));
-program.command("wrap").description("Auto-wrap strings with <T> and t() for translation").option("--include <pattern>", "Glob pattern(s) to include (can be used multiple times)", collect, []).option("--exclude <pattern>", "Glob pattern(s) to exclude (can be used multiple times)", collect, []).option("--dry-run", "Preview changes without modifying files").option("--interactive", "Confirm each string interactively").option("--confidence <level>", "Minimum confidence: high, medium, low", "high").option("--verbose", "Detailed output").action((options) => runCommand(wrap, options));
-program.command("init").description("Authenticate and provision Vocoder for this project").option("--api-url <url>", "Override Vocoder API URL").option("--yes", "Allow overwriting existing local config values").option("--project-name <name>", "Starter project name to create").option("--source-locale <locale>", "Source locale for the starter project").option("--target-locales <list>", "Comma-separated target locales (e.g. es,fr,de)").action((options) => runCommand(init, options));
+program.name("vocoder").description("Vocoder CLI - Project setup and string extraction").version("0.1.5");
+program.command("init").description("Authenticate and provision Vocoder for this project").option("--api-url <url>", "Override Vocoder API URL").option("--yes", "Allow overwriting existing local config values").option("--ci", "Non-interactive mode: print auth URL to stdout, skip browser open").option("--project-name <name>", "Starter project name to create").option("--source-locale <locale>", "Source locale for the starter project").option("--target-locales <list>", "Comma-separated target locales (e.g. es,fr,de)").action((options) => runCommand(init, options));
+program.command("sync").description("Extract strings and sync translations").option("--branch <branch>", "Override detected branch").option("--mode <mode>", "Sync mode: auto, required, best-effort", "auto").option("--max-wait <ms>", "Max wait for translations (ms)").option("--force", "Force re-extraction even if no changes").option("--dry-run", "Preview without syncing").option("--no-fallback", "Disable fallback to cached translations").option("--include <pattern>", "Include glob pattern", collect, []).option("--exclude <pattern>", "Exclude glob pattern", collect, []).option("--verbose", "Detailed output").action((options) => {
+  const translated = { ...options };
+  if (options.maxWait) translated.maxWaitMs = Number(options.maxWait);
+  if (options.fallback === false) translated.noFallback = true;
+  return runCommand(sync, translated);
+});
+program.command("logout").description("Log out and remove stored credentials").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(logout, options));
+program.command("whoami").description("Show the currently authenticated user").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(whoami, options));
 program.parse(process.argv);
 //# sourceMappingURL=bin.mjs.map