@vocoder/cli 0.1.3 → 0.1.6

package/dist/bin.mjs

@@ -5,6 +5,7 @@ import { Command } from "commander";
 
 // src/commands/init.ts
 import * as p from "@clack/prompts";
+import chalk from "chalk";
 
 // src/utils/api.ts
 function isLimitErrorResponse(value) {
@@ -254,11 +255,294 @@ var VocoderAPI = class {
     }
     return payload;
   }
+  /**
+   * Look up whether a project already exists for a given repo + scope.
+   * Returns { projectId, projectName, organizationName } or null if not found.
+   */
+  async lookupProjectByRepo(params) {
+    try {
+      const response = await fetch(`${this.apiUrl}/api/cli/init/lookup`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          repo: params.repoCanonical,
+          scopePath: params.scopePath
+        })
+      });
+      if (response.status === 404) return null;
+      if (!response.ok) return null;
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
 };
 
-// src/commands/init.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
+// src/utils/detect-local.ts
+import { existsSync, readFileSync } from "fs";
 import { join } from "path";
+function detectLocalEcosystem(cwd = process.cwd()) {
+  const packageManager = detectPackageManager(cwd);
+  const pkg = readPackageJson(cwd);
+  if (!pkg) {
+    return {
+      ecosystem: null,
+      framework: null,
+      packageManager,
+      uiPackage: null,
+      hasUnplugin: false,
+      hasUiPackage: false,
+      sourceLocale: null
+    };
+  }
+  const allDeps = {
+    ...pkg.dependencies ?? {},
+    ...pkg.devDependencies ?? {}
+  };
+  const hasUnplugin = "@vocoder/unplugin" in allDeps;
+  const { ecosystem, framework, uiPackage } = detectFromDeps(allDeps, cwd);
+  const hasUiPackage = uiPackage !== null && uiPackage in allDeps;
+  return {
+    ecosystem,
+    framework,
+    packageManager,
+    uiPackage,
+    hasUnplugin,
+    hasUiPackage,
+    sourceLocale: null
+  };
+}
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) return "bun";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function readPackageJson(cwd) {
+  const pkgPath = join(cwd, "package.json");
+  if (!existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(readFileSync(pkgPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function detectFromDeps(allDeps, cwd) {
+  if ("vue" in allDeps) {
+    const framework = "nuxt" in allDeps ? "nuxt" : null;
+    return { ecosystem: "vue", framework, uiPackage: "@vocoder/vue" };
+  }
+  if ("svelte" in allDeps) {
+    const framework = "@sveltejs/kit" in allDeps ? "sveltekit" : null;
+    return { ecosystem: "svelte", framework, uiPackage: "@vocoder/svelte" };
+  }
+  if ("@angular/core" in allDeps || existsSync(join(cwd, "angular.json"))) {
+    return { ecosystem: "angular", framework: "angular", uiPackage: "@vocoder/angular" };
+  }
+  if ("react" in allDeps) {
+    let framework = null;
+    if ("next" in allDeps) framework = "nextjs";
+    else if ("@remix-run/react" in allDeps) framework = "remix";
+    else if ("gatsby" in allDeps) framework = "gatsby";
+    else if ("vite" in allDeps) framework = "vite";
+    return { ecosystem: "react", framework, uiPackage: "@vocoder/react" };
+  }
+  return { ecosystem: null, framework: null, uiPackage: null };
+}
+function buildInstallCommand(packageManager, packages) {
+  if (packages.length === 0) return "";
+  const pkgList = packages.join(" ");
+  switch (packageManager) {
+    case "pnpm":
+      return `pnpm add ${pkgList}`;
+    case "yarn":
+      return `yarn add ${pkgList}`;
+    case "bun":
+      return `bun add ${pkgList}`;
+    default:
+      return `npm install ${pkgList}`;
+  }
+}
+function getPackagesToInstall(detection) {
+  const packages = [];
+  if (!detection.hasUnplugin) packages.push("@vocoder/unplugin");
+  if (detection.uiPackage && !detection.hasUiPackage) packages.push(detection.uiPackage);
+  return packages;
+}
+
+// src/utils/setup-snippets.ts
+function getSetupSnippets(params) {
+  const { framework, ecosystem, sourceLocale, translationTriggers } = params;
+  return {
+    pluginStep: getPluginSnippet(framework, ecosystem),
+    providerStep: getProviderSnippet(ecosystem, sourceLocale),
+    wrapStep: getWrapSnippet(ecosystem),
+    whatsNext: getWhatsNextMessage(translationTriggers)
+  };
+}
+function getPluginSnippet(framework, ecosystem) {
+  switch (framework) {
+    case "nextjs":
+      return {
+        file: "next.config.ts",
+        code: `import { withVocoder } from '@vocoder/unplugin/next';
+
+export default withVocoder({
+  // your existing Next.js config
+});`
+      };
+    case "vite":
+    case "remix":
+      return {
+        file: "vite.config.ts",
+        code: `import vocoder from '@vocoder/unplugin/vite';
+
+export default defineConfig({
+  plugins: [
+    vocoder(),
+    // your other plugins
+  ],
+});`
+      };
+    case "nuxt":
+      return {
+        file: "nuxt.config.ts",
+        code: `import vocoder from '@vocoder/unplugin/vite';
+
+export default defineNuxtConfig({
+  vite: {
+    plugins: [vocoder()],
+  },
+});`
+      };
+    case "sveltekit":
+      return {
+        file: "vite.config.ts",
+        code: `import vocoder from '@vocoder/unplugin/vite';
+import { sveltekit } from '@sveltejs/kit/vite';
+
+export default defineConfig({
+  plugins: [
+    sveltekit(),
+    vocoder(),
+  ],
+});`
+      };
+    case "gatsby":
+      return {
+        file: "gatsby-node.js",
+        code: `const vocoder = require('@vocoder/unplugin/webpack');
+
+exports.onCreateWebpackConfig = ({ actions }) => {
+  actions.setWebpackConfig({
+    plugins: [vocoder()],
+  });
+};`
+      };
+    case "angular":
+      return null;
+    // Angular CLI doesn't expose plugin config easily
+    default:
+      if (ecosystem) {
+        return {
+          file: "your bundler config",
+          code: `// Vite
+import vocoder from '@vocoder/unplugin/vite';
+// Webpack
+const vocoder = require('@vocoder/unplugin/webpack');
+
+// Add vocoder() to your plugins array`
+        };
+      }
+      return null;
+  }
+}
+function getProviderSnippet(ecosystem, sourceLocale) {
+  switch (ecosystem) {
+    case "react":
+      return {
+        file: "your root layout or App component",
+        code: `import { VocoderProvider } from '@vocoder/react';
+
+<VocoderProvider defaultLocale="${sourceLocale}">
+  {children}
+</VocoderProvider>`
+      };
+    case "vue":
+      return {
+        file: "your app entry",
+        code: `import { createVocoder } from '@vocoder/vue';
+
+const vocoder = createVocoder({
+  defaultLocale: '${sourceLocale}',
+});
+
+app.use(vocoder);`
+      };
+    case "svelte":
+      return {
+        file: "your root layout",
+        code: `<script>
+  import { VocoderProvider } from '@vocoder/svelte';
+</script>
+
+<VocoderProvider defaultLocale="${sourceLocale}">
+  <slot />
+</VocoderProvider>`
+      };
+    default:
+      return null;
+  }
+}
+function getWrapSnippet(ecosystem) {
+  switch (ecosystem) {
+    case "react":
+      return {
+        code: `import { T } from '@vocoder/react';
+
+<T>Hello, world!</T>`
+      };
+    case "vue":
+      return {
+        code: `<template>
+  <T>Hello, world!</T>
+</template>
+
+<script setup>
+import { T } from '@vocoder/vue';
+</script>`
+      };
+    case "svelte":
+      return {
+        code: `<script>
+  import { T } from '@vocoder/svelte';
+</script>
+
+<T>Hello, world!</T>`
+      };
+    default:
+      return {
+        code: `// Wrap translatable strings with <T>
+<T>Hello, world!</T>`
+      };
+  }
+}
+function getWhatsNextMessage(triggers) {
+  const parts = [];
+  if (triggers.includes("push")) {
+    parts.push("Push to a target branch to trigger translations.");
+  }
+  if (triggers.includes("pull_request")) {
+    parts.push("Open a pull request to trigger translations.");
+  }
+  if (triggers.includes("manual")) {
+    parts.push("Run `vocoder sync` to extract and translate.");
+  }
+  if (parts.length === 0) {
+    parts.push("Push to a target branch to trigger translations.");
+  }
+  return parts.join("\n");
+}
 
 // src/utils/git-identity.ts
 import { execSync } from "child_process";
@@ -357,57 +641,16 @@ function resolveGitContext() {
 }
 
 // src/commands/init.ts
+import { config as loadEnv } from "dotenv";
+import { execSync as execSync2 } from "child_process";
 import { spawn } from "child_process";
+loadEnv();
 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));
 }
@@ -468,76 +711,107 @@ function printPlanLimitMessage(apiUrl, message) {
    ${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)}`;
+function runScaffold(params) {
+  const { projectName, organizationName, sourceLocale, translationTriggers } = params;
+  p.log.info(`Project:   ${chalk.bold(projectName)}`);
+  p.log.info(`Workspace: ${chalk.bold(organizationName)}`);
+  const detection = detectLocalEcosystem();
+  if (detection.ecosystem) {
+    const frameworkLabel = detection.framework ?? detection.ecosystem;
+    const pmLabel = detection.packageManager;
+    p.log.info(`Detected:  ${chalk.bold(frameworkLabel)} (${pmLabel})`);
+  }
+  const packagesToInstall = getPackagesToInstall(detection);
+  if (packagesToInstall.length > 0) {
+    const installCmd = buildInstallCommand(detection.packageManager, packagesToInstall);
+    p.log.info("");
+    const installSpinner = p.spinner();
+    installSpinner.start(`Installing ${packagesToInstall.join(", ")}...`);
+    try {
+      execSync2(installCmd, { stdio: "pipe", cwd: process.cwd() });
+      installSpinner.stop(`Installed ${packagesToInstall.join(", ")}`);
+    } catch {
+      installSpinner.stop("Package installation failed");
+      p.log.warn(`Run manually: ${chalk.cyan(installCmd)}`);
+    }
+  } else if (detection.ecosystem) {
+    p.log.info(`Packages:  ${chalk.green("already installed")}`);
+  }
+  const snippets = getSetupSnippets({
+    framework: detection.framework,
+    ecosystem: detection.ecosystem,
+    sourceLocale,
+    translationTriggers
+  });
+  let stepNum = 1;
+  if (snippets.pluginStep) {
+    p.log.message("");
+    p.log.step(`${chalk.bold(`Step ${stepNum}:`)} Add the plugin to ${chalk.cyan(snippets.pluginStep.file)}`);
+    printCodeBlock(snippets.pluginStep.code);
+    stepNum++;
+  }
+  if (snippets.providerStep) {
+    p.log.step(`${chalk.bold(`Step ${stepNum}:`)} Add the provider to ${chalk.cyan(snippets.providerStep.file)}`);
+    printCodeBlock(snippets.providerStep.code);
+    stepNum++;
+  }
+  p.log.step(`${chalk.bold(`Step ${stepNum}:`)} Wrap translatable strings`);
+  printCodeBlock(snippets.wrapStep.code);
+  p.log.message("");
+  for (const line of snippets.whatsNext.split("\n")) {
+    p.log.success(line);
+  }
+}
+function printCodeBlock(code) {
+  const lines = code.split("\n");
+  const maxLen = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  const bar = chalk.gray("\u2502");
+  const pad = (s) => s + " ".repeat(maxLen - s.length);
+  process.stdout.write(`${chalk.gray("\u2502")}
+`);
+  process.stdout.write(`${chalk.gray("\u2502")}  ${chalk.gray("\u250C" + "\u2500".repeat(maxLen + 2) + "\u2510")}
+`);
+  for (const line of lines) {
+    process.stdout.write(`${chalk.gray("\u2502")}  ${bar} ${pad(line)} ${bar}
+`);
+  }
+  process.stdout.write(`${chalk.gray("\u2502")}  ${chalk.gray("\u2514" + "\u2500".repeat(maxLen + 2) + "\u2518")}
+`);
 }
 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();
+  const spinner3 = 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)" }
-          ]
+    const gitContext = resolveGitContext();
+    const identity = gitContext.identity;
+    if (gitContext.warnings.length > 0) {
+      for (const warning of gitContext.warnings) {
+        p.log.warn(warning);
+      }
+    }
+    if (identity) {
+      spinner3.start("Checking for existing project...");
+      const api2 = new VocoderAPI({ apiUrl, apiKey: "" });
+      const existing = await api2.lookupProjectByRepo({
+        repoCanonical: identity.repoCanonical,
+        scopePath: identity.repoScopePath
+      });
+      if (existing) {
+        spinner3.stop("Found existing project!");
+        p.outro("Vocoder is already set up for this repository.");
+        runScaffold({
+          projectName: existing.projectName,
+          organizationName: existing.organizationName,
+          sourceLocale: existing.sourceLocale ?? "en",
+          translationTriggers: existing.translationTriggers ?? ["push"]
         });
-        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;
-          }
-        }
+        return 0;
       }
+      spinner3.stop("No existing project found for this repo.");
     }
-    spinner4.start("Creating setup session");
+    spinner3.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,
@@ -545,14 +819,10 @@ async function init(options = {}) {
       ...identity?.repoCanonical ? { repoCanonical: identity.repoCanonical } : {},
       ...identity ? { repoScopePath: identity.repoScopePath } : {}
     });
-    spinner4.stop("Setup session created");
+    spinner3.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");
+    p.log.info("Create a project in your browser to continue.");
+    p.note(verificationUrlString, "Setup URL");
     if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
       const shouldOpen = options.yes ? true : await p.confirm({ message: "Open this URL in your browser?" });
       if (p.isCancel(shouldOpen)) {
@@ -562,14 +832,14 @@ async function init(options = {}) {
       if (shouldOpen) {
         const opened = await tryOpenBrowser(verificationUrlString);
         if (opened) {
-          p.log.info("Opened your browser for verification.");
+          p.log.info("Opened your browser.");
         } 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...");
+    spinner3.start("Waiting for setup to complete...");
     while (Date.now() < expiresAt) {
       const status = await api.getInitSessionStatus({
         sessionId: start.sessionId,
@@ -578,13 +848,13 @@ async function init(options = {}) {
       if (status.status === "pending") {
         const pendingMessage = status.message?.trim();
         if (pendingMessage) {
-          spinner4.message(`Waiting for browser authorization... (${pendingMessage})`);
+          spinner3.message(`Waiting for setup to complete... (${pendingMessage})`);
         }
         await sleep((status.pollIntervalSeconds || start.poll.intervalSeconds) * 1e3);
         continue;
       }
       if (status.status === "failed") {
-        spinner4.stop("Setup failed");
+        spinner3.stop("Setup failed");
         if (isPlanLimitFailure(status.message)) {
           printPlanLimitMessage(apiUrl, status.message);
         } else {
@@ -594,70 +864,24 @@ async function init(options = {}) {
         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`);
-        }
+        spinner3.stop("Setup complete!");
+        const { credentials } = status;
         p.outro("Vocoder initialized successfully!");
-        p.log.info(`Project:   ${status.credentials.projectName}`);
-        p.log.info(`Workspace: ${status.credentials.organizationName}`);
+        runScaffold({
+          projectName: credentials.projectName,
+          organizationName: credentials.organizationName,
+          sourceLocale: credentials.sourceLocale,
+          translationTriggers: credentials.translationTriggers ?? ["push"]
+        });
         return 0;
       }
     }
-    spinner4.stop("Authorization timed out");
-    p.log.error("Authorization timed out. Run `vocoder init` again.");
+    spinner3.stop("Setup timed out");
+    p.log.error("Setup 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;
-    }
+    spinner3.stop();
     if (error instanceof Error) {
       if (isPlanLimitFailure(error.message)) {
         printPlanLimitMessage(apiUrl, error.message);
@@ -676,7 +900,7 @@ import * as p2 from "@clack/prompts";
 import { createHash as createHash2, randomUUID } from "crypto";
 
 // src/utils/branch.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 var REGEX_SPECIAL_CHARS = /[.+?^${}()|[\]\\]/g;
 function escapeRegexChar(value) {
   return value.replace(REGEX_SPECIAL_CHARS, "\\$&");
@@ -698,7 +922,7 @@ function detectBranch(override) {
     return envBranch;
   }
   try {
-    const branch = execSync2("git rev-parse --abbrev-ref HEAD", {
+    const branch = execSync3("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
@@ -742,12 +966,12 @@ function matchBranchPattern(branch, pattern) {
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
 
 // src/utils/config.ts
-import chalk from "chalk";
-import { config as loadEnv } from "dotenv";
-loadEnv();
+import chalk2 from "chalk";
+import { config as loadEnv2 } from "dotenv";
+loadEnv2();
 function validateLocalConfig(config) {
   if (!config.apiKey || config.apiKey.length === 0) {
     throw new Error("VOCODER_API_KEY is required. Set it in your .env file.");
@@ -837,19 +1061,19 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
     configSources.noFallback = "environment";
   }
   if (verbose) {
-    console.log(chalk.dim("\n   Configuration sources:"));
-    console.log(chalk.dim(`     Include patterns: ${configSources.extractionPattern}`));
+    console.log(chalk2.dim("\n   Configuration sources:"));
+    console.log(chalk2.dim(`     Include patterns: ${configSources.extractionPattern}`));
     if (excludePattern.length > 0) {
-      console.log(chalk.dim(`     Exclude patterns: ${configSources.excludePattern}`));
+      console.log(chalk2.dim(`     Exclude patterns: ${configSources.excludePattern}`));
     }
-    console.log(chalk.dim(`     API key: ${configSources.apiKey}`));
-    console.log(chalk.dim(`     API URL: ${configSources.apiUrl}
+    console.log(chalk2.dim(`     API key: ${configSources.apiKey}`));
+    console.log(chalk2.dim(`     API URL: ${configSources.apiUrl}
 `));
-    console.log(chalk.dim(`     Sync mode: ${configSources.mode}`));
+    console.log(chalk2.dim(`     Sync mode: ${configSources.mode}`));
     if (maxWaitMs) {
-      console.log(chalk.dim(`     Max wait: ${configSources.maxWaitMs}`));
+      console.log(chalk2.dim(`     Max wait: ${configSources.maxWaitMs}`));
     }
-    console.log(chalk.dim(`     No fallback: ${configSources.noFallback}
+    console.log(chalk2.dim(`     No fallback: ${configSources.noFallback}
 `));
   }
   return {
@@ -1137,7 +1361,7 @@ var StringExtractor = class {
 };
 
 // src/commands/sync.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import { join as join2 } from "path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1186,7 +1410,7 @@ 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);
+  return join2(projectRoot, "node_modules", ".vocoder", "cache", "sync", filename);
 }
 function readLocalSnapshotCache(params) {
   const candidateBranches = params.branch === "main" ? ["main"] : [params.branch, "main"];
@@ -1222,7 +1446,7 @@ function readLocalSnapshotCache(params) {
 }
 function writeLocalSnapshotCache(params) {
   const cacheFilePath = getCacheFilePath(params.projectRoot, params.branch);
-  mkdirSync(join2(params.projectRoot, ".vocoder", "cache", "sync"), {
+  mkdirSync(join2(params.projectRoot, "node_modules", ".vocoder", "cache", "sync"), {
     recursive: true
   });
   const payload = {
@@ -1236,7 +1460,7 @@ function writeLocalSnapshotCache(params) {
     ...params.localeMetadata ? { localeMetadata: params.localeMetadata } : {},
     translations: params.translations
   };
-  writeFileSync2(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
+  writeFileSync(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
   return cacheFilePath;
 }
 function resolveEffectiveModeFromPolicy(params) {
@@ -1392,12 +1616,12 @@ async function sync(options = {}) {
   const startTime = Date.now();
   const projectRoot = process.cwd();
   p2.intro("Vocoder Sync");
-  const spinner4 = p2.spinner();
+  const spinner3 = p2.spinner();
   try {
-    spinner4.start("Detecting branch");
+    spinner3.start("Detecting branch");
     const branch = detectBranch(options.branch);
-    spinner4.stop(`Branch: ${chalk2.cyan(branch)}`);
-    spinner4.start("Loading project configuration");
+    spinner3.stop(`Branch: ${chalk3.cyan(branch)}`);
+    spinner3.start("Loading project configuration");
     const mergedConfig = await getMergedConfig(options, options.verbose);
     const localConfig = {
       apiKey: mergedConfig.apiKey || "",
@@ -1419,10 +1643,10 @@ async function sync(options = {}) {
       excludePattern: mergedConfig.excludePattern,
       timeout: waitTimeoutMs
     };
-    spinner4.stop("Project configuration loaded");
+    spinner3.stop("Project configuration loaded");
     if (!options.force && !isTargetBranch(branch, config.targetBranches)) {
       p2.log.warn(
-        `Skipping translations (${chalk2.cyan(branch)} is not a target branch)`
+        `Skipping translations (${chalk3.cyan(branch)} is not a target branch)`
       );
       p2.log.info(`Target branches: ${config.targetBranches.join(", ")}`);
       p2.log.info("Use --force to translate anyway");
@@ -1430,7 +1654,7 @@ async function sync(options = {}) {
       return 0;
     }
     const patternsDisplay = Array.isArray(config.extractionPattern) ? config.extractionPattern.join(", ") : config.extractionPattern;
-    spinner4.start(`Extracting strings from ${patternsDisplay}`);
+    spinner3.start(`Extracting strings from ${patternsDisplay}`);
     const extractor = new StringExtractor();
     const extractedStrings = await extractor.extractFromProject(
       config.extractionPattern,
@@ -1438,13 +1662,13 @@ async function sync(options = {}) {
       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");
+      spinner3.stop("No translatable strings found");
+      p2.log.warn("Make sure you are wrapping translatable strings with Vocoder");
       p2.outro("");
       return 0;
     }
-    spinner4.stop(
-      `Extracted ${chalk2.cyan(extractedStrings.length)} strings from ${chalk2.cyan(patternsDisplay)}`
+    spinner3.stop(
+      `Extracted ${chalk3.cyan(extractedStrings.length)} strings from ${chalk3.cyan(patternsDisplay)}`
     );
     if (options.verbose) {
       const sampleLines = extractedStrings.slice(0, 5).map((s) => `  "${s.text}" (${s.file}:${s.line})`);
@@ -1481,7 +1705,7 @@ async function sync(options = {}) {
         `Deduped ${extractedStrings.length} extracted entries into ${stringEntries.length} unique source strings`
       );
     }
-    spinner4.start("Submitting strings to Vocoder API");
+    spinner3.start("Submitting strings to Vocoder API");
     const batchResponse = await api.submitTranslation(
       branch,
       stringEntries,
@@ -1493,7 +1717,7 @@ async function sync(options = {}) {
       },
       repoIdentity ?? void 0
     );
-    spinner4.stop(`Submitted to API - Batch ${chalk2.cyan(batchResponse.batchId)}`);
+    spinner3.stop(`Submitted to API - Batch ${chalk3.cyan(batchResponse.batchId)}`);
     const effectiveMode = batchResponse.effectiveMode ?? resolveEffectiveModeFromPolicy({
       branch,
       requestedMode,
@@ -1510,13 +1734,13 @@ async function sync(options = {}) {
     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)}`);
+    p2.log.info(`New strings: ${chalk3.cyan(batchResponse.newStrings)}`);
     if (batchResponse.deletedStrings && batchResponse.deletedStrings > 0) {
       p2.log.info(
-        `Deleted strings: ${chalk2.yellow(batchResponse.deletedStrings)} (archived)`
+        `Deleted strings: ${chalk3.yellow(batchResponse.deletedStrings)} (archived)`
       );
     }
-    p2.log.info(`Total strings: ${chalk2.cyan(batchResponse.totalStrings)}`);
+    p2.log.info(`Total strings: ${chalk3.cyan(batchResponse.totalStrings)}`);
     if (batchResponse.newStrings === 0) {
       p2.log.success("No new strings - using existing translations");
     } else {
@@ -1536,7 +1760,7 @@ async function sync(options = {}) {
     }
     let waitError = null;
     if (!artifacts && (effectiveMode === "required" || effectiveMode === "best-effort")) {
-      spinner4.start(`Waiting for translations (max ${waitTimeoutMs}ms)`);
+      spinner3.start(`Waiting for translations (max ${waitTimeoutMs}ms)`);
       let lastProgress = 0;
       try {
         const completion = await api.waitForCompletion(
@@ -1545,7 +1769,7 @@ async function sync(options = {}) {
           (progress) => {
             const percent = Math.round(progress * 100);
             if (percent > lastProgress) {
-              spinner4.message(`Translating... ${percent}%`);
+              spinner3.message(`Translating... ${percent}%`);
               lastProgress = percent;
             }
           }
@@ -1555,9 +1779,9 @@ async function sync(options = {}) {
           translations: completion.translations,
           localeMetadata: completion.localeMetadata
         };
-        spinner4.stop("Translations complete");
+        spinner3.stop("Translations complete");
       } catch (error) {
-        spinner4.stop("Translation wait incomplete");
+        spinner3.stop("Translation wait incomplete");
         waitError = error instanceof Error ? error : new Error(String(error));
         if (effectiveMode === "required") {
           throw waitError;
@@ -1571,7 +1795,7 @@ async function sync(options = {}) {
           "Fresh translations are not available and fallback is disabled (--no-fallback)."
         );
       }
-      spinner4.start("Loading fallback translations");
+      spinner3.start("Loading fallback translations");
       const localFallback = readLocalSnapshotCache({
         projectRoot,
         branch
@@ -1579,7 +1803,7 @@ async function sync(options = {}) {
       if (localFallback) {
         artifacts = localFallback;
         const cacheBranchLabel = localFallback.cacheBranch && localFallback.cacheBranch !== branch ? `${localFallback.cacheBranch} fallback` : localFallback.cacheBranch || branch;
-        spinner4.stop(`Using local cached snapshot (${cacheBranchLabel})`);
+        spinner3.stop(`Using local cached snapshot (${cacheBranchLabel})`);
       } else {
         try {
           const apiSnapshot = await fetchApiSnapshot(api, {
@@ -1588,12 +1812,12 @@ async function sync(options = {}) {
           });
           if (apiSnapshot) {
             artifacts = apiSnapshot;
-            spinner4.stop("Using latest completed API snapshot");
+            spinner3.stop("Using latest completed API snapshot");
           } else {
-            spinner4.stop("No completed API snapshot available");
+            spinner3.stop("No completed API snapshot available");
           }
         } catch (error) {
-          spinner4.stop("Failed to fetch API snapshot");
+          spinner3.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}`);
@@ -1649,7 +1873,7 @@ async function sync(options = {}) {
     p2.log.info("Just use <VocoderProvider> and <T> \u2014 no manual imports needed.");
     return 0;
   } catch (error) {
-    spinner4.stop();
+    spinner3.stop();
     if (error instanceof VocoderAPIError && error.syncPolicyError) {
       p2.log.error(error.syncPolicyError.message);
       const guidance = getSyncPolicyErrorGuidance(error.syncPolicyError);
@@ -1670,9 +1894,12 @@ async function sync(options = {}) {
     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");
+        p2.log.warn("VOCODER_API_KEY is only needed for `vocoder sync` (CLI push).");
+        p2.log.info("  Create one at: https://vocoder.app/dashboard");
+        p2.log.info('  Then: export VOCODER_API_KEY="vc_..." or add it to .env');
+        p2.log.info("");
+        p2.log.info("  Note: If you use @vocoder/unplugin, `vocoder sync` is optional.");
+        p2.log.info("  Translations are fetched automatically at build time.");
       } else if (error.message.includes("git branch")) {
         p2.log.warn("Run from a git repository, or use:");
         p2.log.info("  vocoder sync --branch main");
@@ -1685,1159 +1912,6 @@ async function sync(options = {}) {
   }
 }
 
-// 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]);
@@ -2847,12 +1921,13 @@ async function runCommand(command, options) {
   process.exitCode = exitCode;
 }
 var program = new Command();
-program.name("vocoder").description("Vocoder CLI - Sync translations for your application").version("0.1.2");
-program.command("sync").description("Extract strings and sync translations").option("--include <pattern>", "Glob pattern(s) to include (can be used multiple times)", collect, []).option("--exclude <pattern>", "Glob pattern(s) to exclude (can be used multiple times)", collect, []).option("--branch <name>", "Override branch detection").option("--force", "Sync even if not a target branch").option("--mode <mode>", "Sync mode: auto|required|best-effort").option("--max-wait-ms <ms>", "Max wait time before fallback (ms)", (value) => Number.parseInt(value, 10)).option("--no-fallback", "Fail instead of using fallback artifacts").option("--dry-run", "Show what would be synced without doing it").option("--verbose", "Show detailed progress").action((options) => runCommand(sync, {
-  ...options,
-  noFallback: options.noFallback ? true : void 0
-}));
-program.command("wrap").description("Auto-wrap strings with <T> and t() for translation").option("--include <pattern>", "Glob pattern(s) to include (can be used multiple times)", collect, []).option("--exclude <pattern>", "Glob pattern(s) to exclude (can be used multiple times)", collect, []).option("--dry-run", "Preview changes without modifying files").option("--interactive", "Confirm each string interactively").option("--confidence <level>", "Minimum confidence: high, medium, low", "high").option("--verbose", "Detailed output").action((options) => runCommand(wrap, options));
+program.name("vocoder").description("Vocoder CLI - Project setup and string extraction").version("0.1.5");
 program.command("init").description("Authenticate and provision Vocoder for this project").option("--api-url <url>", "Override Vocoder API URL").option("--yes", "Allow overwriting existing local config values").option("--project-name <name>", "Starter project name to create").option("--source-locale <locale>", "Source locale for the starter project").option("--target-locales <list>", "Comma-separated target locales (e.g. es,fr,de)").action((options) => runCommand(init, options));
+program.command("sync").description("Extract strings and sync translations").option("--branch <branch>", "Override detected branch").option("--mode <mode>", "Sync mode: auto, required, best-effort", "auto").option("--max-wait <ms>", "Max wait for translations (ms)").option("--force", "Force re-extraction even if no changes").option("--dry-run", "Preview without syncing").option("--no-fallback", "Disable fallback to cached translations").option("--include <pattern>", "Include glob pattern", collect, []).option("--exclude <pattern>", "Exclude glob pattern", collect, []).option("--verbose", "Detailed output").action((options) => {
+  const translated = { ...options };
+  if (options.maxWait) translated.maxWaitMs = Number(options.maxWait);
+  if (options.fallback === false) translated.noFallback = true;
+  return runCommand(sync, translated);
+});
 program.parse(process.argv);
 //# sourceMappingURL=bin.mjs.map