@vocoder/cli 0.1.1 → 0.1.3

package/dist/chunk-N45Q4R6O.mjs

@@ -1,635 +0,0 @@
-// src/utils/branch.ts
-import { execSync } from "child_process";
-function detectBranch(override) {
-  if (override) {
-    return override;
-  }
-  const envBranch = process.env.GITHUB_REF_NAME || // GitHub Actions
-  process.env.VERCEL_GIT_COMMIT_REF || // Vercel
-  process.env.BRANCH || // Netlify, generic
-  process.env.CI_COMMIT_REF_NAME || // GitLab
-  process.env.BITBUCKET_BRANCH || // Bitbucket
-  process.env.CIRCLE_BRANCH;
-  if (envBranch) {
-    return envBranch;
-  }
-  try {
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
-    }).trim();
-    return branch;
-  } catch (error) {
-    throw new Error(
-      "Failed to detect git branch. Make sure you are in a git repository or set the --branch flag."
-    );
-  }
-}
-function isTargetBranch(currentBranch, targetBranches) {
-  return targetBranches.includes(currentBranch);
-}
-
-// src/utils/config.ts
-import { config as loadEnv } from "dotenv";
-loadEnv();
-function getLocalConfig() {
-  const apiKey = process.env.VOCODER_API_KEY;
-  if (!apiKey) {
-    throw new Error(
-      'VOCODER_API_KEY is required. Set it in your .env file or environment:\n  export VOCODER_API_KEY="your-api-key"\n\nGet your API key from: https://vocoder.app/settings/api-keys'
-    );
-  }
-  return {
-    apiKey,
-    apiUrl: process.env.VOCODER_API_URL || "https://vocoder.app"
-  };
-}
-function validateLocalConfig(config) {
-  if (!config.apiKey || config.apiKey.length === 0) {
-    throw new Error("Invalid API key");
-  }
-  if (!config.apiKey.startsWith("vc_")) {
-    throw new Error("Invalid API key format. Expected format: vc_...");
-  }
-  if (!config.apiUrl || !config.apiUrl.startsWith("http")) {
-    throw new Error("Invalid API URL");
-  }
-}
-
-// src/commands/sync.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { join, dirname } from "path";
-import chalk from "chalk";
-import ora from "ora";
-
-// src/utils/api.ts
-var VocoderAPI = class {
-  constructor(config) {
-    this.apiUrl = config.apiUrl;
-    this.apiKey = config.apiKey;
-  }
-  /**
-   * Fetch project configuration from API
-   * Project is determined from the API key
-   */
-  async getProjectConfig() {
-    const response = await fetch(
-      `${this.apiUrl}/api/cli/config`,
-      {
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`
-        }
-      }
-    );
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to fetch project config: ${error}`);
-    }
-    const data = await response.json();
-    return {
-      sourceLocale: data.sourceLocale,
-      targetLocales: data.targetLocales,
-      targetBranches: data.targetBranches
-    };
-  }
-  /**
-   * Submit strings for translation
-   * Project is determined from the API key
-   */
-  async submitTranslation(branch, strings, targetLocales) {
-    const crypto = await import("crypto");
-    const sortedStrings = [...strings].sort();
-    const stringsHash = crypto.createHash("sha256").update(JSON.stringify(sortedStrings)).digest("hex");
-    const response = await fetch(`${this.apiUrl}/api/cli/sync`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        branch,
-        strings,
-        targetLocales,
-        stringsHash
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Translation submission failed: ${error}`);
-    }
-    return response.json();
-  }
-  /**
-   * Check translation status
-   */
-  async getTranslationStatus(batchId) {
-    const response = await fetch(
-      `${this.apiUrl}/api/cli/sync/status/${batchId}`,
-      {
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`
-        }
-      }
-    );
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to check translation status: ${error}`);
-    }
-    return response.json();
-  }
-  /**
-   * Wait for translation to complete with polling
-   */
-  async waitForCompletion(batchId, timeout = 6e4, onProgress) {
-    const startTime = Date.now();
-    const pollInterval = 1e3;
-    while (Date.now() - startTime < timeout) {
-      const status = await this.getTranslationStatus(batchId);
-      if (onProgress) {
-        onProgress(status.progress);
-      }
-      if (status.status === "COMPLETED") {
-        if (!status.translations) {
-          throw new Error("Translation completed but no translations returned");
-        }
-        return {
-          translations: status.translations,
-          localeMetadata: status.localeMetadata
-        };
-      }
-      if (status.status === "FAILED") {
-        throw new Error(
-          `Translation failed: ${status.errorMessage || "Unknown error"}`
-        );
-      }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    }
-    throw new Error(`Translation timeout after ${timeout}ms`);
-  }
-};
-
-// src/utils/extract.ts
-import { readFileSync } from "fs";
-import { parse } from "@babel/parser";
-import babelTraverse from "@babel/traverse";
-import { glob } from "glob";
-var traverse = babelTraverse.default || babelTraverse;
-var StringExtractor = class {
-  /**
-   * Extract strings from all files matching the pattern
-   */
-  async extractFromProject(pattern, projectRoot = process.cwd()) {
-    const files = await glob(pattern, {
-      cwd: projectRoot,
-      absolute: true,
-      ignore: ["**/node_modules/**", "**/.next/**", "**/dist/**", "**/build/**"]
-    });
-    const allStrings = [];
-    for (const file of files) {
-      try {
-        const strings = await this.extractFromFile(file);
-        allStrings.push(...strings);
-      } catch (error) {
-        console.warn(`Warning: Failed to extract from ${file}:`, error);
-      }
-    }
-    const unique = this.deduplicateStrings(allStrings);
-    return unique;
-  }
-  /**
-   * Extract strings from a single file
-   */
-  async extractFromFile(filePath) {
-    const code = readFileSync(filePath, "utf-8");
-    const strings = [];
-    try {
-      const ast = parse(code, {
-        sourceType: "module",
-        plugins: ["jsx", "typescript"]
-      });
-      const vocoderImports = /* @__PURE__ */ new Map();
-      const tFunctionNames = /* @__PURE__ */ new Set();
-      traverse(ast, {
-        // Track imports of <T> component and t function
-        ImportDeclaration: (path) => {
-          const source = path.node.source.value;
-          if (source === "@vocoder/react") {
-            path.node.specifiers.forEach((spec) => {
-              if (spec.type === "ImportSpecifier") {
-                const imported = spec.imported.type === "Identifier" ? spec.imported.name : null;
-                const local = spec.local.name;
-                if (imported === "T") {
-                  vocoderImports.set(local, "T");
-                }
-                if (imported === "t") {
-                  tFunctionNames.add(local);
-                }
-                if (imported === "useVocoder") {
-                }
-              }
-            });
-          }
-        },
-        // Track destructured 't' from useVocoder hook
-        VariableDeclarator: (path) => {
-          const init = path.node.init;
-          if (init && init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "useVocoder" && path.node.id.type === "ObjectPattern") {
-            path.node.id.properties.forEach((prop) => {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "t") {
-                const localName = prop.value.type === "Identifier" ? prop.value.name : "t";
-                tFunctionNames.add(localName);
-              }
-            });
-          }
-        },
-        // Extract from t() function calls
-        CallExpression: (path) => {
-          const callee = path.node.callee;
-          const isTFunction = callee.type === "Identifier" && tFunctionNames.has(callee.name);
-          if (!isTFunction) return;
-          const firstArg = path.node.arguments[0];
-          if (!firstArg) return;
-          let text = null;
-          if (firstArg.type === "StringLiteral") {
-            text = firstArg.value;
-          } else if (firstArg.type === "TemplateLiteral") {
-            text = this.extractTemplateText(firstArg);
-          }
-          if (!text || text.trim().length === 0) return;
-          const secondArg = path.node.arguments[1];
-          let context;
-          let formality;
-          if (secondArg && secondArg.type === "ObjectExpression") {
-            secondArg.properties.forEach((prop) => {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
-                if (prop.key.name === "context" && prop.value.type === "StringLiteral") {
-                  context = prop.value.value;
-                }
-                if (prop.key.name === "formality" && prop.value.type === "StringLiteral") {
-                  formality = prop.value.value;
-                }
-              }
-            });
-          }
-          strings.push({
-            text: text.trim(),
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            context,
-            formality
-          });
-        },
-        // Extract from JSX elements
-        JSXElement: (path) => {
-          const opening = path.node.openingElement;
-          const tagName = opening.name.type === "JSXIdentifier" ? opening.name.name : null;
-          if (!tagName) return;
-          const isTranslationComponent = vocoderImports.has(tagName);
-          if (!isTranslationComponent) return;
-          const text = this.extractTextContent(path.node.children);
-          if (!text || text.trim().length === 0) return;
-          const context = this.getStringAttribute(opening.attributes, "context");
-          const formality = this.getStringAttribute(
-            opening.attributes,
-            "formality"
-          );
-          strings.push({
-            text: text.trim(),
-            file: filePath,
-            line: path.node.loc?.start.line || 0,
-            context,
-            formality
-          });
-        }
-      });
-    } catch (error) {
-      throw new Error(
-        `Failed to parse ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-    return strings;
-  }
-  /**
-   * Extract text from template literal
-   * Converts template literals like `Hello ${name}` to `Hello {name}`
-   */
-  extractTemplateText(node) {
-    let text = "";
-    for (let i = 0; i < node.quasis.length; i++) {
-      const quasi = node.quasis[i];
-      text += quasi.value.raw;
-      if (i < node.expressions.length) {
-        const expr = node.expressions[i];
-        if (expr.type === "Identifier") {
-          text += `{${expr.name}}`;
-        } else {
-          text += "{value}";
-        }
-      }
-    }
-    return text;
-  }
-  /**
-   * Extract text content from JSX children
-   */
-  extractTextContent(children) {
-    let text = "";
-    for (const child of children) {
-      if (child.type === "JSXText") {
-        text += child.value;
-      } else if (child.type === "JSXExpressionContainer") {
-        const expr = child.expression;
-        if (expr.type === "Identifier") {
-          text += `{${expr.name}}`;
-        } else if (expr.type === "StringLiteral") {
-          text += expr.value;
-        } else if (expr.type === "TemplateLiteral") {
-          text += this.extractTemplateText(expr);
-        }
-      }
-    }
-    return text;
-  }
-  /**
-   * Get string value from JSX attribute
-   */
-  getStringAttribute(attributes, name) {
-    const attr = attributes.find(
-      (a) => a.type === "JSXAttribute" && a.name.name === name
-    );
-    if (!attr || !attr.value) return void 0;
-    if (attr.value.type === "StringLiteral") {
-      return attr.value.value;
-    }
-    return void 0;
-  }
-  /**
-   * Deduplicate strings (keep first occurrence)
-   */
-  deduplicateStrings(strings) {
-    const seen = /* @__PURE__ */ new Set();
-    const unique = [];
-    for (const str of strings) {
-      const key = `${str.text}|${str.context || ""}|${str.formality || ""}`;
-      if (!seen.has(key)) {
-        seen.add(key);
-        unique.push(str);
-      }
-    }
-    return unique;
-  }
-};
-
-// src/commands/sync.ts
-function generateIndexFile(locales, translations, localeMetadata) {
-  const toIdentifier = (locale) => locale.replace(/-/g, "_");
-  const imports = locales.map(
-    (locale) => `import ${toIdentifier(locale)} from './${locale}.json';`
-  ).join("\n");
-  const translationsObj = locales.map(
-    (locale) => `  '${locale}': ${toIdentifier(locale)},`
-  ).join("\n");
-  const localesObjEntries = locales.map((locale) => {
-    const metadata = localeMetadata?.[locale];
-    if (metadata) {
-      const escapedNativeName = metadata.nativeName.replace(/'/g, "\\'");
-      const dirProp = metadata.dir ? `, dir: '${metadata.dir}' as const` : "";
-      return `  '${locale}': { nativeName: '${escapedNativeName}'${dirProp} }`;
-    } else {
-      return `  '${locale}': { nativeName: '${locale}' }`;
-    }
-  });
-  const localesObjString = localesObjEntries.join(",\n");
-  return `// Auto-generated by Vocoder CLI
-// This file imports all locale JSON files and exports them as a single object
-// Usage: import { translations, locales } from './.vocoder/locales';
-
-${imports}
-
-export const translations = {
-${translationsObj}
-};
-
-/**
- * Flat locale metadata map (O(N))
- * Structure: locales[localeCode] = { nativeName, dir? }
- * - nativeName: Name in the locale's own language (e.g., "Espa\xF1ol", "\u7B80\u4F53\u4E2D\u6587")
- * - dir: Optional 'rtl' for right-to-left locales
- *
- * Translated names are generated at runtime using Intl.DisplayNames:
- * Example: new Intl.DisplayNames(['es'], { type: 'language' }).of('en') \u2192 "ingl\xE9s"
- * Display format: \`\${getDisplayName(code)} (\${locales[code].nativeName})\` \u2192 "ingl\xE9s (English)"
- */
-export const locales = {
-${localesObjString}
-};
-
-export type SupportedLocale = ${locales.map((l) => `'${l}'`).join(" | ")};
-`;
-}
-async function sync(options = {}) {
-  const startTime = Date.now();
-  const projectRoot = process.cwd();
-  try {
-    const spinner = ora("Detecting branch...").start();
-    const branch = detectBranch(options.branch);
-    spinner.succeed(`Detected branch: ${chalk.cyan(branch)}`);
-    spinner.start("Loading project configuration...");
-    const localConfig = getLocalConfig();
-    validateLocalConfig(localConfig);
-    const api = new VocoderAPI(localConfig);
-    const apiConfig = await api.getProjectConfig();
-    const config = {
-      ...localConfig,
-      ...apiConfig,
-      extractionPattern: process.env.VOCODER_EXTRACTION_PATTERN || "src/**/*.{tsx,jsx,ts,js}",
-      outputDir: ".vocoder/locales",
-      timeout: 6e4
-    };
-    spinner.succeed("Project configuration loaded");
-    if (!options.force && !isTargetBranch(branch, config.targetBranches)) {
-      console.log(
-        chalk.yellow(
-          `\u2139\uFE0F  Skipping translations (${branch} is not a target branch)`
-        )
-      );
-      console.log(
-        chalk.dim(
-          `   Target branches: ${config.targetBranches.join(", ")}`
-        )
-      );
-      console.log(chalk.dim(`   Use --force to translate anyway`));
-      process.exit(0);
-    }
-    spinner.start(`Extracting strings from ${config.extractionPattern}...`);
-    const extractor = new StringExtractor();
-    const extractedStrings = await extractor.extractFromProject(
-      config.extractionPattern,
-      projectRoot
-    );
-    if (extractedStrings.length === 0) {
-      spinner.warn("No translatable strings found");
-      console.log(chalk.yellow("Make sure you are using <T> components from @vocoder/react"));
-      process.exit(0);
-    }
-    spinner.succeed(
-      `Extracted ${chalk.cyan(extractedStrings.length)} strings from ${chalk.cyan(config.extractionPattern)}`
-    );
-    if (options.verbose) {
-      console.log(chalk.dim("\nSample strings:"));
-      extractedStrings.slice(0, 5).forEach((s) => {
-        console.log(chalk.dim(`  - "${s.text}" (${s.file}:${s.line})`));
-      });
-      if (extractedStrings.length > 5) {
-        console.log(chalk.dim(`  ... and ${extractedStrings.length - 5} more`));
-      }
-      console.log();
-    }
-    if (options.dryRun) {
-      console.log(chalk.cyan("\n\u{1F4CB} Dry run mode - would translate:"));
-      console.log(chalk.dim(`   Strings: ${extractedStrings.length}`));
-      console.log(chalk.dim(`   Branch: ${branch}`));
-      console.log(chalk.dim(`   Target locales: ${config.targetLocales.join(", ")}`));
-      console.log(chalk.dim(`
-   No API calls made.`));
-      process.exit(0);
-    }
-    spinner.start("Submitting strings to Vocoder API...");
-    const strings = extractedStrings.map((s) => s.text);
-    const batchResponse = await api.submitTranslation(
-      branch,
-      strings,
-      config.targetLocales
-    );
-    spinner.succeed(
-      `Submitted to API - Batch ID: ${chalk.cyan(batchResponse.batchId)}`
-    );
-    if (batchResponse.status === "UP_TO_DATE" && batchResponse.noChanges) {
-      console.log(chalk.green("\n\u2714 No changes detected - strings are up to date"));
-      console.log(chalk.dim("   (Files will be written for build environment)\n"));
-    }
-    console.log(
-      chalk.dim(
-        `   New strings: ${chalk.cyan(batchResponse.newStrings)}`
-      )
-    );
-    if (batchResponse.deletedStrings && batchResponse.deletedStrings > 0) {
-      console.log(
-        chalk.dim(
-          `   Deleted strings: ${chalk.yellow(batchResponse.deletedStrings)} (archived)`
-        )
-      );
-    }
-    console.log(
-      chalk.dim(
-        `   Total strings: ${chalk.cyan(batchResponse.totalStrings)}`
-      )
-    );
-    if (batchResponse.newStrings === 0) {
-      console.log(
-        chalk.green("\n\u2705 No new strings - using existing translations")
-      );
-    } else {
-      console.log(
-        chalk.cyan(
-          `
-\u23F3 Syncing to ${config.targetLocales.length} locales (${config.targetLocales.join(", ")})`
-        )
-      );
-      if (batchResponse.estimatedTime) {
-        console.log(
-          chalk.dim(
-            `   Estimated time: ~${batchResponse.estimatedTime} seconds`
-          )
-        );
-      }
-    }
-    spinner.start("Waiting for translations to complete...");
-    let lastProgress = 0;
-    const result = await api.waitForCompletion(
-      batchResponse.batchId,
-      config.timeout,
-      (progress) => {
-        const percent = Math.round(progress * 100);
-        if (percent > lastProgress) {
-          spinner.text = `Syncing... ${percent}% complete`;
-          lastProgress = percent;
-        }
-      }
-    );
-    const { translations, localeMetadata: apiLocaleMetadata } = result;
-    spinner.succeed("Translations complete!");
-    spinner.start(`Writing locale files to ${config.outputDir}...`);
-    const outputPath = join(projectRoot, config.outputDir);
-    mkdirSync(outputPath, { recursive: true });
-    let filesWritten = 0;
-    const localeNames = [];
-    for (const [locale, strings2] of Object.entries(translations)) {
-      const filePath = join(outputPath, `${locale}.json`);
-      const content = JSON.stringify(strings2, null, 2);
-      mkdirSync(dirname(filePath), { recursive: true });
-      writeFileSync(filePath, content, "utf-8");
-      filesWritten++;
-      localeNames.push(locale);
-      const sizeKB = (content.length / 1024).toFixed(1);
-      console.log(
-        chalk.dim(`   \u2713 Wrote ${locale}.json (${sizeKB}KB)`)
-      );
-    }
-    const indexContent = generateIndexFile(localeNames, translations, apiLocaleMetadata);
-    const indexPath = join(outputPath, "index.ts");
-    writeFileSync(indexPath, indexContent, "utf-8");
-    console.log(chalk.dim(`   \u2713 Generated index.ts (with flat locales map)`));
-    spinner.succeed(`Wrote ${chalk.cyan(filesWritten)} locale files`);
-    const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
-    console.log(
-      chalk.green(`
-\u2705 Sync complete! (${duration}s)
-`)
-    );
-    console.log(chalk.dim("Next steps:"));
-    console.log(
-      chalk.dim(
-        `   1. Import translations: import { translations } from '${config.outputDir}'`
-      )
-    );
-    console.log(
-      chalk.dim(
-        `   2. Use VocoderProvider: <VocoderProvider translations={translations} defaultLocale="en">`
-      )
-    );
-    console.log(
-      chalk.dim(
-        `   3. Commit ${config.outputDir}/ to your repository`
-      )
-    );
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(chalk.red(`
-\u274C Error: ${error.message}
-`));
-      if (error.message.includes("VOCODER_API_KEY")) {
-        console.log(chalk.yellow("\u{1F4A1} Solution:"));
-        console.log(chalk.dim("   Set your API key:"));
-        console.log(chalk.dim('   export VOCODER_API_KEY="your-api-key"'));
-        console.log(chalk.dim("   or add it to your .env file"));
-      } else if (error.message.includes("git branch")) {
-        console.log(chalk.yellow("\u{1F4A1} Solution:"));
-        console.log(chalk.dim("   Run from a git repository, or use:"));
-        console.log(chalk.dim("   vocoder translate --branch main"));
-      }
-      if (options.verbose) {
-        console.error(chalk.dim("\nFull error:"), error);
-      }
-    }
-    process.exit(1);
-  }
-}
-
-export {
-  detectBranch,
-  getLocalConfig,
-  validateLocalConfig,
-  sync
-};
-//# sourceMappingURL=chunk-N45Q4R6O.mjs.map