i18next-cli 1.61.1 → 1.63.0

package/dist/cjs/locize.js

@@ -6,6 +6,11 @@ var ora = require('ora');
 var inquirer = require('inquirer');
 var node_path = require('node:path');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
+
 /**
  * Resolves the locize-cli executable to use.
  *
@@ -63,7 +68,7 @@ async function resolveLocizeBin() {
  */
 async function interactiveCredentialSetup(config) {
     console.log(node_util.styleText('yellow', '\nLocize configuration is missing or invalid. Let\'s set it up!'));
-    const answers = await inquirer.prompt([
+    const answers = await inquirer__default.default.prompt([
         {
             type: 'input',
             name: 'projectId',
@@ -73,7 +78,7 @@ async function interactiveCredentialSetup(config) {
         {
             type: 'password',
             name: 'apiKey',
-            message: 'Enter your Locize API key (Project settings → API → API Keys). If your project has no languages yet, use an API key with admin role.',
+            message: 'Enter your Locize API key (Project settings → API → API Keys). Any write-capable key works — missing languages are created automatically for new projects.',
             validate: input => !!input || 'API Key cannot be empty.',
         },
         {
@@ -87,7 +92,7 @@ async function interactiveCredentialSetup(config) {
         console.error(node_util.styleText('red', 'Project ID is required to continue.'));
         return undefined;
     }
-    const { save } = await inquirer.prompt([{
+    const { save } = await inquirer__default.default.prompt([{
             type: 'confirm',
             name: 'save',
             message: 'Would you like to see how to save these credentials for future use?',
@@ -119,11 +124,42 @@ LOCIZE_API_KEY=${answers.apiKey}
     };
 }
 /**
- * Masks an API key for safe console output, preserving only the first
- * and last 3 characters while replacing everything in between.
+ * Error thrown by {@link runLocizeCommand} when `throwOnError` is set,
+ * carrying the captured output of the failed locize-cli invocation so
+ * orchestrating commands (e.g. `localize`) can inspect and react to it.
+ */
+class LocizeCommandError extends Error {
+    stdout;
+    stderr;
+    constructor(message, output = {}) {
+        super(message);
+        this.name = 'LocizeCommandError';
+        this.stdout = output.stdout || '';
+        this.stderr = output.stderr || '';
+    }
+}
+/** Prefixed Locize token formats (PATs and the newer api-keys). */
+const SECRET_PREFIXES = ['lz_pat_', 'lz_api_'];
+const PREFIXED_VISIBLE_RANDOM_CHARS = 4;
+const PREFIXED_VISIBLE_END_CHARS = 4;
+/**
+ * Masks an API key / PAT for safe console output, mirroring Locize's own
+ * maskSecret format:
+ * - prefixed tokens: `lz_pat_4xK9****************************oZ1i`
+ * - legacy UUID keys: first and last 3 characters visible
  */
 function maskApiKey(apiKey) {
-    if (!apiKey || apiKey.length <= 6)
+    if (!apiKey)
+        return apiKey;
+    const matchedPrefix = SECRET_PREFIXES.find(p => apiKey.startsWith(p));
+    if (matchedPrefix) {
+        const visibleStart = matchedPrefix.length + PREFIXED_VISIBLE_RANDOM_CHARS;
+        const start = apiKey.substring(0, visibleStart);
+        const end = apiKey.substring(apiKey.length - PREFIXED_VISIBLE_END_CHARS);
+        const middle = apiKey.substring(visibleStart, apiKey.length - PREFIXED_VISIBLE_END_CHARS);
+        return `${start}${middle.replace(/[0-9a-zA-Z]/g, '*')}${end}`;
+    }
+    if (apiKey.length <= 6)
         return apiKey;
     const first3 = apiKey.substring(0, 3);
     const last3 = apiKey.substring(apiKey.length - 3);
@@ -147,16 +183,23 @@ function maskArgs(args) {
 function buildArgs(command, config, cliOptions) {
     const { locize: locizeConfig = {}, extract } = config;
     const commandArgs = [command];
-    const projectId = cliOptions.projectId ?? locizeConfig.projectId;
+    // Resolve credentials explicitly (CLI option → config → env var) and always
+    // forward them as flags. locize-cli would pick env vars up itself, but its
+    // own precedence puts a ~/.locize config file ABOVE the environment — a
+    // stale ~/.locize would silently redirect the run to another project.
+    const projectId = cliOptions.projectId ?? locizeConfig.projectId ?? process.env.LOCIZE_PROJECTID ?? process.env.LOCIZE_PID;
     if (projectId)
         commandArgs.push('--project-id', projectId);
-    const apiKey = cliOptions.apiKey ?? locizeConfig.apiKey;
+    const apiKey = cliOptions.apiKey ?? locizeConfig.apiKey ?? process.env.LOCIZE_API_KEY ?? process.env.LOCIZE_KEY;
     if (apiKey)
         commandArgs.push('--api-key', apiKey);
-    const version = cliOptions.version ?? locizeConfig.version;
+    const version = cliOptions.version ?? locizeConfig.version ?? process.env.LOCIZE_VERSION ?? process.env.LOCIZE_VER;
     if (version)
         commandArgs.push('--ver', version);
-    const cdnType = cliOptions.cdnType ?? locizeConfig.cdnType;
+    const apiEndpoint = cliOptions.apiEndpoint ?? locizeConfig.apiEndpoint ?? process.env.LOCIZE_API_ENDPOINT;
+    if (apiEndpoint)
+        commandArgs.push('--api-endpoint', apiEndpoint);
+    const cdnType = cliOptions.cdnType ?? locizeConfig.cdnType ?? process.env.LOCIZE_CDN_TYPE;
     if (cdnType)
         commandArgs.push('--cdn-type', cdnType);
     // TODO: there might be more configurable locize-cli options in future
@@ -179,6 +222,20 @@ function buildArgs(command, config, cliOptions) {
         const dryRun = cliOptions.dryRun ?? locizeConfig.dryRun;
         if (dryRun)
             commandArgs.push('--dry', 'true');
+        const autoTranslate = cliOptions.autoTranslate ?? locizeConfig.autoTranslate;
+        if (autoTranslate !== undefined) {
+            commandArgs.push('--auto-translate', String(autoTranslate === true || autoTranslate === 'true'));
+        }
+        const autoTranslateReview = cliOptions.autoTranslateReview ?? locizeConfig.autoTranslateReview;
+        if (autoTranslateReview !== undefined) {
+            commandArgs.push('--auto-translate-review', String(autoTranslateReview === true || autoTranslateReview === 'true'));
+        }
+        const autoTranslateLanguages = cliOptions.autoTranslateLanguages ?? locizeConfig.autoTranslateLanguages;
+        if (autoTranslateLanguages) {
+            const languages = Array.isArray(autoTranslateLanguages) ? autoTranslateLanguages.join(',') : String(autoTranslateLanguages);
+            if (languages)
+                commandArgs.push('--auto-translate-languages', languages);
+        }
     }
     // Derive a sensible base path for locize from the configured output.
     // If output is a string template we can strip the language placeholder.
@@ -249,8 +306,16 @@ function buildArgs(command, config, cliOptions) {
  * ```
  */
 async function runLocizeCommand(command, config, cliOptions = {}) {
+    const throwOnError = !!cliOptions.throwOnError;
     const resolved = await resolveLocizeBin();
     if (!resolved) {
+        const installHint = 'Error: `locize-cli` command not found.\n' +
+            'Please install it to use the Locize integration:\n' +
+            '  npm install -g locize-cli\n' +
+            'Or make sure npx is available so it can be fetched on demand.';
+        if (throwOnError) {
+            throw new LocizeCommandError(installHint);
+        }
         console.error(node_util.styleText('red', 'Error: `locize-cli` command not found.'));
         console.log(node_util.styleText('yellow', 'Please install it to use the Locize integration:'));
         console.log(node_util.styleText('cyan', '  npm install -g locize-cli'));
@@ -259,7 +324,7 @@ async function runLocizeCommand(command, config, cliOptions = {}) {
         return;
     }
     const { cmd, prefixArgs } = resolved;
-    const spinner = ora(`Running 'locize ${command}'...\n`).start();
+    const spinner = ora__default.default(`Running 'locize ${command}'...\n`).start();
     let effectiveConfig = config;
     try {
         // 1. First attempt
@@ -272,6 +337,12 @@ async function runLocizeCommand(command, config, cliOptions = {}) {
     }
     catch (error) {
         const stderr = error.stderr || '';
+        if (throwOnError) {
+            // Orchestrating callers (e.g. `localize`) handle credentials and
+            // messaging themselves — no interactive retry, no process.exit.
+            spinner.fail(node_util.styleText('red', `Error executing 'locize ${command}'.`));
+            throw new LocizeCommandError(stderr || error.stdout || error.message, { stdout: error.stdout, stderr });
+        }
         if (stderr.includes('missing required argument')) {
             // 2. Auth failure, trigger interactive setup
             spinner.stop();
@@ -312,6 +383,8 @@ const runLocizeSync = (config, cliOptions) => runLocizeCommand('sync', config, c
 const runLocizeDownload = (config, cliOptions) => runLocizeCommand('download', config, cliOptions);
 const runLocizeMigrate = (config, cliOptions) => runLocizeCommand('migrate', config, cliOptions);
 
+exports.LocizeCommandError = LocizeCommandError;
+exports.maskApiKey = maskApiKey;
 exports.runLocizeDownload = runLocizeDownload;
 exports.runLocizeMigrate = runLocizeMigrate;
 exports.runLocizeSync = runLocizeSync;

package/dist/cjs/status.js

@@ -15,6 +15,10 @@ var contextVariants = require('./utils/context-variants.js');
 var funnelMsgTracker = require('./utils/funnel-msg-tracker.js');
 require('node:module');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+
 function classifyValue(value) {
     if (value === undefined || value === null)
         return 'absent';
@@ -44,7 +48,7 @@ function classifyValue(value) {
 async function runStatus(config, options = {}) {
     config.extract.primaryLanguage ||= config.locales[0] || 'en';
     config.extract.secondaryLanguages ||= config.locales.filter((l) => l !== config?.extract?.primaryLanguage);
-    const spinner = ora('Analyzing project localization status...\n').start();
+    const spinner = ora__default.default('Analyzing project localization status...\n').start();
     try {
         const report = await generateStatusReport(config);
         spinner.succeed('Analysis complete.');

package/dist/cjs/types-generator.js

@@ -13,6 +13,11 @@ var json5Parser = require('@croct/json5-parser');
 var yaml = require('yaml');
 var vm = require('node:vm');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var yaml__default = /*#__PURE__*/_interopDefault(yaml);
+var vm__default = /*#__PURE__*/_interopDefault(vm);
+
 async function loadFile(file) {
     const ext = node_path.extname(file);
     if (['.ts', '.mts', '.cts', '.js', '.mjs', '.cjs'].includes(ext)) {
@@ -31,14 +36,14 @@ async function loadFile(file) {
         });
         const exports = {};
         const module = { exports };
-        const context = vm.createContext({
+        const context = vm__default.default.createContext({
             exports,
             module,
             require: (id) => require(id),
             console,
             process
         });
-        const script = new vm.Script(code, { filename: file });
+        const script = new vm__default.default.Script(code, { filename: file });
         script.runInContext(context);
         // @ts-ignore
         const exported = context.module.exports?.default || context.module.exports;
@@ -46,7 +51,7 @@ async function loadFile(file) {
     }
     const content = await promises.readFile(file, 'utf-8');
     if (ext === '.yaml' || ext === '.yml') {
-        return yaml.parse(content);
+        return yaml__default.default.parse(content);
     }
     if (ext === '.json5') {
         return json5Parser.JsonParser.parse(content, json5Parser.JsonObjectNode).toJSON();

package/dist/cjs/utils/file-utils.js

@@ -7,6 +7,10 @@ var config = require('../config.js');
 var json5Parser = require('@croct/json5-parser');
 var yaml = require('yaml');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var yaml__default = /*#__PURE__*/_interopDefault(yaml);
+
 /**
  * Thrown when an existing translation file in a structured data format
  * (JSON/JSON5/YAML) exists on disk but cannot be parsed. Callers should treat
@@ -97,7 +101,7 @@ async function loadTranslationFile(filePath) {
     else if (ext === '.yaml' || ext === '.yml') {
         const content = await promises.readFile(fullPath, 'utf-8');
         try {
-            return yaml.parse(content);
+            return yaml__default.default.parse(content);
         }
         catch (error) {
             throw new ParseTranslationFileError(filePath, error);
@@ -165,7 +169,7 @@ function serializeTranslationFile(data, format = 'json', indentation = 2, rawCon
             return node.toString({ object: { indentationSize: Number(indentation) ?? 2 } });
         }
         case 'yaml':
-            return yaml.stringify(data, { indent: Number(indentation) || 2, lineWidth: 0 });
+            return yaml__default.default.stringify(data, { indent: Number(indentation) || 2, lineWidth: 0 });
         case 'js':
         case 'js-esm':
             return `export default ${jsonString};\n`;

package/dist/cjs/utils/inlang-scaffold.js

@@ -0,0 +1,184 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var node_path = require('node:path');
+var jsoncParser = require('jsonc-parser');
+
+/**
+ * The plugin that teaches inlang tools (Sherlock, Fink, Paraglide) to read and
+ * write i18next JSON resource files directly.
+ *
+ * Pinned to an exact version on purpose: 6.2.0 is the first release with
+ * verified round-trip support for plurals, context, `_zero` and ordinal keys,
+ * and jsDelivr serves floating range URLs (`@6`) from edge caches that can
+ * lag releases by days. Bump deliberately when newer verified versions ship.
+ */
+const INLANG_PLUGIN_MODULE = 'https://cdn.jsdelivr.net/npm/@inlang/plugin-i18next@6.2.0/dist/index.js';
+/** VS Code marketplace id of the inlang Sherlock extension. */
+const SHERLOCK_EXTENSION_ID = 'inlang.vs-code-extension';
+/**
+ * Scaffolds an inlang project (`project.inlang/settings.json`) next to the
+ * i18next configuration so that inlang tooling (Sherlock VS Code extension,
+ * Fink editor, Paraglide compiler) operates on the EXISTING i18next JSON
+ * files. The i18next files remain the single source of truth — the scaffold
+ * is just the adapter.
+ *
+ * Behavior:
+ * - Derives `plugin.inlang.i18next.pathPattern` from the `extract.output`
+ *   template: the namespaced object form when the template contains a
+ *   `{{namespace}}` placeholder (namespaces are discovered from the files of
+ *   the primary language), the plain string form otherwise.
+ * - Never overwrites an existing `project.inlang/settings.json`.
+ * - Adds the Sherlock extension to `.vscode/extensions.json` recommendations
+ *   (creating or comment-preservingly merging the file).
+ */
+async function scaffoldInlangProject(options) {
+    const { locales, output } = options;
+    const baseLocale = options.primaryLanguage || locales[0] || 'en';
+    if (typeof output !== 'string') {
+        console.log('⚠️  Skipping inlang setup: extract.output is a function, so the file layout cannot be derived automatically. Create project.inlang/settings.json manually (see https://inlang.com/m/3i8bor92/plugin-inlang-i18next).');
+        return;
+    }
+    // Normalize Windows separators (heuristic-detected templates may be built
+    // with path.join) — settings.json patterns must be POSIX for portability.
+    // {{lng}} is a supported alias for {{language}}.
+    const template = output.replace(/\\/g, '/').replace(/\{\{lng\}\}/g, '{{language}}');
+    if (!template.endsWith('.json')) {
+        console.log('⚠️  Skipping inlang setup: the inlang i18next plugin supports JSON resource files only, but extract.output points to non-JSON files.');
+        return;
+    }
+    const settingsDir = node_path.resolve(process.cwd(), 'project.inlang');
+    const settingsPath = node_path.resolve(settingsDir, 'settings.json');
+    if (await fileExists(settingsPath)) {
+        console.log('ℹ️  project.inlang/settings.json already exists — leaving it untouched.');
+    }
+    else {
+        const pathPattern = template.includes('{{namespace}}')
+            ? await deriveNamespacedPathPattern(template, baseLocale, options.defaultNS)
+            : toInlangPattern(template);
+        const settings = {
+            $schema: 'https://inlang.com/schema/project-settings',
+            baseLocale,
+            locales,
+            modules: [INLANG_PLUGIN_MODULE],
+            'plugin.inlang.i18next': { pathPattern },
+        };
+        await promises.mkdir(settingsDir, { recursive: true });
+        await promises.writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+        console.log(`✅ inlang project created at: ${settingsPath}`);
+        console.log('   Your i18next JSON files stay the single source of truth — inlang tools read and write them directly.');
+        console.log(`   • Sherlock (VS Code): install the recommended "${SHERLOCK_EXTENSION_ID}" extension`);
+        console.log('   • Fink (web editor for translators): https://fink.inlang.com');
+        console.log('   • Paraglide (compiled i18n): npx @inlang/paraglide-js compile --project ./project.inlang');
+    }
+    await recommendSherlockExtension();
+}
+/**
+ * Converts an i18next-cli output template into an inlang `pathPattern`:
+ * `{{language}}` becomes `{locale}`, and relative paths are prefixed with
+ * `./` as required by the plugin's settings schema (which also permits
+ * `../`-relative and absolute paths, so those pass through unchanged).
+ */
+function toInlangPattern(template) {
+    const pattern = template.replace(/\{\{language\}\}/g, '{locale}');
+    if (pattern.startsWith('./') || pattern.startsWith('../') || pattern.startsWith('/')) {
+        return pattern;
+    }
+    return `./${pattern}`;
+}
+/**
+ * Builds the namespaced (object) form of `pathPattern` by discovering the
+ * project's namespaces from the existing resource files of the primary
+ * language. Falls back to the default namespace when no files exist yet
+ * (e.g. `init` ran before the first `extract`).
+ */
+async function deriveNamespacedPathPattern(template, baseLocale, defaultNS) {
+    const namespaces = await discoverNamespaces(template, baseLocale);
+    if (namespaces.length === 0) {
+        namespaces.push(typeof defaultNS === 'string' ? defaultNS : 'translation');
+    }
+    const pathPattern = {};
+    for (const ns of namespaces.sort()) {
+        pathPattern[ns] = toInlangPattern(template.replace(/\{\{namespace\}\}/g, ns));
+    }
+    return pathPattern;
+}
+/**
+ * Discovers namespace names by listing the directory entries that match the
+ * `{{namespace}}` segment of the output template, resolved for the primary
+ * language. Works for namespaces in the file name
+ * (`locales/en/{{namespace}}.json`) as well as in a directory segment
+ * (`locales/{{namespace}}/en.json`).
+ */
+async function discoverNamespaces(template, baseLocale) {
+    const resolved = template.replace(/\{\{language\}\}/g, baseLocale);
+    const segments = resolved.split('/');
+    const nsIndex = segments.findIndex(segment => segment.includes('{{namespace}}'));
+    if (nsIndex === -1)
+        return [];
+    const baseDir = node_path.resolve(process.cwd(), segments.slice(0, nsIndex).join('/'));
+    const [prefix, suffix = ''] = segments[nsIndex].split('{{namespace}}');
+    try {
+        const entries = await promises.readdir(baseDir);
+        return entries
+            .filter(entry => entry.startsWith(prefix) &&
+            entry.endsWith(suffix) &&
+            entry.length > prefix.length + suffix.length)
+            .map(entry => entry.slice(prefix.length, entry.length - suffix.length));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Adds the Sherlock VS Code extension to `.vscode/extensions.json`
+ * recommendations. Creates the file when missing; otherwise merges into the
+ * existing one while preserving comments and formatting (JSONC-aware). Bails
+ * gracefully — with a notice, never an error — when the existing file cannot
+ * be parsed.
+ */
+async function recommendSherlockExtension() {
+    const extensionsPath = node_path.resolve(process.cwd(), '.vscode', 'extensions.json');
+    let text;
+    try {
+        text = await promises.readFile(extensionsPath, 'utf-8');
+    }
+    catch {
+        // File doesn't exist yet — create it.
+    }
+    if (text === undefined || text.trim() === '') {
+        await promises.mkdir(node_path.dirname(extensionsPath), { recursive: true });
+        await promises.writeFile(extensionsPath, JSON.stringify({ recommendations: [SHERLOCK_EXTENSION_ID] }, null, 2) + '\n');
+        console.log('✅ Added the Sherlock extension to .vscode/extensions.json recommendations.');
+        return;
+    }
+    const errors = [];
+    const current = jsoncParser.parse(text, errors, { allowTrailingComma: true });
+    if (errors.length > 0 || typeof current !== 'object' || current === null || Array.isArray(current)) {
+        console.log('⚠️  Could not parse .vscode/extensions.json — please add "inlang.vs-code-extension" to its recommendations manually.');
+        return;
+    }
+    const recommendations = Array.isArray(current.recommendations) ? current.recommendations : [];
+    const alreadyRecommended = recommendations.some(entry => typeof entry === 'string' && entry.toLowerCase() === SHERLOCK_EXTENSION_ID);
+    if (alreadyRecommended)
+        return;
+    const formattingOptions = { insertSpaces: true, tabSize: 2, eol: '\n' };
+    const edits = Array.isArray(current.recommendations)
+        // Append to the existing array (preserves comments and formatting).
+        ? jsoncParser.modify(text, ['recommendations', recommendations.length], SHERLOCK_EXTENSION_ID, { isArrayInsertion: true, formattingOptions })
+        // No recommendations key yet — add one.
+        : jsoncParser.modify(text, ['recommendations'], [SHERLOCK_EXTENSION_ID], { formattingOptions });
+    await promises.writeFile(extensionsPath, jsoncParser.applyEdits(text, edits));
+    console.log('✅ Added the Sherlock extension to .vscode/extensions.json recommendations.');
+}
+async function fileExists(path) {
+    try {
+        await promises.readFile(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+exports.scaffoldInlangProject = scaffoldInlangProject;

package/dist/cjs/utils/locize-onboarding.js

@@ -0,0 +1,91 @@
+'use strict';
+
+var inquirer = require('inquirer');
+var execa = require('execa');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
+
+/** Rough 8-4-4-4-12 hex UUID shape — not strict (locize project IDs may evolve). */
+const UUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Opens the given URL in the user's default browser using the platform-native command.
+ * Returns true on success, false if there's nowhere to open one (CI, headless Linux)
+ * or if spawning the command failed.
+ */
+async function openBrowser(url, opts = {}) {
+    // Short-circuit: no point spawning a browser-opener in CI or headless Linux.
+    if (opts.ci || process.env.CI === 'true')
+        return false;
+    const isWSL = !!process.env.WSL_DISTRO_NAME;
+    if (process.platform === 'linux' && !isWSL &&
+        !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+        return false;
+    }
+    try {
+        if (process.platform === 'darwin') {
+            await execa.execa('open', [url], { stdio: 'ignore' });
+        }
+        else if (process.platform === 'win32') {
+            // `start` is a cmd.exe builtin; the empty "" is the window-title slot
+            await execa.execa('cmd', ['/c', 'start', '""', url], { stdio: 'ignore' });
+        }
+        else if (isWSL) {
+            // WSL: try the wslu / wsl-open shims that bridge to the Windows side
+            // before falling back to xdg-open (which usually isn't installed there).
+            try {
+                await execa.execa('wslview', [url], { stdio: 'ignore' });
+            }
+            catch {
+                try {
+                    await execa.execa('wsl-open', [url], { stdio: 'ignore' });
+                }
+                catch {
+                    await execa.execa('xdg-open', [url], { stdio: 'ignore' });
+                }
+            }
+        }
+        else {
+            await execa.execa('xdg-open', [url], { stdio: 'ignore' });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Prompts for Locize credentials (Project ID + optional API key) and returns them.
+ * Warns (but does not block) when the Project ID does not look like a UUID.
+ */
+async function promptLocizeCredentials() {
+    const credentials = await inquirer__default.default.prompt([
+        {
+            type: 'input',
+            name: 'projectId',
+            message: 'Locize Project ID (e.g. 4eeb5ce0-a7a7-453f-8eb3-078f6eeb56fe):',
+            validate: (input) => input.trim().length > 0 || 'Project ID cannot be empty.',
+            filter: (input) => input.trim(),
+        },
+        {
+            type: 'password',
+            name: 'apiKey',
+            message: 'Locize API key (needed for saveMissing / auto-publish / sync during development; leave empty to skip and add later via env var):',
+            filter: (input) => input.trim(),
+        },
+    ]);
+    if (!UUID_SHAPE.test(credentials.projectId)) {
+        console.log("⚠️  The Project ID doesn't look like a UUID (8-4-4-4-12 hex). It will still be written — double-check it in your Locize project settings.");
+    }
+    // API keys come in multiple shapes (UUID, `lz_pat_…`, `lz_api_…`, etc.) —
+    // treat them as opaque; no client-side format check.
+    const result = { projectId: credentials.projectId };
+    if (credentials.apiKey)
+        result.apiKey = credentials.apiKey;
+    return result;
+}
+
+exports.UUID_SHAPE = UUID_SHAPE;
+exports.openBrowser = openBrowser;
+exports.promptLocizeCredentials = promptLocizeCredentials;

package/dist/cjs/utils/wrap-ora.js

@@ -2,6 +2,10 @@
 
 var ora = require('ora');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+
 /**
  * Creates a spinner-like object that either:
  * - is fully silent (quiet mode),
@@ -16,7 +20,7 @@ function createSpinnerLike(initialText, options = {}) {
     // If interactive (no logger and not quiet), create a single real ora spinner
     let realSpinner = null;
     if (!quiet && !logger) {
-        realSpinner = ora({ text }).start();
+        realSpinner = ora__default.default({ text }).start();
     }
     const self = {
         get text() { return text; },
@@ -40,7 +44,7 @@ function createSpinnerLike(initialText, options = {}) {
             }
             else {
                 if (!realSpinner)
-                    realSpinner = ora({ text }).start();
+                    realSpinner = ora__default.default({ text }).start();
                 realSpinner.succeed(message);
             }
         },
@@ -58,7 +62,7 @@ function createSpinnerLike(initialText, options = {}) {
             }
             else {
                 if (!realSpinner)
-                    realSpinner = ora({ text }).start();
+                    realSpinner = ora__default.default({ text }).start();
                 realSpinner.fail(message);
             }
         },
@@ -76,7 +80,7 @@ function createSpinnerLike(initialText, options = {}) {
             }
             else {
                 if (!realSpinner)
-                    realSpinner = ora({ text }).start();
+                    realSpinner = ora__default.default({ text }).start();
                 try {
                     realSpinner.warn?.(message);
                 }
@@ -101,7 +105,7 @@ function createSpinnerLike(initialText, options = {}) {
             }
             else {
                 if (!realSpinner)
-                    realSpinner = ora({ text }).start();
+                    realSpinner = ora__default.default({ text }).start();
                 realSpinner.text = String(msg);
             }
         }

package/dist/esm/cli.js

@@ -25,12 +25,13 @@ import { runRenameKey } from './rename-key.js';
 import { runInstrumenter } from './instrumenter/core/instrumenter.js';
 import './utils/jsx-attributes.js';
 import 'magic-string';
+import { runLocalize } from './localize/localize.js';
 
 const program = new Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.61.1'); // This string is replaced with the actual version at build time by rollup
+    .version('1.63.0'); // This string is replaced with the actual version at build time by rollup
 // new: global config override option
 program.option('-c, --config <path>', 'Path to i18next-cli config file (overrides detection)');
 program
@@ -190,7 +191,8 @@ program
     .command('init')
     .description('Create a new i18next.config.ts/js file with an interactive setup wizard.')
     .option('--ci', 'Skip the browser launch when a backend (e.g. Locize) is selected. The signup URL is printed instead.')
-    .action((options) => runInit({ ci: !!options.ci }));
+    .option('--inlang', 'Also scaffold an inlang project (project.inlang/settings.json) so inlang tooling (Sherlock, Fink, Paraglide) works on the translation files. Skips the corresponding wizard question.')
+    .action((options) => runInit({ ci: !!options.ci, inlang: !!options.inlang }));
 program
     .command('lint')
     .description('Find potential issues like hardcoded strings in your codebase.')
@@ -284,6 +286,29 @@ program
         process.exit(1);
     }
 });
+program
+    .command('localize')
+    .description('One command from hardcoded strings to a fully localized app: detect, instrument, extract, connect to Locize, auto-translate, deliver.')
+    .option('--dry-run', 'Preview every step; nothing is written or pushed.')
+    .option('-y, --yes', 'Accept defaults; auto-approve instrumentation candidates (no per-string prompts).')
+    .option('--ci', 'Non-interactive: never open a browser or prompt; instrument is skipped (combine with --yes to force non-interactive instrumentation).')
+    .option('--skip-instrument', 'Skip the code-instrumentation step (use when your code already calls t()).')
+    .option('--skip-translate', 'Sync to Locize but do not request AI auto-translation.')
+    .option('--skip-locize', 'Stop after extraction (local files only; steps 5-6 skipped).')
+    .option('--namespace <ns>', 'Target namespace for instrumented keys (forwarded to instrument).')
+    .option('--update-values', 'Also update existing translation values on Locize (forwarded to sync).')
+    .option('--cdn-type <standard|pro>', 'Specify the cdn endpoint that should be used (depends on which cdn type you\'ve in your Locize project)')
+    .option('--print-agent-prompt', 'Print a copy-paste prompt for AI coding agents (Claude Code, Cursor) that performs the same steps, then exit.')
+    .action(async (options) => {
+    try {
+        const cfgPath = program.opts().config;
+        await runLocalize(options, cfgPath);
+    }
+    catch (error) {
+        console.error(styleText('red', 'Error running localize command:'), error);
+        process.exit(1);
+    }
+});
 program
     .command('locize-sync')
     .description('Synchronize local translations with your Locize project.')
@@ -292,6 +317,9 @@ program
     .option('--compare-mtime', 'Compare modification times when syncing.')
     .option('--dry-run', 'Run the command without making any changes.')
     .option('--cdn-type <standard|pro>', 'Specify the cdn endpoint that should be used (depends on which cdn type you\'ve in your locize project)')
+    .option('--auto-translate <true|false>', 'Trigger AI/MT auto-translation of newly synced keys (requires auto-translation enabled in your Locize project; on by default for new projects).')
+    .option('--auto-translate-review <true|false>', 'Route auto-translated segments through the review workflow for languages that have review enabled.')
+    .option('--auto-translate-languages <lng1,lng2>', 'Restrict auto-translation to these target languages (comma separated; defaults to all languages).')
     .action(async (options) => {
     const cfgPath = program.opts().config;
     const config = await ensureConfig(cfgPath);