@vocoder/cli 0.1.4 → 0.1.6

package/dist/bin.mjs

@@ -278,6 +278,272 @@ var VocoderAPI = class {
   }
 };
 
+// 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";
 import { relative, resolve } from "path";
@@ -375,7 +641,10 @@ 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 parseTargetLocales(value) {
   if (!value) return void 0;
@@ -442,19 +711,77 @@ function printPlanLimitMessage(apiUrl, message) {
    ${message}`);
   p.log.info(`Manage subscription: ${getSubscriptionSettingsUrl(apiUrl)}`);
 }
-function printNextSteps(projectName, organizationName) {
+function runScaffold(params) {
+  const { projectName, organizationName, sourceLocale, translationTriggers } = params;
   p.log.info(`Project:   ${chalk.bold(projectName)}`);
   p.log.info(`Workspace: ${chalk.bold(organizationName)}`);
-  p.log.info("");
-  p.log.info("Next steps:");
-  p.log.info(`  1. Add ${chalk.cyan("@vocoder/unplugin")} to your build config`);
-  p.log.info(`  2. Wrap translatable strings with ${chalk.green("<T>")}...${chalk.green("</T>")}`);
-  p.log.info("  3. Push to trigger extraction + translation");
+  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 apiUrl = options.apiUrl || process.env.VOCODER_API_URL || "https://vocoder.app";
   p.intro("Vocoder Setup");
-  const spinner4 = p.spinner();
+  const spinner3 = p.spinner();
   try {
     const gitContext = resolveGitContext();
     const identity = gitContext.identity;
@@ -464,21 +791,26 @@ async function init(options = {}) {
       }
     }
     if (identity) {
-      spinner4.start("Checking for existing project...");
+      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) {
-        spinner4.stop("Found existing project!");
+        spinner3.stop("Found existing project!");
         p.outro("Vocoder is already set up for this repository.");
-        printNextSteps(existing.projectName, existing.organizationName);
+        runScaffold({
+          projectName: existing.projectName,
+          organizationName: existing.organizationName,
+          sourceLocale: existing.sourceLocale ?? "en",
+          translationTriggers: existing.translationTriggers ?? ["push"]
+        });
         return 0;
       }
-      spinner4.stop("No existing project found for this repo.");
+      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 start = await api.startInitSession({
       projectName: options.projectName,
@@ -487,7 +819,7 @@ 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;
     p.log.info("Create a project in your browser to continue.");
     p.note(verificationUrlString, "Setup URL");
@@ -507,7 +839,7 @@ async function init(options = {}) {
       }
     }
     const expiresAt = new Date(start.expiresAt).getTime();
-    spinner4.start("Waiting for setup to complete...");
+    spinner3.start("Waiting for setup to complete...");
     while (Date.now() < expiresAt) {
       const status = await api.getInitSessionStatus({
         sessionId: start.sessionId,
@@ -516,13 +848,13 @@ async function init(options = {}) {
       if (status.status === "pending") {
         const pendingMessage = status.message?.trim();
         if (pendingMessage) {
-          spinner4.message(`Waiting for setup to complete... (${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 {
@@ -532,19 +864,24 @@ async function init(options = {}) {
         return 1;
       }
       if (status.status === "completed") {
-        spinner4.stop("Setup complete!");
+        spinner3.stop("Setup complete!");
         const { credentials } = status;
         p.outro("Vocoder initialized successfully!");
-        printNextSteps(credentials.projectName, credentials.organizationName);
+        runScaffold({
+          projectName: credentials.projectName,
+          organizationName: credentials.organizationName,
+          sourceLocale: credentials.sourceLocale,
+          translationTriggers: credentials.translationTriggers ?? ["push"]
+        });
         return 0;
       }
     }
-    spinner4.stop("Setup timed out");
+    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();
+    spinner3.stop();
     if (error instanceof Error) {
       if (isPlanLimitFailure(error.message)) {
         printPlanLimitMessage(apiUrl, error.message);
@@ -563,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, "\\$&");
@@ -585,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();
@@ -629,12 +966,12 @@ function matchBranchPattern(branch, pattern) {
 }
 
 // src/commands/sync.ts
-import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
 
 // src/utils/config.ts
 import chalk2 from "chalk";
-import { config as loadEnv } from "dotenv";
-loadEnv();
+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.");
@@ -753,7 +1090,7 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
 
 // src/utils/extract.ts
 import { createHash } from "crypto";
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { parse } from "@babel/parser";
 import babelTraverse from "@babel/traverse";
 import { glob } from "glob";
@@ -797,7 +1134,7 @@ var StringExtractor = class {
    * Extract strings from a single file
    */
   async extractFromFile(filePath, projectRoot) {
-    const code = readFileSync(filePath, "utf-8");
+    const code = readFileSync2(filePath, "utf-8");
     const strings = [];
     const relativeFilePath = pathRelative(projectRoot, filePath).split("\\").join("/");
     try {
@@ -1025,7 +1362,7 @@ var StringExtractor = class {
 
 // src/commands/sync.ts
 import chalk3 from "chalk";
-import { join } from "path";
+import { join as join2 } from "path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1073,17 +1410,17 @@ 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 join(projectRoot, ".vocoder", "cache", "sync", filename);
+  return join2(projectRoot, "node_modules", ".vocoder", "cache", "sync", filename);
 }
 function readLocalSnapshotCache(params) {
   const candidateBranches = params.branch === "main" ? ["main"] : [params.branch, "main"];
   for (const candidateBranch of candidateBranches) {
     const cacheFilePath = getCacheFilePath(params.projectRoot, candidateBranch);
-    if (!existsSync(cacheFilePath)) {
+    if (!existsSync2(cacheFilePath)) {
       continue;
     }
     try {
-      const raw = readFileSync2(cacheFilePath, "utf-8");
+      const raw = readFileSync3(cacheFilePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!isRecord(parsed)) {
         continue;
@@ -1109,7 +1446,7 @@ function readLocalSnapshotCache(params) {
 }
 function writeLocalSnapshotCache(params) {
   const cacheFilePath = getCacheFilePath(params.projectRoot, params.branch);
-  mkdirSync(join(params.projectRoot, ".vocoder", "cache", "sync"), {
+  mkdirSync(join2(params.projectRoot, "node_modules", ".vocoder", "cache", "sync"), {
     recursive: true
   });
   const payload = {
@@ -1279,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: ${chalk3.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 || "",
@@ -1306,7 +1643,7 @@ 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 (${chalk3.cyan(branch)} is not a target branch)`
@@ -1317,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,
@@ -1325,12 +1662,12 @@ 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(
+    spinner3.stop(
       `Extracted ${chalk3.cyan(extractedStrings.length)} strings from ${chalk3.cyan(patternsDisplay)}`
     );
     if (options.verbose) {
@@ -1368,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,
@@ -1380,7 +1717,7 @@ async function sync(options = {}) {
       },
       repoIdentity ?? void 0
     );
-    spinner4.stop(`Submitted to API - Batch ${chalk3.cyan(batchResponse.batchId)}`);
+    spinner3.stop(`Submitted to API - Batch ${chalk3.cyan(batchResponse.batchId)}`);
     const effectiveMode = batchResponse.effectiveMode ?? resolveEffectiveModeFromPolicy({
       branch,
       requestedMode,
@@ -1423,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(
@@ -1432,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;
             }
           }
@@ -1442,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;
@@ -1458,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
@@ -1466,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, {
@@ -1475,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}`);
@@ -1536,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);
@@ -1575,1159 +1912,6 @@ async function sync(options = {}) {
   }
 }
 
-// src/commands/wrap.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { relative as relative2 } from "path";
-import * as p3 from "@clack/prompts";
-import chalk4 from "chalk";
-
-// src/utils/wrap/analyzer.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { parse as parse2 } from "@babel/parser";
-import babelTraverse2 from "@babel/traverse";
-import { glob as glob2 } from "glob";
-
-// src/utils/wrap/heuristics.ts
-var URL_REGEX = /^(https?:\/\/|\/\/|mailto:|tel:|ftp:\/\/)/i;
-var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-var FILE_PATH_REGEX = /^(\.{0,2}\/|[a-zA-Z]:\\)/;
-var COLOR_HEX_REGEX = /^#([0-9a-fA-F]{3,8})$/;
-var COLOR_FUNC_REGEX = /^(rgb|rgba|hsl|hsla)\s*\(/i;
-var CAMEL_CASE_REGEX = /^[a-z][a-zA-Z0-9]*$/;
-var PASCAL_CASE_REGEX = /^[A-Z][a-zA-Z0-9]*$/;
-var SCREAMING_SNAKE_REGEX = /^[A-Z][A-Z0-9_]+$/;
-var KEBAB_CASE_REGEX = /^[a-z][a-z0-9-]+$/;
-var MIME_TYPE_REGEX = /^(application|text|image|audio|video|font|multipart)\//;
-var DATE_FORMAT_REGEX = /^[YMDHhmsaAZz\-\/\.\s:,]+$/;
-var CSS_UNIT_REGEX = /^\d+(\.\d+)?(px|em|rem|vh|vw|%|ch|ex|pt|pc|in|cm|mm)$/;
-var TAILWIND_REGEX = /^[a-z][\w-]*(\s+[a-z][\w-]*)*$/;
-var TAILWIND_PREFIXES = [
-  "flex",
-  "grid",
-  "block",
-  "inline",
-  "hidden",
-  "absolute",
-  "relative",
-  "fixed",
-  "sticky",
-  "top",
-  "bottom",
-  "left",
-  "right",
-  "inset",
-  "w-",
-  "h-",
-  "min-",
-  "max-",
-  "p-",
-  "px-",
-  "py-",
-  "pt-",
-  "pb-",
-  "pl-",
-  "pr-",
-  "m-",
-  "mx-",
-  "my-",
-  "mt-",
-  "mb-",
-  "ml-",
-  "mr-",
-  "text-",
-  "font-",
-  "leading-",
-  "tracking-",
-  "bg-",
-  "border-",
-  "rounded-",
-  "shadow-",
-  "opacity-",
-  "z-",
-  "gap-",
-  "space-",
-  "items-",
-  "justify-",
-  "self-",
-  "place-",
-  "overflow-",
-  "cursor-",
-  "transition-",
-  "duration-",
-  "ease-",
-  "sm:",
-  "md:",
-  "lg:",
-  "xl:",
-  "2xl:",
-  "dark:",
-  "hover:",
-  "focus:",
-  "active:",
-  "group-",
-  "peer-"
-];
-var NON_TRANSLATABLE_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "className",
-  "class",
-  "href",
-  "src",
-  "id",
-  "key",
-  "ref",
-  "style",
-  "data-testid",
-  "data-cy",
-  "data-test",
-  "type",
-  "name",
-  "value",
-  "action",
-  "method",
-  "encType",
-  "target",
-  "rel",
-  "role",
-  "tabIndex",
-  "htmlFor",
-  "for",
-  "width",
-  "height",
-  "viewBox",
-  "xmlns",
-  "fill",
-  "stroke",
-  "onClick",
-  "onChange",
-  "onSubmit",
-  "onBlur",
-  "onFocus",
-  "onKeyDown",
-  "onKeyUp",
-  "onKeyPress",
-  "onMouseEnter",
-  "onMouseLeave"
-]);
-var TRANSLATABLE_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "title",
-  "placeholder",
-  "alt",
-  "aria-label",
-  "aria-description",
-  "aria-placeholder",
-  "aria-roledescription",
-  "aria-valuetext",
-  "label",
-  "description",
-  "message",
-  "heading",
-  "caption",
-  "helperText",
-  "errorMessage",
-  "successMessage",
-  "tooltip"
-]);
-var NON_TRANSLATABLE_CALLS = /* @__PURE__ */ new Set([
-  "console.log",
-  "console.warn",
-  "console.error",
-  "console.info",
-  "console.debug",
-  "require",
-  "import",
-  "addEventListener",
-  "removeEventListener",
-  "querySelector",
-  "querySelectorAll",
-  "getElementById",
-  "getAttribute",
-  "setAttribute",
-  "createElement",
-  "JSON.parse",
-  "JSON.stringify",
-  "parseInt",
-  "parseFloat",
-  "encodeURIComponent",
-  "decodeURIComponent",
-  "encodeURI",
-  "decodeURI",
-  "RegExp"
-]);
-var TRANSLATABLE_VAR_NAMES = /* @__PURE__ */ new Set([
-  "label",
-  "message",
-  "title",
-  "description",
-  "heading",
-  "text",
-  "caption",
-  "subtitle",
-  "tooltip",
-  "errorMessage",
-  "successMessage",
-  "warningMessage",
-  "infoMessage",
-  "placeholder",
-  "helperText",
-  "hint",
-  "buttonText",
-  "linkText",
-  "headerText",
-  "footerText",
-  "confirmText",
-  "cancelText",
-  "submitText",
-  "greeting",
-  "welcome",
-  "instructions"
-]);
-function classifyString(text, context, metadata = {}) {
-  const trimmed = text.trim();
-  if (trimmed.length === 0) {
-    return { translatable: false, confidence: "high", reason: "Empty or whitespace-only" };
-  }
-  if (trimmed.length === 1) {
-    return { translatable: false, confidence: "high", reason: "Single character" };
-  }
-  if (!/[a-zA-Z]/.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "No alphabetic characters" };
-  }
-  if (URL_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "URL" };
-  }
-  if (EMAIL_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "Email address" };
-  }
-  if (FILE_PATH_REGEX.test(trimmed) && !trimmed.includes(" ")) {
-    return { translatable: false, confidence: "high", reason: "File path" };
-  }
-  if (COLOR_HEX_REGEX.test(trimmed) || COLOR_FUNC_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "Color code" };
-  }
-  if (CSS_UNIT_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "CSS unit value" };
-  }
-  if (MIME_TYPE_REGEX.test(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "MIME type" };
-  }
-  if (DATE_FORMAT_REGEX.test(trimmed) && trimmed.length > 1) {
-    return { translatable: false, confidence: "high", reason: "Date format string" };
-  }
-  if (context === "jsx-attribute" && metadata.attributeName) {
-    if (NON_TRANSLATABLE_ATTRIBUTES.has(metadata.attributeName)) {
-      return { translatable: false, confidence: "high", reason: `Non-translatable attribute: ${metadata.attributeName}` };
-    }
-    if (metadata.attributeName.startsWith("data-") && !TRANSLATABLE_ATTRIBUTES.has(metadata.attributeName)) {
-      return { translatable: false, confidence: "high", reason: "data-* attribute" };
-    }
-    if (metadata.attributeName.startsWith("on") && metadata.attributeName.length > 2) {
-      const thirdChar = metadata.attributeName[2];
-      if (thirdChar && thirdChar === thirdChar.toUpperCase()) {
-        return { translatable: false, confidence: "high", reason: "Event handler attribute" };
-      }
-    }
-    if (TRANSLATABLE_ATTRIBUTES.has(metadata.attributeName)) {
-      return { translatable: true, confidence: "high", reason: `Translatable attribute: ${metadata.attributeName}` };
-    }
-  }
-  if (context === "jsx-text") {
-    const hasWords = /[a-zA-Z]{2,}/.test(trimmed);
-    if (hasWords) {
-      return { translatable: true, confidence: "high", reason: "JSX text with words" };
-    }
-  }
-  if (!trimmed.includes(" ") && (CAMEL_CASE_REGEX.test(trimmed) || PASCAL_CASE_REGEX.test(trimmed) || SCREAMING_SNAKE_REGEX.test(trimmed) || KEBAB_CASE_REGEX.test(trimmed))) {
-    return { translatable: false, confidence: "high", reason: "Code identifier" };
-  }
-  if (isTailwindClasses(trimmed)) {
-    return { translatable: false, confidence: "high", reason: "CSS/Tailwind classes" };
-  }
-  if (metadata.isInsideCallExpression) {
-    if (NON_TRANSLATABLE_CALLS.has(metadata.isInsideCallExpression)) {
-      return { translatable: false, confidence: "high", reason: `Inside ${metadata.isInsideCallExpression}()` };
-    }
-  }
-  if (metadata.parentType === "ThrowStatement" || metadata.isInsideCallExpression === "Error") {
-    return { translatable: false, confidence: "high", reason: "Error message" };
-  }
-  if ((context === "string-literal" || context === "template-literal") && metadata.parentType === "VariableDeclarator") {
-    return { translatable: true, confidence: "medium", reason: "String in variable declaration" };
-  }
-  const wordCount = trimmed.split(/\s+/).length;
-  if (wordCount >= 3) {
-    return { translatable: true, confidence: "medium", reason: `Multi-word string (${wordCount} words)` };
-  }
-  if (wordCount === 2 && /[a-zA-Z]{2,}/.test(trimmed)) {
-    return { translatable: true, confidence: "low", reason: "Short phrase (2 words)" };
-  }
-  if (/^[A-Z][a-z]/.test(trimmed) && context !== "string-literal") {
-    return { translatable: true, confidence: "low", reason: "Capitalized word, possibly UI text" };
-  }
-  return { translatable: false, confidence: "low", reason: "Ambiguous single-word string" };
-}
-function isTranslatableVarName(name) {
-  const lower = name.toLowerCase();
-  for (const varName of TRANSLATABLE_VAR_NAMES) {
-    if (lower === varName.toLowerCase() || lower.endsWith(varName.toLowerCase())) {
-      return true;
-    }
-  }
-  return false;
-}
-function isTailwindClasses(text) {
-  if (!TAILWIND_REGEX.test(text)) return false;
-  const parts = text.split(/\s+/);
-  let tailwindCount = 0;
-  for (const part of parts) {
-    if (TAILWIND_PREFIXES.some((prefix) => part.startsWith(prefix))) {
-      tailwindCount++;
-    }
-  }
-  return tailwindCount > parts.length / 2;
-}
-
-// src/utils/wrap/analyzer.ts
-var traverse2 = babelTraverse2.default || babelTraverse2;
-var StringAnalyzer = class {
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  /**
-   * Analyze all files matching the given patterns and return wrap candidates.
-   */
-  async analyzeProject(options, projectRoot = process.cwd()) {
-    const includePatterns = options.include?.length ? options.include : ["src/**/*.{tsx,jsx,ts,js}"];
-    const defaultIgnore = [
-      "**/node_modules/**",
-      "**/.next/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/*.test.*",
-      "**/*.spec.*",
-      "**/*.stories.*",
-      "**/__tests__/**"
-    ];
-    const ignorePatterns = options.exclude ? [...defaultIgnore, ...options.exclude] : defaultIgnore;
-    const allFiles = /* @__PURE__ */ new Set();
-    for (const pattern of includePatterns) {
-      const files = await glob2(pattern, {
-        cwd: projectRoot,
-        absolute: true,
-        ignore: ignorePatterns
-      });
-      files.forEach((file) => allFiles.add(file));
-    }
-    const allCandidates = [];
-    for (const file of allFiles) {
-      try {
-        const candidates = this.analyzeFile(file);
-        allCandidates.push(...candidates);
-      } catch (error) {
-        if (options.verbose) {
-          const msg = error instanceof Error ? error.message : "Unknown error";
-          console.warn(`Warning: Failed to analyze ${file}: ${msg}`);
-        }
-      }
-    }
-    return allCandidates;
-  }
-  /**
-   * Analyze a single file and return wrap candidates.
-   */
-  analyzeFile(filePath) {
-    const code = readFileSync3(filePath, "utf-8");
-    return this.analyzeCode(code, filePath);
-  }
-  /**
-   * Analyze source code and return wrap candidates.
-   */
-  analyzeCode(code, filePath = "<input>") {
-    const candidates = [];
-    const ast = parse2(code, {
-      sourceType: "module",
-      plugins: ["jsx", "typescript"]
-    });
-    const vocoderImports = /* @__PURE__ */ new Map();
-    const tFunctionNames = /* @__PURE__ */ new Set();
-    traverse2(ast, {
-      // Track imports from @vocoder/react
-      ImportDeclaration: (path) => {
-        const source = path.node.source.value;
-        if (source === this.adapter.importSource) {
-          path.node.specifiers.forEach((spec) => {
-            if (spec.type === "ImportSpecifier") {
-              const imported = spec.imported.type === "Identifier" ? spec.imported.name : null;
-              const local = spec.local.name;
-              if (imported === this.adapter.componentName) {
-                vocoderImports.set(local, this.adapter.componentName);
-              }
-              if (imported === this.adapter.functionName) {
-                tFunctionNames.add(local);
-              }
-              if (imported === this.adapter.hookName) {
-                vocoderImports.set(local, this.adapter.hookName);
-              }
-            }
-          });
-        }
-      },
-      // Track destructured t from useVocoder()
-      VariableDeclarator: (path) => {
-        const init2 = path.node.init;
-        if (init2 && init2.type === "CallExpression" && init2.callee.type === "Identifier" && init2.callee.name === this.adapter.hookName && path.node.id.type === "ObjectPattern") {
-          path.node.id.properties.forEach((prop) => {
-            if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === this.adapter.functionName) {
-              const localName = prop.value.type === "Identifier" ? prop.value.name : this.adapter.functionName;
-              tFunctionNames.add(localName);
-            }
-          });
-        }
-      },
-      // Find bare JSX text
-      JSXText: (path) => {
-        const text = path.node.value;
-        const trimmed = text.trim();
-        if (!trimmed) return;
-        const ancestors = path.getAncestry().map((a) => a.node);
-        if (this.adapter.isAlreadyWrapped(ancestors, vocoderImports)) return;
-        const classification = classifyString(trimmed, "jsx-text", {
-          isInsideComponent: true
-        });
-        if (classification.translatable) {
-          candidates.push({
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            column: path.node.loc?.start.column || 0,
-            text: trimmed,
-            confidence: classification.confidence,
-            strategy: "T-component",
-            context: "jsx-text",
-            reason: classification.reason
-          });
-        }
-      },
-      // Find translatable JSX attributes
-      JSXAttribute: (path) => {
-        const attrName = path.node.name?.name;
-        if (!attrName) return;
-        const value = path.node.value;
-        if (!value) return;
-        let text = null;
-        let context = "jsx-attribute";
-        if (value.type === "StringLiteral") {
-          text = value.value;
-        } else if (value.type === "JSXExpressionContainer" && value.expression.type === "StringLiteral") {
-          text = value.expression.value;
-        }
-        if (!text || !text.trim()) return;
-        if (value.type === "JSXExpressionContainer" && value.expression.type === "CallExpression") {
-          if (this.adapter.isAlreadyWrappedCall(value.expression, tFunctionNames)) return;
-        }
-        const classification = classifyString(text.trim(), context, {
-          attributeName: attrName,
-          isInsideComponent: true
-        });
-        if (classification.translatable) {
-          candidates.push({
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            column: path.node.loc?.start.column || 0,
-            text: text.trim(),
-            confidence: classification.confidence,
-            strategy: "t-function",
-            context,
-            reason: classification.reason
-          });
-        }
-      },
-      // Find string literals in non-JSX contexts
-      StringLiteral: (path) => {
-        if (path.parent.type === "ImportDeclaration") return;
-        if (path.parent.type === "ExportDeclaration") return;
-        if (path.parent.type === "JSXAttribute") return;
-        if (path.parent.type === "JSXExpressionContainer" && path.parentPath?.parent?.type === "JSXAttribute") return;
-        if (path.parent.type === "JSXExpressionContainer") return;
-        if (path.parent.type === "ObjectProperty" && path.parent.key === path.node) return;
-        if (path.parent.type === "TSLiteralType") return;
-        if (isInsideTCall(path, tFunctionNames)) return;
-        const text = path.node.value;
-        if (!text.trim()) return;
-        const callExpr = getEnclosingCallExpression(path);
-        const parentType = path.parent.type;
-        const classification = classifyString(text.trim(), "string-literal", {
-          parentType,
-          isInsideCallExpression: callExpr,
-          isInsideComponent: false
-        });
-        let { confidence } = classification;
-        if (parentType === "VariableDeclarator" && path.parent.id?.type === "Identifier") {
-          const varName = path.parent.id.name;
-          if (isTranslatableVarName(varName) && classification.translatable) {
-            confidence = "high";
-          }
-        }
-        if (classification.translatable) {
-          candidates.push({
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            column: path.node.loc?.start.column || 0,
-            text: text.trim(),
-            confidence,
-            strategy: "t-function",
-            context: "string-literal",
-            reason: classification.reason
-          });
-        }
-      },
-      // Find template literals
-      TemplateLiteral: (path) => {
-        if (path.parent.type === "ImportDeclaration") return;
-        if (path.parent.type === "TaggedTemplateExpression") return;
-        if (isInsideTCall(path, tFunctionNames)) return;
-        const quasis = path.node.quasis;
-        if (quasis.length === 0) return;
-        const parts = [];
-        for (let i = 0; i < quasis.length; i++) {
-          const quasi = quasis[i];
-          parts.push(quasi.value.raw);
-          if (i < path.node.expressions.length) {
-            const expr = path.node.expressions[i];
-            if (expr.type === "Identifier") {
-              parts.push(`{${expr.name}}`);
-            } else {
-              parts.push("{value}");
-            }
-          }
-        }
-        const text = parts.join("").trim();
-        if (!text) return;
-        const callExpr = getEnclosingCallExpression(path);
-        const parentType = path.parent.type;
-        const classification = classifyString(text, "template-literal", {
-          parentType,
-          isInsideCallExpression: callExpr,
-          isInsideComponent: false
-        });
-        if (classification.translatable) {
-          candidates.push({
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            column: path.node.loc?.start.column || 0,
-            text,
-            confidence: classification.confidence,
-            strategy: "t-function",
-            context: "template-literal",
-            reason: classification.reason
-          });
-        }
-      }
-    });
-    return candidates;
-  }
-};
-function isInsideTCall(path, tNames) {
-  let current = path.parentPath;
-  while (current) {
-    if (current.node.type === "CallExpression") {
-      const callee = current.node.callee;
-      if (callee.type === "Identifier" && tNames.has(callee.name)) {
-        return true;
-      }
-    }
-    current = current.parentPath;
-  }
-  return false;
-}
-function getEnclosingCallExpression(path) {
-  let current = path.parentPath;
-  while (current) {
-    if (current.node.type === "CallExpression") {
-      const callee = current.node.callee;
-      if (callee.type === "Identifier") {
-        return callee.name;
-      }
-      if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.property.type === "Identifier") {
-        return `${callee.object.name}.${callee.property.name}`;
-      }
-    }
-    if (current.node.type === "NewExpression") {
-      const callee = current.node.callee;
-      if (callee.type === "Identifier") {
-        return callee.name;
-      }
-    }
-    current = current.parentPath;
-  }
-  return void 0;
-}
-
-// src/utils/wrap/transformer.ts
-import * as recast from "recast";
-import { parse as babelParse } from "@babel/parser";
-var babelParser = {
-  parse(source) {
-    return babelParse(source, {
-      sourceType: "module",
-      plugins: ["jsx", "typescript"],
-      tokens: true
-    });
-  }
-};
-var StringTransformer = class {
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  /**
-   * Transform a file by wrapping the given candidates.
-   * Returns the transformed source code.
-   */
-  transform(code, candidates, filePath = "<input>") {
-    const ast = recast.parse(code, { parser: babelParser });
-    const b = recast.types.builders;
-    const wrapped = [];
-    const skipped = [];
-    const usedStrategies = /* @__PURE__ */ new Set();
-    const componentsNeedingHook = /* @__PURE__ */ new Set();
-    const candidatesByLocation = /* @__PURE__ */ new Map();
-    for (const c of candidates) {
-      candidatesByLocation.set(`${c.line}:${c.column}`, c);
-    }
-    let existingImportDecl = null;
-    const existingSpecifiers = /* @__PURE__ */ new Set();
-    const adapter = this.adapter;
-    recast.visit(ast, {
-      visitImportDeclaration(path) {
-        const source = path.node.source.value;
-        if (source === adapter.importSource) {
-          existingImportDecl = path;
-          for (const spec of path.node.specifiers || []) {
-            if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier") {
-              existingSpecifiers.add(spec.imported.name);
-            }
-          }
-        }
-        this.traverse(path);
-      },
-      visitJSXText(path) {
-        const loc = path.node.loc;
-        if (!loc) {
-          this.traverse(path);
-          return;
-        }
-        const key = `${loc.start.line}:${loc.start.column}`;
-        const candidate = candidatesByLocation.get(key);
-        if (!candidate || candidate.strategy !== "T-component") {
-          this.traverse(path);
-          return;
-        }
-        const tOpen = b.jsxOpeningElement(
-          b.jsxIdentifier(adapter.componentName),
-          []
-        );
-        const tClose = b.jsxClosingElement(
-          b.jsxIdentifier(adapter.componentName)
-        );
-        const tElement = b.jsxElement(
-          tOpen,
-          tClose,
-          [b.jsxText(candidate.text)]
-        );
-        path.replace(tElement);
-        wrapped.push(candidate);
-        usedStrategies.add("T-component");
-        candidatesByLocation.delete(key);
-        return false;
-      },
-      visitJSXAttribute(path) {
-        const loc = path.node.loc;
-        if (!loc) {
-          this.traverse(path);
-          return;
-        }
-        const key = `${loc.start.line}:${loc.start.column}`;
-        const candidate = candidatesByLocation.get(key);
-        if (!candidate || candidate.strategy !== "t-function") {
-          this.traverse(path);
-          return;
-        }
-        const value = path.node.value;
-        if (!value) {
-          this.traverse(path);
-          return;
-        }
-        const tCall = b.callExpression(
-          b.identifier(adapter.functionName),
-          [b.stringLiteral(candidate.text)]
-        );
-        const exprContainer = b.jsxExpressionContainer(tCall);
-        path.node.value = exprContainer;
-        const componentFunc = findEnclosingComponent(path);
-        if (componentFunc) {
-          componentsNeedingHook.add(componentFunc);
-        }
-        wrapped.push(candidate);
-        usedStrategies.add("t-function");
-        candidatesByLocation.delete(key);
-        this.traverse(path);
-      },
-      visitStringLiteral(path) {
-        const loc = path.node.loc;
-        if (!loc) {
-          this.traverse(path);
-          return;
-        }
-        const key = `${loc.start.line}:${loc.start.column}`;
-        const candidate = candidatesByLocation.get(key);
-        if (!candidate || candidate.strategy !== "t-function") {
-          this.traverse(path);
-          return;
-        }
-        if (path.parent.node.type === "JSXAttribute") {
-          this.traverse(path);
-          return;
-        }
-        const tCall = b.callExpression(
-          b.identifier(adapter.functionName),
-          [b.stringLiteral(candidate.text)]
-        );
-        path.replace(tCall);
-        const componentFunc = findEnclosingComponent(path);
-        if (componentFunc) {
-          componentsNeedingHook.add(componentFunc);
-        }
-        wrapped.push(candidate);
-        usedStrategies.add("t-function");
-        candidatesByLocation.delete(key);
-        return false;
-      }
-    });
-    for (const candidate of candidatesByLocation.values()) {
-      skipped.push(candidate);
-    }
-    if (componentsNeedingHook.size > 0) {
-      this.injectUseVocoderHooks(ast, componentsNeedingHook, b);
-    }
-    this.manageImports(ast, usedStrategies, existingImportDecl, existingSpecifiers, componentsNeedingHook.size > 0, b);
-    const output = recast.print(ast).code;
-    return {
-      file: filePath,
-      output,
-      wrappedCount: wrapped.length,
-      wrapped,
-      skipped
-    };
-  }
-  /**
-   * Inject `const { t } = useVocoder();` at the top of component functions.
-   */
-  injectUseVocoderHooks(ast, componentFuncs, b) {
-    const adapterFunctionName = this.adapter.functionName;
-    const adapterHookName = this.adapter.hookName;
-    const buildHookDecl = () => b.variableDeclaration("const", [
-      b.variableDeclarator(
-        b.objectPattern([
-          b.property.from({
-            kind: "init",
-            key: b.identifier(adapterFunctionName),
-            value: b.identifier(adapterFunctionName),
-            shorthand: true
-          })
-        ]),
-        b.callExpression(b.identifier(adapterHookName), [])
-      )
-    ]);
-    recast.visit(ast, {
-      visitFunction(path) {
-        if (componentFuncs.has(path.node)) {
-          const body = path.node.body;
-          if (body.type === "BlockStatement") {
-            const alreadyHasHook = body.body.some((stmt) => {
-              if (stmt.type !== "VariableDeclaration") return false;
-              return stmt.declarations.some(
-                (decl) => decl.init?.type === "CallExpression" && decl.init.callee?.type === "Identifier" && decl.init.callee.name === "useVocoder"
-              );
-            });
-            if (!alreadyHasHook) {
-              body.body.unshift(buildHookDecl());
-            }
-          }
-        }
-        this.traverse(path);
-      },
-      visitArrowFunctionExpression(path) {
-        if (componentFuncs.has(path.node)) {
-          const body = path.node.body;
-          if (body.type === "BlockStatement") {
-            const alreadyHasHook = body.body.some((stmt) => {
-              if (stmt.type !== "VariableDeclaration") return false;
-              return stmt.declarations.some(
-                (decl) => decl.init?.type === "CallExpression" && decl.init.callee?.type === "Identifier" && decl.init.callee.name === "useVocoder"
-              );
-            });
-            if (!alreadyHasHook) {
-              body.body.unshift(buildHookDecl());
-            }
-          }
-        }
-        this.traverse(path);
-      }
-    });
-  }
-  /**
-   * Add or update @vocoder/react imports.
-   */
-  manageImports(ast, usedStrategies, existingImportPath, existingSpecifiers, needsHook, b) {
-    if (usedStrategies.size === 0) return;
-    const neededSpecifiers = /* @__PURE__ */ new Set();
-    if (usedStrategies.has("T-component")) {
-      neededSpecifiers.add(this.adapter.componentName);
-    }
-    if (usedStrategies.has("t-function") && needsHook) {
-      neededSpecifiers.add(this.adapter.hookName);
-    }
-    const missingSpecifiers = [];
-    for (const spec of neededSpecifiers) {
-      if (!existingSpecifiers.has(spec)) {
-        missingSpecifiers.push(spec);
-      }
-    }
-    if (missingSpecifiers.length === 0) return;
-    if (existingImportPath) {
-      for (const name of missingSpecifiers) {
-        const specifier = b.importSpecifier(b.identifier(name), b.identifier(name));
-        existingImportPath.node.specifiers.push(specifier);
-      }
-    } else {
-      const specifiers = missingSpecifiers.map(
-        (name) => b.importSpecifier(b.identifier(name), b.identifier(name))
-      );
-      const importDecl = b.importDeclaration(
-        specifiers,
-        b.stringLiteral(this.adapter.importSource)
-      );
-      const body = ast.program.body;
-      let lastImportIndex = -1;
-      for (let i = 0; i < body.length; i++) {
-        if (body[i].type === "ImportDeclaration") {
-          lastImportIndex = i;
-        }
-      }
-      if (lastImportIndex >= 0) {
-        body.splice(lastImportIndex + 1, 0, importDecl);
-      } else {
-        body.unshift(importDecl);
-      }
-    }
-  }
-};
-function findEnclosingComponent(path) {
-  let current = path.parent;
-  while (current) {
-    const node = current.node;
-    if (node.type === "FunctionDeclaration" && node.id?.name) {
-      const name = node.id.name;
-      if (/^[A-Z]/.test(name)) return node;
-    }
-    if (node.type === "ArrowFunctionExpression") {
-      const parent = current.parent?.node;
-      if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") {
-        const name = parent.id.name;
-        if (/^[A-Z]/.test(name)) return node;
-      }
-    }
-    if (node.type === "FunctionExpression") {
-      const parent = current.parent?.node;
-      if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") {
-        const name = parent.id.name;
-        if (/^[A-Z]/.test(name)) return node;
-      }
-    }
-    current = current.parent;
-  }
-  return null;
-}
-
-// src/utils/wrap/adapters/react.ts
-var reactAdapter = {
-  name: "react",
-  extensions: [".tsx", ".jsx", ".ts", ".js"],
-  importSource: "@vocoder/react",
-  componentName: "T",
-  functionName: "t",
-  hookName: "useVocoder",
-  translatableAttributes: [
-    "title",
-    "placeholder",
-    "alt",
-    "aria-label",
-    "aria-description",
-    "aria-placeholder",
-    "aria-roledescription",
-    "aria-valuetext",
-    "label",
-    "description",
-    "message",
-    "heading",
-    "caption",
-    "helperText",
-    "errorMessage",
-    "successMessage",
-    "tooltip"
-  ],
-  nonTranslatableAttributes: [
-    "className",
-    "class",
-    "href",
-    "src",
-    "id",
-    "key",
-    "ref",
-    "style",
-    "data-testid",
-    "data-cy",
-    "data-test",
-    "type",
-    "name",
-    "value",
-    "action",
-    "method",
-    "encType",
-    "target",
-    "rel",
-    "role",
-    "tabIndex",
-    "htmlFor",
-    "for",
-    "width",
-    "height",
-    "viewBox",
-    "xmlns",
-    "fill",
-    "stroke"
-  ],
-  isAlreadyWrapped(ancestors, imports) {
-    for (const ancestor of ancestors) {
-      if (ancestor.type === "JSXElement") {
-        const opening = ancestor.openingElement;
-        if (opening && opening.name && opening.name.type === "JSXIdentifier") {
-          const tagName = opening.name.name;
-          if (imports.has(tagName) && imports.get(tagName) === "T") {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
-  },
-  isAlreadyWrappedCall(node, tNames) {
-    if (node.type === "CallExpression") {
-      const callee = node.callee;
-      if (callee.type === "Identifier" && tNames.has(callee.name)) {
-        return true;
-      }
-    }
-    return false;
-  },
-  getRequiredImports(strategies) {
-    const specifiers = [];
-    if (strategies.has("T-component")) {
-      specifiers.push("T");
-    }
-    if (strategies.has("t-function")) {
-      specifiers.push("useVocoder");
-    }
-    return { specifiers, source: "@vocoder/react" };
-  }
-};
-
-// src/commands/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 ${chalk4.cyan(allCandidates.length)} candidate strings`
-    );
-    const filtered = allCandidates.filter(
-      (c) => meetsConfidenceThreshold(c.confidence, confidenceThreshold)
-    );
-    if (filtered.length === 0) {
-      p3.log.warn(
-        `No strings meet the ${chalk4.bold(confidenceThreshold)} confidence threshold.`
-      );
-      p3.log.info("Try --confidence medium or --confidence low to see more candidates.");
-      p3.outro("");
-      return 0;
-    }
-    p3.log.info(
-      `${filtered.length} strings meet ${chalk4.bold(confidenceThreshold)} confidence threshold`
-    );
-    const byFile = /* @__PURE__ */ new Map();
-    for (const c of filtered) {
-      const existing = byFile.get(c.file) || [];
-      existing.push(c);
-      byFile.set(c.file, existing);
-    }
-    if (options.dryRun) {
-      const lines = [];
-      for (const [file, candidates] of byFile) {
-        const relPath = relative2(projectRoot, file);
-        lines.push(chalk4.bold(relPath));
-        for (const c of candidates) {
-          const confidenceColor = c.confidence === "high" ? chalk4.green : c.confidence === "medium" ? chalk4.yellow : chalk4.red;
-          const strategyLabel = c.strategy === "T-component" ? "<T>" : "t()";
-          lines.push(
-            `  ${chalk4.dim(`L${c.line}`)} ${confidenceColor(`[${c.confidence}]`)} ${chalk4.cyan(strategyLabel)} "${truncate(c.text, 50)}"`
-          );
-          if (options.verbose) {
-            lines.push(chalk4.dim(`        ${c.reason}`));
-          }
-        }
-        lines.push("");
-      }
-      lines.push(summarizeCandidates(filtered));
-      p3.note(lines.join("\n"), "Dry run \u2014 would wrap");
-      p3.outro("Run without --dry-run to apply changes.");
-      return 0;
-    }
-    let accepted;
-    if (options.interactive) {
-      accepted = await interactiveConfirm(byFile, projectRoot);
-      if (accepted.length === 0) {
-        p3.log.warn("No strings selected for wrapping.");
-        p3.outro("");
-        return 0;
-      }
-    } else {
-      accepted = filtered;
-    }
-    spinner4.start("Wrapping strings");
-    const transformer = new StringTransformer(reactAdapter);
-    let totalWrapped = 0;
-    let filesModified = 0;
-    const acceptedByFile = /* @__PURE__ */ new Map();
-    for (const c of accepted) {
-      const existing = acceptedByFile.get(c.file) || [];
-      existing.push(c);
-      acceptedByFile.set(c.file, existing);
-    }
-    for (const [file, candidates] of acceptedByFile) {
-      const code = readFileSync4(file, "utf-8");
-      const result = transformer.transform(code, candidates, file);
-      if (result.wrappedCount > 0) {
-        writeFileSync2(file, result.output, "utf-8");
-        totalWrapped += result.wrappedCount;
-        filesModified++;
-      }
-      if (options.verbose && result.skipped.length > 0) {
-        const relPath = relative2(projectRoot, file);
-        p3.log.info(`Skipped ${result.skipped.length} strings in ${relPath}`);
-      }
-    }
-    spinner4.stop(
-      `Wrapped ${chalk4.cyan(totalWrapped)} strings across ${chalk4.cyan(filesModified)} files`
-    );
-    const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
-    p3.outro(`Done! (${duration}s)`);
-    p3.log.info("Next steps:");
-    p3.log.info("  1. Review the changes (git diff)");
-    p3.log.info("  2. Run your tests to verify nothing broke");
-    p3.log.info('  3. Run "vocoder sync" to extract and translate');
-    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(chalk4.bold(relPath));
-    let skipFile = false;
-    for (const c of candidates) {
-      if (skipFile) break;
-      const strategyLabel = c.strategy === "T-component" ? "<T>" : "t()";
-      const label = `L${c.line} ${strategyLabel} "${truncate(c.text, 50)}"`;
-      const action = await p3.select({
-        message: label,
-        options: [
-          { value: "yes", label: "Yes, wrap this string" },
-          { value: "no", label: "No, skip" },
-          { value: "all", label: "Accept all remaining" },
-          { value: "skip", label: "Skip this file" },
-          { value: "quit", label: "Quit" }
-        ]
-      });
-      if (p3.isCancel(action) || action === "quit") {
-        return accepted;
-      }
-      if (action === "yes") {
-        accepted.push(c);
-      } else if (action === "all") {
-        accepted.push(c);
-        const remaining = candidates.slice(candidates.indexOf(c) + 1);
-        accepted.push(...remaining);
-        for (const [, moreCandidates] of byFile) {
-          if (moreCandidates !== candidates) {
-            accepted.push(...moreCandidates);
-          }
-        }
-        return accepted;
-      } else if (action === "skip") {
-        skipFile = true;
-      }
-    }
-  }
-  return accepted;
-}
-function truncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen - 3) + "...";
-}
-function summarizeCandidates(candidates) {
-  let high = 0;
-  let medium = 0;
-  let low = 0;
-  let tComponent = 0;
-  let tFunction = 0;
-  for (const c of candidates) {
-    if (c.confidence === "high") high++;
-    else if (c.confidence === "medium") medium++;
-    else low++;
-    if (c.strategy === "T-component") tComponent++;
-    else tFunction++;
-  }
-  const parts = [];
-  if (high > 0) parts.push(chalk4.green(`${high} high`));
-  if (medium > 0) parts.push(chalk4.yellow(`${medium} medium`));
-  if (low > 0) parts.push(chalk4.red(`${low} low`));
-  return `${candidates.length} total (${parts.join(", ")}) | ${tComponent} <T>, ${tFunction} t()`;
-}
-
 // src/bin.ts
 function collect(value, previous = []) {
   return previous.concat([value]);
@@ -2737,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