@vocoder/cli 0.1.2 → 0.1.3

package/dist/bin.mjs

@@ -1,12 +1,2858 @@
 #!/usr/bin/env node
-import {
-  sync
-} from "./chunk-N45Q4R6O.mjs";
 
 // src/bin.ts
 import { Command } from "commander";
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+
+// src/utils/api.ts
+function isLimitErrorResponse(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.errorCode === "string" && typeof candidate.limitType === "string" && typeof candidate.planId === "string" && typeof candidate.current === "number" && typeof candidate.required === "number" && typeof candidate.upgradeUrl === "string" && typeof candidate.message === "string";
+}
+function isSyncPolicyErrorResponse(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return (candidate.errorCode === "BRANCH_NOT_ALLOWED" || candidate.errorCode === "PROJECT_REPOSITORY_MISMATCH") && typeof candidate.message === "string";
+}
+function extractErrorMessage(payload, fallback) {
+  if (!payload || typeof payload !== "object") {
+    return fallback;
+  }
+  const candidate = payload;
+  if (typeof candidate.message === "string") {
+    return candidate.message;
+  }
+  if (typeof candidate.error === "string") {
+    return candidate.error;
+  }
+  return fallback;
+}
+function parsePayload(raw) {
+  if (raw.length === 0) {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { message: raw };
+  }
+}
+async function readPayload(response) {
+  if (typeof response.text === "function") {
+    const raw = await response.text();
+    return parsePayload(raw);
+  }
+  if (typeof response.json === "function") {
+    return response.json();
+  }
+  return null;
+}
+var VocoderAPIError = class extends Error {
+  constructor(params) {
+    super(params.message);
+    this.name = "VocoderAPIError";
+    this.status = params.status;
+    this.payload = params.payload;
+    this.limitError = params.limitError ?? null;
+    this.syncPolicyError = params.syncPolicyError ?? null;
+  }
+};
+var VocoderAPI = class {
+  constructor(config) {
+    this.apiUrl = config.apiUrl;
+    this.apiKey = config.apiKey;
+  }
+  async request(path, init2 = {}, errorPrefix) {
+    const response = await fetch(`${this.apiUrl}${path}`, {
+      ...init2,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        ...init2.headers ?? {}
+      }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      const limitError = isLimitErrorResponse(payload) ? payload : null;
+      const syncPolicyError = isSyncPolicyErrorResponse(payload) ? payload : null;
+      const baseMessage = extractErrorMessage(payload, `Request failed with status ${response.status}`);
+      throw new VocoderAPIError({
+        message: errorPrefix ? `${errorPrefix}: ${baseMessage}` : baseMessage,
+        status: response.status,
+        payload,
+        limitError,
+        syncPolicyError
+      });
+    }
+    return payload;
+  }
+  /**
+   * Fetch project configuration from API
+   * Project is determined from the API key
+   */
+  async getProjectConfig() {
+    const data = await this.request("/api/cli/config", {}, "Failed to fetch project config");
+    return {
+      projectName: data.projectName,
+      organizationName: data.organizationName,
+      sourceLocale: data.sourceLocale,
+      targetLocales: data.targetLocales,
+      targetBranches: data.targetBranches,
+      syncPolicy: {
+        blockingBranches: data.syncPolicy?.blockingBranches ?? ["main", "master"],
+        blockingMode: data.syncPolicy?.blockingMode ?? "required",
+        nonBlockingMode: data.syncPolicy?.nonBlockingMode ?? "best-effort",
+        defaultMaxWaitMs: data.syncPolicy?.defaultMaxWaitMs ?? 6e4
+      }
+    };
+  }
+  /**
+   * Submit strings for translation
+   * Project is determined from the API key
+   */
+  stableTextKey(text) {
+    let hash = 2166136261;
+    for (let i = 0; i < text.length; i++) {
+      hash ^= text.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return `SK_TEXT_${(hash >>> 0).toString(16).toUpperCase().padStart(8, "0")}`;
+  }
+  normalizeStringEntries(entries) {
+    if (entries.length === 0) {
+      return [];
+    }
+    const first = entries[0];
+    if (typeof first === "string") {
+      return entries.map((text) => ({
+        key: this.stableTextKey(text),
+        text
+      }));
+    }
+    return entries.map((entry, index) => ({
+      key: entry.key || this.stableTextKey(`${entry.text}:${index}`),
+      text: entry.text,
+      ...entry.context ? { context: entry.context } : {},
+      ...entry.formality ? { formality: entry.formality } : {}
+    }));
+  }
+  async submitTranslation(branch, entries, targetLocales, options, repoIdentity) {
+    const stringEntries = this.normalizeStringEntries(entries);
+    const strings = stringEntries.map((entry) => entry.text);
+    const crypto = await import("crypto");
+    const sortedStrings = [...strings].sort();
+    const stringsHash = crypto.createHash("sha256").update(JSON.stringify(sortedStrings)).digest("hex");
+    return this.request("/api/cli/sync", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        branch,
+        stringEntries,
+        targetLocales,
+        stringsHash,
+        ...options?.requestedMode ? { requestedMode: options.requestedMode } : {},
+        ...typeof options?.requestedMaxWaitMs === "number" ? { requestedMaxWaitMs: options.requestedMaxWaitMs } : {},
+        ...options?.clientRunId ? { clientRunId: options.clientRunId } : {},
+        ...repoIdentity?.repoCanonical ? { repoCanonical: repoIdentity.repoCanonical } : {},
+        ...repoIdentity?.repoScopePath !== void 0 ? { repoScopePath: repoIdentity.repoScopePath } : {}
+      })
+    }, "Translation submission failed");
+  }
+  /**
+   * Check translation status
+   */
+  async getTranslationStatus(batchId) {
+    return this.request(
+      `/api/cli/sync/status/${batchId}`,
+      {},
+      "Failed to check translation status"
+    );
+  }
+  async getTranslationSnapshot(params) {
+    const search = new URLSearchParams();
+    search.set("branch", params.branch);
+    for (const locale of params.targetLocales) {
+      search.append("targetLocale", locale);
+    }
+    return this.request(
+      `/api/cli/sync/snapshot?${search.toString()}`,
+      {},
+      "Failed to fetch translation snapshot"
+    );
+  }
+  /**
+   * Wait for translation to complete with polling
+   */
+  async waitForCompletion(batchId, timeout = 6e4, onProgress) {
+    const startTime = Date.now();
+    const pollInterval = 1e3;
+    while (Date.now() - startTime < timeout) {
+      const status = await this.getTranslationStatus(batchId);
+      if (onProgress) {
+        onProgress(status.progress);
+      }
+      if (status.status === "COMPLETED") {
+        if (!status.translations) {
+          throw new Error("Translation completed but no translations returned");
+        }
+        return {
+          translations: status.translations,
+          localeMetadata: status.localeMetadata
+        };
+      }
+      if (status.status === "FAILED") {
+        throw new Error(
+          `Translation failed: ${status.errorMessage || "Unknown error"}`
+        );
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+    }
+    throw new Error(`Translation timeout after ${timeout}ms`);
+  }
+  async startInitSession(input) {
+    const response = await fetch(`${this.apiUrl}/api/cli/init/start`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(input)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to start init session (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async getInitSessionStatus(params) {
+    const response = await fetch(
+      `${this.apiUrl}/api/cli/init/status/${params.sessionId}`,
+      {
+        headers: {
+          Authorization: `Bearer ${params.pollToken}`
+        }
+      }
+    );
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to get init status (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+};
+
+// src/commands/init.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// 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()}`;
+  }
+  return `git:${host}/${ownerRepoPath.toLowerCase()}`;
+}
+function resolveGitRepositoryIdentity() {
+  const remoteUrl = safeExec("git config --get remote.origin.url");
+  if (!remoteUrl) {
+    return null;
+  }
+  const parsed = parseRemoteUrl(remoteUrl);
+  if (!parsed) {
+    return null;
+  }
+  const repositoryRoot = safeExec("git rev-parse --show-toplevel");
+  const currentDirectory = process.cwd();
+  let repoScopePath = "";
+  if (repositoryRoot) {
+    const relativePath = relative(resolve(repositoryRoot), resolve(currentDirectory)).replace(/\\/g, "/").trim();
+    if (relativePath && relativePath !== "." && !relativePath.startsWith("..")) {
+      repoScopePath = relativePath;
+    }
+  }
+  return {
+    repoCanonical: toCanonical(parsed.host, parsed.ownerRepoPath),
+    repoScopePath
+  };
+}
+function resolveGitContext() {
+  const warnings = [];
+  const identity = resolveGitRepositoryIdentity();
+  if (!identity) {
+    warnings.push(
+      "Could not detect git remote origin. Repo binding will be skipped until sync can detect it."
+    );
+  }
+  return { identity, warnings };
+}
+
+// src/commands/init.ts
+import { spawn } from "child_process";
+var SUBSCRIPTION_SETTINGS_PATH = "/dashboard/workspace/settings?tab=subscription";
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+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;
+}
+function getEnvLine(filePath, key) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  const current = readFileSync(filePath, "utf-8");
+  const pattern = new RegExp(`^${escapeRegExp(key)}=.*$`, "m");
+  const existingMatch = current.match(pattern);
+  return existingMatch?.[0] ?? null;
+}
+function getEnvValue(filePath, key) {
+  const line = getEnvLine(filePath, key);
+  if (!line) return null;
+  const eqIndex = line.indexOf("=");
+  if (eqIndex === -1) return null;
+  return line.slice(eqIndex + 1);
+}
+function upsertEnvValue(params) {
+  const lineValue = `${params.key}=${params.value}`;
+  if (!existsSync(params.filePath)) {
+    writeFileSync(params.filePath, `${lineValue}
+`, "utf-8");
+    return;
+  }
+  const current = readFileSync(params.filePath, "utf-8");
+  const pattern = new RegExp(`^${escapeRegExp(params.key)}=.*$`, "m");
+  const existingMatch = current.match(pattern);
+  if (existingMatch && existingMatch[0] !== lineValue && !params.allowOverwrite) {
+    throw new Error(
+      `${params.key} already exists in ${params.filePath}. Re-run with --yes to overwrite.`
+    );
+  }
+  if (existingMatch) {
+    const updated = current.replace(pattern, lineValue);
+    writeFileSync(params.filePath, updated.endsWith("\n") ? updated : `${updated}
+`, "utf-8");
+    return;
+  }
+  const prefix = current.endsWith("\n") || current.length === 0 ? "" : "\n";
+  writeFileSync(params.filePath, `${current}${prefix}${lineValue}
+`, "utf-8");
+}
+async function sleep(ms) {
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function tryOpenBrowser(url) {
+  if (!process.stdout.isTTY || process.env.CI === "true") {
+    return false;
+  }
+  let command;
+  let args;
+  if (process.platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    command = "rundll32";
+    args = ["url.dll,FileProtocolHandler", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+  return await 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);
+    }
+  });
+}
+function isPlanLimitFailure(message) {
+  if (!message) return false;
+  return /limit|upgrade/i.test(message);
+}
+function getSubscriptionSettingsUrl(apiUrl) {
+  return new URL(SUBSCRIPTION_SETTINGS_PATH, apiUrl).toString();
+}
+function printPlanLimitMessage(apiUrl, message) {
+  p.log.error(`You are over your plan limits.
+   ${message}`);
+  p.log.info(`Manage subscription: ${getSubscriptionSettingsUrl(apiUrl)}`);
+}
+function maskApiKey(key) {
+  if (key.length <= 8) return key;
+  return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
+async function init(options = {}) {
+  const projectRoot = process.cwd();
+  const apiUrl = options.apiUrl || process.env.VOCODER_API_URL || "https://vocoder.app";
+  const envPath = join(projectRoot, ".env");
+  p.intro("Vocoder Setup");
+  const spinner4 = p.spinner();
+  try {
+    const existingKey = getEnvValue(envPath, "VOCODER_API_KEY");
+    if (existingKey && existingKey.startsWith("vc_")) {
+      const existingApi = new VocoderAPI({ apiUrl, apiKey: existingKey });
+      try {
+        const config = await existingApi.getProjectConfig();
+        p.log.info("Existing configuration found:");
+        p.note(
+          [
+            `Project:    ${config.projectName}`,
+            `Workspace:  ${config.organizationName}`,
+            `Source:     ${config.sourceLocale}`,
+            `Targets:    ${config.targetLocales.join(", ")}`,
+            `Key:        ${maskApiKey(existingKey)}`
+          ].join("\n")
+        );
+        if (options.yes) {
+          p.outro("Configuration unchanged. You're all set!");
+          return 0;
+        }
+        const action = await p.select({
+          message: "What would you like to do?",
+          options: [
+            { value: "keep", label: "Keep current configuration" },
+            { value: "reconfigure", label: "Reconfigure (new browser setup)" }
+          ]
+        });
+        if (p.isCancel(action)) {
+          p.cancel("Setup cancelled.");
+          return 1;
+        }
+        if (action === "keep") {
+          p.outro("Configuration unchanged. You're all set!");
+          return 0;
+        }
+      } catch {
+        p.log.warn("Found VOCODER_API_KEY in .env but it appears to be invalid or expired.");
+        if (!options.yes) {
+          const action = await p.select({
+            message: "What would you like to do?",
+            options: [
+              { value: "reconfigure", label: "Reconfigure (new browser setup)" },
+              { value: "keep", label: "Keep current key anyway" }
+            ]
+          });
+          if (p.isCancel(action)) {
+            p.cancel("Setup cancelled.");
+            return 1;
+          }
+          if (action === "keep") {
+            p.outro("Keeping existing key. You may encounter errors if the key is invalid.");
+            return 0;
+          }
+        }
+      }
+    }
+    spinner4.start("Creating setup session");
+    const api = new VocoderAPI({ apiUrl, apiKey: "" });
+    const gitContext = resolveGitContext();
+    const identity = gitContext.identity;
+    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;
+    if (gitContext.warnings.length > 0) {
+      for (const warning of gitContext.warnings) {
+        p.log.warn(warning);
+      }
+    }
+    p.note(verificationUrlString, "Authorize in your browser");
+    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;
+      }
+      if (shouldOpen) {
+        const opened = await tryOpenBrowser(verificationUrlString);
+        if (opened) {
+          p.log.info("Opened your browser for verification.");
+        } else {
+          p.log.info("Could not open a browser automatically. Use the URL above.");
+        }
+      }
+    }
+    const expiresAt = new Date(start.expiresAt).getTime();
+    spinner4.start("Waiting for browser authorization...");
+    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 browser authorization... (${pendingMessage})`);
+        }
+        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);
+        } else {
+          p.log.error(status.message);
+        }
+        p.cancel("Setup could not be completed.");
+        return 1;
+      }
+      if (status.status === "completed") {
+        spinner4.stop("Authorization complete!");
+        const key = "VOCODER_API_KEY";
+        const desiredLine = `${key}=${status.credentials.apiKey}`;
+        const existingLine = getEnvLine(envPath, key);
+        const isAlreadyCurrent = existingLine === desiredLine;
+        let didOverwrite = false;
+        if (!isAlreadyCurrent) {
+          try {
+            upsertEnvValue({
+              filePath: envPath,
+              key,
+              value: status.credentials.apiKey,
+              allowOverwrite: Boolean(options.yes)
+            });
+            didOverwrite = Boolean(existingLine);
+          } catch (error) {
+            const overwriteConflict = error instanceof Error && error.message.includes(`${key} already exists in ${envPath}`);
+            if (!overwriteConflict) {
+              throw error;
+            }
+            const shouldOverwrite = await p.confirm({
+              message: `${key} already exists in ${envPath}. Overwrite it?`
+            });
+            if (p.isCancel(shouldOverwrite) || !shouldOverwrite) {
+              p.log.warn("Existing VOCODER_API_KEY was not changed.");
+              p.log.info("Re-run with --yes to overwrite it without prompting.");
+              p.cancel("Setup cancelled.");
+              return 1;
+            }
+            upsertEnvValue({
+              filePath: envPath,
+              key,
+              value: status.credentials.apiKey,
+              allowOverwrite: true
+            });
+            didOverwrite = true;
+          }
+        }
+        if (isAlreadyCurrent) {
+          p.log.info(`VOCODER_API_KEY already matches your .env file`);
+        } else if (didOverwrite) {
+          p.log.success(`Updated VOCODER_API_KEY in .env`);
+        } else {
+          p.log.success(`Wrote VOCODER_API_KEY to .env`);
+        }
+        p.outro("Vocoder initialized successfully!");
+        p.log.info(`Project:   ${status.credentials.projectName}`);
+        p.log.info(`Workspace: ${status.credentials.organizationName}`);
+        return 0;
+      }
+    }
+    spinner4.stop("Authorization timed out");
+    p.log.error("Authorization timed out. Run `vocoder init` again.");
+    p.cancel("Setup could not be completed.");
+    return 1;
+  } catch (error) {
+    spinner4.stop();
+    if (error instanceof VocoderAPIError && error.limitError) {
+      printPlanLimitMessage(apiUrl, error.limitError.message);
+      p.log.info(`Current: ${error.limitError.current}`);
+      p.log.info(`Required: ${error.limitError.required}`);
+      p.log.info(`Upgrade: ${error.limitError.upgradeUrl}`);
+      return 1;
+    }
+    if (error instanceof Error) {
+      if (isPlanLimitFailure(error.message)) {
+        printPlanLimitMessage(apiUrl, error.message);
+        return 1;
+      }
+      p.log.error(`Error: ${error.message}`);
+    } else {
+      p.log.error("Unknown setup error");
+    }
+    return 1;
+  }
+}
+
+// src/commands/sync.ts
+import * as p2 from "@clack/prompts";
+import { createHash as createHash2, randomUUID } from "crypto";
+
+// src/utils/branch.ts
+import { execSync as execSync2 } from "child_process";
+var REGEX_SPECIAL_CHARS = /[.+?^${}()|[\]\\]/g;
+function escapeRegexChar(value) {
+  return value.replace(REGEX_SPECIAL_CHARS, "\\$&");
+}
+function detectBranch(override) {
+  if (override) {
+    return override;
+  }
+  const envBranch = process.env.GITHUB_HEAD_REF || // GitHub Actions (PR source branch)
+  process.env.GITHUB_REF_NAME || // GitHub Actions (push)
+  process.env.VERCEL_GIT_COMMIT_REF || // Vercel
+  process.env.BRANCH || // Netlify
+  process.env.CF_PAGES_BRANCH || // Cloudflare Pages
+  process.env.CI_COMMIT_REF_NAME || // GitLab CI
+  process.env.BITBUCKET_BRANCH || // Bitbucket Pipelines
+  process.env.CIRCLE_BRANCH || // CircleCI
+  process.env.RENDER_GIT_BRANCH;
+  if (envBranch) {
+    return envBranch;
+  }
+  try {
+    const branch = execSync2("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    return branch;
+  } catch (error) {
+    throw new Error(
+      "Failed to detect git branch. Make sure you are in a git repository or set the --branch flag."
+    );
+  }
+}
+function isTargetBranch(currentBranch, targetBranches) {
+  return targetBranches.some(
+    (pattern) => matchBranchPattern(currentBranch, pattern)
+  );
+}
+function matchBranchPattern(branch, pattern) {
+  const trimmedPattern = pattern.trim();
+  if (!trimmedPattern) {
+    return false;
+  }
+  let regexSource = "^";
+  for (let i = 0; i < trimmedPattern.length; i += 1) {
+    const char = trimmedPattern[i];
+    if (!char) {
+      continue;
+    }
+    if (char === "*") {
+      const next = trimmedPattern[i + 1];
+      if (next === "*") {
+        regexSource += ".*";
+        i += 1;
+      } else {
+        regexSource += "[^/]*";
+      }
+      continue;
+    }
+    regexSource += escapeRegexChar(char);
+  }
+  regexSource += "$";
+  return new RegExp(regexSource).test(branch);
+}
+
+// src/commands/sync.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+
+// src/utils/config.ts
+import chalk from "chalk";
+import { config as loadEnv } from "dotenv";
+loadEnv();
+function validateLocalConfig(config) {
+  if (!config.apiKey || config.apiKey.length === 0) {
+    throw new Error("VOCODER_API_KEY is required. Set it in your .env file.");
+  }
+  if (!config.apiKey.startsWith("vc_")) {
+    throw new Error("Invalid API key format. Expected format: vc_...");
+  }
+  if (!config.apiUrl || !config.apiUrl.startsWith("http")) {
+    throw new Error("Invalid API URL");
+  }
+}
+async function getMergedConfig(cliOptions, verbose = false, _startDir) {
+  const configSources = {
+    extractionPattern: "default",
+    excludePattern: "default",
+    apiKey: "environment",
+    apiUrl: "default",
+    mode: "default",
+    maxWaitMs: "default",
+    noFallback: "default"
+  };
+  const defaults = {
+    extractionPattern: ["src/**/*.{tsx,jsx,ts,js}"],
+    excludePattern: [],
+    apiUrl: "https://vocoder.app"
+  };
+  const envExtractionPattern = process.env.VOCODER_EXTRACTION_PATTERN;
+  const envApiUrl = process.env.VOCODER_API_URL;
+  const envSyncMode = process.env.VOCODER_SYNC_MODE;
+  const envSyncMaxWaitMs = process.env.VOCODER_SYNC_MAX_WAIT_MS;
+  const envSyncNoFallback = process.env.VOCODER_SYNC_NO_FALLBACK;
+  let extractionPattern;
+  if (cliOptions.include && cliOptions.include.length > 0) {
+    extractionPattern = cliOptions.include;
+    configSources.extractionPattern = "CLI flag";
+  } else if (envExtractionPattern) {
+    extractionPattern = [envExtractionPattern];
+    configSources.extractionPattern = "environment";
+  } else {
+    extractionPattern = defaults.extractionPattern;
+  }
+  let excludePattern;
+  if (cliOptions.exclude && cliOptions.exclude.length > 0) {
+    excludePattern = cliOptions.exclude;
+    configSources.excludePattern = "CLI flag";
+  } else {
+    excludePattern = defaults.excludePattern;
+  }
+  let apiKey;
+  if (process.env.VOCODER_API_KEY) {
+    apiKey = process.env.VOCODER_API_KEY;
+    configSources.apiKey = "environment";
+  }
+  let apiUrl;
+  if (envApiUrl) {
+    apiUrl = envApiUrl;
+    configSources.apiUrl = "environment";
+  } else {
+    apiUrl = defaults.apiUrl;
+  }
+  const modeCandidates = ["auto", "required", "best-effort"];
+  let mode = "auto";
+  if (cliOptions.mode && modeCandidates.includes(cliOptions.mode)) {
+    mode = cliOptions.mode;
+    configSources.mode = "CLI flag";
+  } else if (envSyncMode && modeCandidates.includes(envSyncMode)) {
+    mode = envSyncMode;
+    configSources.mode = "environment";
+  }
+  let maxWaitMs;
+  if (typeof cliOptions.maxWaitMs === "number" && Number.isFinite(cliOptions.maxWaitMs) && cliOptions.maxWaitMs > 0) {
+    maxWaitMs = Math.floor(cliOptions.maxWaitMs);
+    configSources.maxWaitMs = "CLI flag";
+  } else if (envSyncMaxWaitMs) {
+    const parsed = Number.parseInt(envSyncMaxWaitMs, 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      maxWaitMs = parsed;
+      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(chalk.dim("\n   Configuration sources:"));
+    console.log(chalk.dim(`     Include patterns: ${configSources.extractionPattern}`));
+    if (excludePattern.length > 0) {
+      console.log(chalk.dim(`     Exclude patterns: ${configSources.excludePattern}`));
+    }
+    console.log(chalk.dim(`     API key: ${configSources.apiKey}`));
+    console.log(chalk.dim(`     API URL: ${configSources.apiUrl}
+`));
+    console.log(chalk.dim(`     Sync mode: ${configSources.mode}`));
+    if (maxWaitMs) {
+      console.log(chalk.dim(`     Max wait: ${configSources.maxWaitMs}`));
+    }
+    console.log(chalk.dim(`     No fallback: ${configSources.noFallback}
+`));
+  }
+  return {
+    extractionPattern,
+    excludePattern,
+    apiKey,
+    apiUrl,
+    mode,
+    maxWaitMs,
+    noFallback,
+    configSources
+  };
+}
+
+// src/utils/extract.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2 } 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 = readFileSync2(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()}`;
+  }
+};
+
+// src/commands/sync.ts
+import chalk2 from "chalk";
+import { join as join2 } from "path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseLocaleMetadata(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const metadata = {};
+  for (const [locale, rawValue] of Object.entries(value)) {
+    if (!isRecord(rawValue)) {
+      continue;
+    }
+    const nativeName = rawValue.nativeName;
+    if (typeof nativeName !== "string" || nativeName.trim().length === 0) {
+      continue;
+    }
+    const entry = { nativeName };
+    if (rawValue.dir === "rtl") {
+      entry.dir = "rtl";
+    }
+    metadata[locale] = entry;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function parseTranslations(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const translations = {};
+  for (const [locale, localeValue] of Object.entries(value)) {
+    if (!isRecord(localeValue)) {
+      continue;
+    }
+    const localeTranslations = {};
+    for (const [source, translated] of Object.entries(localeValue)) {
+      if (typeof translated === "string") {
+        localeTranslations[source] = translated;
+      }
+    }
+    translations[locale] = localeTranslations;
+  }
+  return Object.keys(translations).length > 0 ? translations : null;
+}
+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 filename = `${slug || "branch"}-${branchHash}.json`;
+  return join2(projectRoot, ".vocoder", "cache", "sync", filename);
+}
+function readLocalSnapshotCache(params) {
+  const candidateBranches = params.branch === "main" ? ["main"] : [params.branch, "main"];
+  for (const candidateBranch of candidateBranches) {
+    const cacheFilePath = getCacheFilePath(params.projectRoot, candidateBranch);
+    if (!existsSync2(cacheFilePath)) {
+      continue;
+    }
+    try {
+      const raw = readFileSync3(cacheFilePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!isRecord(parsed)) {
+        continue;
+      }
+      const translations = parseTranslations(parsed.translations);
+      if (!translations) {
+        continue;
+      }
+      const localeMetadata = parseLocaleMetadata(parsed.localeMetadata);
+      return {
+        source: "local-cache",
+        translations,
+        localeMetadata,
+        snapshotBatchId: typeof parsed.snapshotBatchId === "string" ? parsed.snapshotBatchId : void 0,
+        completedAt: typeof parsed.completedAt === "string" ? parsed.completedAt : null,
+        cacheBranch: candidateBranch
+      };
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function writeLocalSnapshotCache(params) {
+  const cacheFilePath = getCacheFilePath(params.projectRoot, params.branch);
+  mkdirSync(join2(params.projectRoot, ".vocoder", "cache", "sync"), {
+    recursive: true
+  });
+  const payload = {
+    version: 1,
+    branch: params.branch,
+    sourceLocale: params.sourceLocale,
+    targetLocales: params.targetLocales,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...params.snapshotBatchId ? { snapshotBatchId: params.snapshotBatchId } : {},
+    ...params.completedAt ? { completedAt: params.completedAt } : {},
+    ...params.localeMetadata ? { localeMetadata: params.localeMetadata } : {},
+    translations: params.translations
+  };
+  writeFileSync2(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
+  return cacheFilePath;
+}
+function resolveEffectiveModeFromPolicy(params) {
+  const { requestedMode, policy, branch } = params;
+  let mode;
+  if (requestedMode === "auto") {
+    const isBlockingBranch = isTargetBranch(branch, policy.blockingBranches);
+    mode = isBlockingBranch ? policy.blockingMode : policy.nonBlockingMode;
+  } else {
+    mode = requestedMode;
+  }
+  return mode;
+}
+function resolveWaitTimeoutMs(params) {
+  if (typeof params.requestedMaxWaitMs === "number" && Number.isFinite(params.requestedMaxWaitMs) && params.requestedMaxWaitMs > 0) {
+    return Math.floor(params.requestedMaxWaitMs);
+  }
+  if (typeof params.policyDefaultMaxWaitMs === "number" && Number.isFinite(params.policyDefaultMaxWaitMs) && params.policyDefaultMaxWaitMs > 0) {
+    return Math.floor(params.policyDefaultMaxWaitMs);
+  }
+  return params.fallbackTimeoutMs;
+}
+function normalizeTranslations(params) {
+  const merged = {};
+  for (const [locale, values] of Object.entries(params.translations)) {
+    merged[locale] = { ...values };
+  }
+  const expectedLocales = [
+    params.sourceLocale,
+    ...params.targetLocales.filter((locale) => locale !== params.sourceLocale)
+  ];
+  for (const locale of expectedLocales) {
+    if (!merged[locale]) {
+      merged[locale] = {};
+    }
+  }
+  if (!merged[params.sourceLocale]) {
+    merged[params.sourceLocale] = {};
+  }
+  for (const sourceText of params.sourceStrings) {
+    if (!(sourceText in merged[params.sourceLocale])) {
+      merged[params.sourceLocale][sourceText] = sourceText;
+    }
+  }
+  return merged;
+}
+function getLimitErrorGuidance(limitError) {
+  if (limitError.limitType === "providers") {
+    return [
+      "Provider setup required.",
+      "Add a DeepL API key in Dashboard -> Workspace Settings -> Providers.",
+      `Open settings: ${limitError.upgradeUrl}`
+    ];
+  }
+  if (limitError.limitType === "translation_chars") {
+    return [
+      "Monthly translation character limit reached.",
+      `Used this month: ${limitError.current.toLocaleString()} chars`,
+      `Requested after sync: ${limitError.required.toLocaleString()} chars`,
+      `Upgrade plan: ${limitError.upgradeUrl}`
+    ];
+  }
+  if (limitError.limitType === "source_strings") {
+    return [
+      "Active source string limit reached.",
+      `Current active strings: ${limitError.current.toLocaleString()}`,
+      `Required for this sync: ${limitError.required.toLocaleString()}`,
+      `Upgrade plan: ${limitError.upgradeUrl}`
+    ];
+  }
+  return [
+    `Plan: ${limitError.planId}`,
+    `Current: ${limitError.current}`,
+    `Required: ${limitError.required}`,
+    `Upgrade: ${limitError.upgradeUrl}`
+  ];
+}
+function getSyncPolicyErrorGuidance(error) {
+  if (error.errorCode === "BRANCH_NOT_ALLOWED") {
+    const lines2 = ["This branch is not allowed for this project."];
+    if (error.branch) {
+      lines2.push(`Current branch: ${error.branch}`);
+    }
+    if (error.targetBranches && error.targetBranches.length > 0) {
+      lines2.push(`Allowed branches: ${error.targetBranches.join(", ")}`);
+    }
+    lines2.push("Update your project target branches in the dashboard if needed.");
+    return lines2;
+  }
+  const lines = ["This project is bound to a different repository."];
+  if (error.boundRepoLabel) {
+    lines.push(`Bound repository: ${error.boundRepoLabel}`);
+  }
+  if (error.boundScopePath) {
+    lines.push(`Bound scope: ${error.boundScopePath}`);
+  }
+  lines.push(
+    "Run `vocoder init` from the correct repository or create a separate project."
+  );
+  return lines;
+}
+function mergeContext(current, incoming) {
+  if (!incoming) return current;
+  if (!current) return incoming;
+  if (current === incoming) return current;
+  const merged = new Set(
+    [...current.split(" | "), ...incoming.split(" | ")].map((part) => part.trim()).filter(Boolean)
+  );
+  return Array.from(merged).join(" | ");
+}
+function buildStringEntries(extractedStrings) {
+  const byText = /* @__PURE__ */ new Map();
+  for (const str of extractedStrings) {
+    const existing = byText.get(str.text);
+    if (!existing) {
+      byText.set(str.text, {
+        key: str.key,
+        text: str.text,
+        ...str.context ? { context: str.context } : {},
+        ...str.formality ? { formality: str.formality } : {}
+      });
+      continue;
+    }
+    existing.context = mergeContext(existing.context, str.context);
+    if (!existing.formality && str.formality) {
+      existing.formality = str.formality;
+    } else if (existing.formality && str.formality && existing.formality !== str.formality) {
+      existing.formality = "auto";
+    }
+    if (str.key < existing.key) {
+      existing.key = str.key;
+    }
+  }
+  return Array.from(byText.values());
+}
+async function fetchApiSnapshot(api, params) {
+  const snapshot = await api.getTranslationSnapshot({
+    branch: params.branch,
+    targetLocales: params.targetLocales
+  });
+  if (snapshot.status !== "FOUND" || !snapshot.translations) {
+    return null;
+  }
+  return {
+    source: "api-snapshot",
+    translations: snapshot.translations,
+    localeMetadata: snapshot.localeMetadata,
+    snapshotBatchId: snapshot.snapshotBatchId,
+    completedAt: snapshot.completedAt
+  };
+}
+async function sync(options = {}) {
+  const startTime = Date.now();
+  const projectRoot = process.cwd();
+  p2.intro("Vocoder Sync");
+  const spinner4 = p2.spinner();
+  try {
+    spinner4.start("Detecting branch");
+    const branch = detectBranch(options.branch);
+    spinner4.stop(`Branch: ${chalk2.cyan(branch)}`);
+    spinner4.start("Loading project configuration");
+    const mergedConfig = await getMergedConfig(options, options.verbose);
+    const localConfig = {
+      apiKey: mergedConfig.apiKey || "",
+      apiUrl: mergedConfig.apiUrl || "https://vocoder.app"
+    };
+    validateLocalConfig(localConfig);
+    const api = new VocoderAPI(localConfig);
+    const apiConfig = await api.getProjectConfig();
+    const requestedMode = mergedConfig.mode;
+    const waitTimeoutMs = resolveWaitTimeoutMs({
+      requestedMaxWaitMs: mergedConfig.maxWaitMs,
+      policyDefaultMaxWaitMs: apiConfig.syncPolicy.defaultMaxWaitMs,
+      fallbackTimeoutMs: 6e4
+    });
+    const config = {
+      ...localConfig,
+      ...apiConfig,
+      extractionPattern: mergedConfig.extractionPattern,
+      excludePattern: mergedConfig.excludePattern,
+      timeout: waitTimeoutMs
+    };
+    spinner4.stop("Project configuration loaded");
+    if (!options.force && !isTargetBranch(branch, config.targetBranches)) {
+      p2.log.warn(
+        `Skipping translations (${chalk2.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("");
+      return 0;
+    }
+    const patternsDisplay = Array.isArray(config.extractionPattern) ? config.extractionPattern.join(", ") : config.extractionPattern;
+    spinner4.start(`Extracting strings from ${patternsDisplay}`);
+    const extractor = new StringExtractor();
+    const extractedStrings = await extractor.extractFromProject(
+      config.extractionPattern,
+      projectRoot,
+      config.excludePattern
+    );
+    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("");
+      return 0;
+    }
+    spinner4.stop(
+      `Extracted ${chalk2.cyan(extractedStrings.length)} strings from ${chalk2.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");
+    }
+    if (options.dryRun) {
+      p2.note(
+        [
+          `Strings: ${extractedStrings.length}`,
+          `Branch: ${branch}`,
+          `Target locales: ${config.targetLocales.join(", ")}`,
+          `Requested mode: ${requestedMode}`,
+          `Max wait: ${waitTimeoutMs}ms`,
+          `No fallback: ${mergedConfig.noFallback ? "yes" : "no"}`
+        ].join("\n"),
+        "Dry run - would translate"
+      );
+      p2.outro("No API calls made.");
+      return 0;
+    }
+    const repoIdentity = resolveGitRepositoryIdentity();
+    if (!repoIdentity && options.verbose) {
+      p2.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(
+        `Deduped ${extractedStrings.length} extracted entries into ${stringEntries.length} unique source strings`
+      );
+    }
+    spinner4.start("Submitting strings to Vocoder API");
+    const batchResponse = await api.submitTranslation(
+      branch,
+      stringEntries,
+      config.targetLocales,
+      {
+        requestedMode,
+        requestedMaxWaitMs: waitTimeoutMs,
+        clientRunId: randomUUID()
+      },
+      repoIdentity ?? void 0
+    );
+    spinner4.stop(`Submitted to API - Batch ${chalk2.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`);
+      if (batchResponse.queueStatus) {
+        p2.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");
+    }
+    p2.log.info(`New strings: ${chalk2.cyan(batchResponse.newStrings)}`);
+    if (batchResponse.deletedStrings && batchResponse.deletedStrings > 0) {
+      p2.log.info(
+        `Deleted strings: ${chalk2.yellow(batchResponse.deletedStrings)} (archived)`
+      );
+    }
+    p2.log.info(`Total strings: ${chalk2.cyan(batchResponse.totalStrings)}`);
+    if (batchResponse.newStrings === 0) {
+      p2.log.success("No new strings - using existing translations");
+    } else {
+      p2.log.info(
+        `Syncing to ${config.targetLocales.length} locales (${config.targetLocales.join(", ")})`
+      );
+      if (batchResponse.estimatedTime) {
+        p2.log.info(`Estimated time: ~${batchResponse.estimatedTime}s`);
+      }
+    }
+    let artifacts = null;
+    if (batchResponse.translations) {
+      artifacts = {
+        source: "fresh",
+        translations: batchResponse.translations
+      };
+    }
+    let waitError = null;
+    if (!artifacts && (effectiveMode === "required" || effectiveMode === "best-effort")) {
+      spinner4.start(`Waiting for translations (max ${waitTimeoutMs}ms)`);
+      let lastProgress = 0;
+      try {
+        const completion = await api.waitForCompletion(
+          batchResponse.batchId,
+          waitTimeoutMs,
+          (progress) => {
+            const percent = Math.round(progress * 100);
+            if (percent > lastProgress) {
+              spinner4.message(`Translating... ${percent}%`);
+              lastProgress = percent;
+            }
+          }
+        );
+        artifacts = {
+          source: "fresh",
+          translations: completion.translations,
+          localeMetadata: completion.localeMetadata
+        };
+        spinner4.stop("Translations complete");
+      } catch (error) {
+        spinner4.stop("Translation wait incomplete");
+        waitError = error instanceof Error ? error : new Error(String(error));
+        if (effectiveMode === "required") {
+          throw waitError;
+        }
+        p2.log.warn(`Best-effort wait ended early: ${waitError.message}`);
+      }
+    }
+    if (!artifacts) {
+      if (mergedConfig.noFallback) {
+        throw new Error(
+          "Fresh translations are not available and fallback is disabled (--no-fallback)."
+        );
+      }
+      spinner4.start("Loading fallback translations");
+      const localFallback = readLocalSnapshotCache({
+        projectRoot,
+        branch
+      });
+      if (localFallback) {
+        artifacts = localFallback;
+        const cacheBranchLabel = localFallback.cacheBranch && localFallback.cacheBranch !== branch ? `${localFallback.cacheBranch} fallback` : localFallback.cacheBranch || branch;
+        spinner4.stop(`Using local cached snapshot (${cacheBranchLabel})`);
+      } else {
+        try {
+          const apiSnapshot = await fetchApiSnapshot(api, {
+            branch,
+            targetLocales: config.targetLocales
+          });
+          if (apiSnapshot) {
+            artifacts = apiSnapshot;
+            spinner4.stop("Using latest completed API snapshot");
+          } else {
+            spinner4.stop("No completed API snapshot available");
+          }
+        } catch (error) {
+          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}`);
+          }
+        }
+      }
+      if (!artifacts) {
+        if (waitError) {
+          throw new Error(
+            `No fallback snapshot available after wait failure: ${waitError.message}`
+          );
+        }
+        throw new Error(
+          "No fallback snapshot available. Try again shortly or run with --mode required."
+        );
+      }
+    }
+    const finalTranslations = normalizeTranslations({
+      sourceLocale: config.sourceLocale,
+      targetLocales: config.targetLocales,
+      sourceStrings,
+      translations: artifacts.translations
+    });
+    try {
+      const cachePath = writeLocalSnapshotCache({
+        projectRoot,
+        branch,
+        sourceLocale: config.sourceLocale,
+        targetLocales: config.targetLocales,
+        translations: finalTranslations,
+        localeMetadata: artifacts.localeMetadata,
+        snapshotBatchId: artifacts.snapshotBatchId ?? (artifacts.source === "fresh" ? batchResponse.batchId : batchResponse.latestCompletedBatchId),
+        completedAt: artifacts.completedAt ?? (artifacts.source === "fresh" ? (/* @__PURE__ */ new Date()).toISOString() : null)
+      });
+      if (options.verbose) {
+        p2.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}`);
+      }
+    }
+    if (artifacts.source !== "fresh") {
+      const sourceLabel = artifacts.source === "local-cache" ? "local cached snapshot" : "completed API snapshot";
+      p2.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.");
+    return 0;
+  } catch (error) {
+    spinner4.stop();
+    if (error instanceof VocoderAPIError && error.syncPolicyError) {
+      p2.log.error(error.syncPolicyError.message);
+      const guidance = getSyncPolicyErrorGuidance(error.syncPolicyError);
+      for (const line of guidance) {
+        p2.log.info(line);
+      }
+      return 1;
+    }
+    if (error instanceof VocoderAPIError && error.limitError) {
+      const { limitError } = error;
+      p2.log.error(limitError.message);
+      const guidance = getLimitErrorGuidance(limitError);
+      for (const line of guidance) {
+        p2.log.info(line);
+      }
+      return 1;
+    }
+    if (error instanceof Error) {
+      p2.log.error(error.message);
+      if (error.message.includes("VOCODER_API_KEY")) {
+        p2.log.warn("Set your API key:");
+        p2.log.info('  export VOCODER_API_KEY="your-api-key"');
+        p2.log.info("  or add it to your .env file");
+      } else if (error.message.includes("git branch")) {
+        p2.log.warn("Run from a git repository, or use:");
+        p2.log.info("  vocoder sync --branch main");
+      }
+      if (options.verbose) {
+        p2.log.info(`Full error: ${error.stack ?? error}`);
+      }
+    }
+    return 1;
+  }
+}
+
+// src/commands/wrap.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { relative as relative2 } from "path";
+import * as p3 from "@clack/prompts";
+import chalk3 from "chalk";
+
+// src/utils/wrap/analyzer.ts
+import { readFileSync as readFileSync4 } 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 = readFileSync4(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/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();
+  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 ${chalk3.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 ${chalk3.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 ${chalk3.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(chalk3.bold(relPath));
+        for (const c of candidates) {
+          const confidenceColor = c.confidence === "high" ? chalk3.green : c.confidence === "medium" ? chalk3.yellow : chalk3.red;
+          const strategyLabel = c.strategy === "T-component" ? "<T>" : "t()";
+          lines.push(
+            `  ${chalk3.dim(`L${c.line}`)} ${confidenceColor(`[${c.confidence}]`)} ${chalk3.cyan(strategyLabel)} "${truncate(c.text, 50)}"`
+          );
+          if (options.verbose) {
+            lines.push(chalk3.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 = readFileSync5(file, "utf-8");
+      const result = transformer.transform(code, candidates, file);
+      if (result.wrappedCount > 0) {
+        writeFileSync3(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}`);
+      }
+    }
+    spinner4.stop(
+      `Wrapped ${chalk3.cyan(totalWrapped)} strings across ${chalk3.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');
+    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}`);
+      }
+    }
+    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(chalk3.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(chalk3.green(`${high} high`));
+  if (medium > 0) parts.push(chalk3.yellow(`${medium} medium`));
+  if (low > 0) parts.push(chalk3.red(`${low} low`));
+  return `${candidates.length} total (${parts.join(", ")}) | ${tComponent} <T>, ${tFunction} t()`;
+}
+
+// src/bin.ts
+function collect(value, previous = []) {
+  return previous.concat([value]);
+}
+async function runCommand(command, options) {
+  const exitCode = await command(options);
+  process.exitCode = exitCode;
+}
 var program = new Command();
-program.name("vocoder").description("Vocoder CLI - Sync translations for your application").version("0.1.0");
-program.command("sync").description("Extract strings and sync translations").option("--branch <name>", "Override branch detection").option("--force", "Sync even if not a target branch").option("--dry-run", "Show what would be synced without doing it").option("--verbose", "Show detailed progress").option("--max-age <seconds>", "Use cache if younger than this (seconds)", parseInt).action(sync);
+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.parse(process.argv);
 //# sourceMappingURL=bin.mjs.map