@chesterbrains/translify-cli 0.6.0 → 0.7.0

package/README.md

@@ -47,7 +47,7 @@ In Translify, open your project's API keys, create a **secret key** (it starts w
 Give the key to the CLI in one of two ways:
 
 - set `TRANSLIFY_SECRET_KEY` (always wins; use this in CI), or
-- run `translify login` and paste it. It is stored in `~/.config/translify/credentials` (or under `$XDG_CONFIG_HOME`).
+- run `translify login` (or let `translify init` ask for it) and paste it. It is stored in `~/.config/translify/credentials` (or under `$XDG_CONFIG_HOME`).
 
 Never commit a key. Delivery keys (public keys used by apps to download published translations) do not work here.
 
@@ -61,7 +61,7 @@ locales/
 
 ```bash
 export TRANSLIFY_SECRET_KEY=sk_...
-npx translify init            # detects your layout, writes translify.json
+npx translify init            # detects your layout, asks for your key, writes translify.json
 npx translify push --dry-run  # show what would change, write nothing
 npx translify push
 npx translify pull
@@ -128,7 +128,11 @@ server converts both ways:
 { "files": [{ "pattern": "src/locale/messages.{locale}.xlf", "format": "xliff", "namespace": "web", "xliffDialect": "angular" }] }
 ```
 
-Give every template string `i18n="@@<key>"` so the unit ids are your keys. What `pull` writes:
+`translify init` reads `angular.json` and writes this rule for you (one per distinct translation path, namespace = project name); `ng extract-i18n` must be run with `--format=xlf2 --out-file messages.<sourceLocale>.xlf` so the source file matches it.
+
+Give every template string `i18n="@@<key>"` so the unit ids are your keys. A translation file's `trgLang` must be the
+Translify locale code: with `"locales": { "it": "it-IT" }` the file is still `messages.it.xlf`, but it declares
+`trgLang="it-IT"`, or `push` is refused with `File targets it but it-IT was requested`. What `pull` writes:
 
 | Translify value | Angular unit |
 |---|---|
@@ -169,6 +173,8 @@ iOS translations get placeholder validation (Xcode's own import accepts a target
               "xliffDialect": "xcode", "xliffOriginal": "Sources/App/Localizable.xcstrings" }] }
 ```
 
+`translify init` finds every `.xcstrings` and writes this rule for you (namespace = catalog name, `xliffOriginal` = its path; `Localization/{locale}.xliff` unless locale-named `.xliff` files already sit in one folder).
+
 Workflow:
 
 1. Seed once: `xcodebuild -exportLocalizations -localizationPath out -exportLanguage en`, copy
@@ -217,7 +223,7 @@ fields are refused, and so is any field whose name contains `key`, `secret` or `
 | `files[].jsonStyle` | `nested` \| `flat` | no | Only for `json`. `nested` (the default) writes `{ "a": { "b": "…" } }`, `flat` writes `{ "a.b": "…" }`. |
 | `files[].xliffDialect` | `angular` \| `xcode` | no | Only for `xliff`. `angular` writes `@angular/localize` placeholders on pull and reads `ng extract-i18n` output on push ([Angular (XLIFF)](#angular-xliff)); `xcode` writes XLIFF 1.2 for String Catalogs and reads `xcodebuild -exportLocalizations` output ([Xcode (XLIFF)](#xcode-xliff)). |
 | `files[].xliffOriginal` | string | with `xliffDialect: "xcode"` | The String Catalog path Xcode knows, e.g. `Sources/App/Localizable.xcstrings`; written to `<file original>`. Xcode imports nothing when it does not match the project. Only with `xcode`. |
-| `locales` | object | no | Maps a locale name on disk to a Translify locale code, e.g. `{ "en_US": "en-US" }`. Unmapped names pass through unchanged. Two names may not map to the same code, and a target may not itself be a mapped name. |
+| `locales` | object | no | Maps a locale name on disk to a Translify locale code, e.g. `{ "en_US": "en-US" }`. Unmapped names pass through unchanged. Two names may not map to the same code, and a target may not itself be a mapped name. The map renames files only: an XLIFF's `trgLang` (2.0) or `target-language` (1.2), when present, must be the Translify code itself, or `push` is refused with `File targets it but it-IT was requested`. |
 
 Each file must be matched by one rule only, and each (locale, namespace) pair must come from one file only;
 otherwise the CLI stops before sending anything and names the files involved.
@@ -226,7 +232,7 @@ otherwise the CLI stops before sending anything and names the files involved.
 
 | Command | What it does |
 |---|---|
-| `translify init` | Create `translify.json` (interactive) |
+| `translify init` | Create `translify.json`: detects i18next, Flutter, Angular and Xcode layouts, asks for your key (interactive, or `--yes`) |
 | `translify login` | Store a secret key on this machine (interactive) |
 | `translify push` | Upload source and target files |
 | `translify pull` | Download translation files |
@@ -236,6 +242,7 @@ otherwise the CLI stops before sending anything and names the files involved.
 
 Options:
 
+- `init`: `-y/--yes` (no prompts: every detected rule, the suggested locale map, the key from `TRANSLIFY_SECRET_KEY` or a previous login; fails instead of overwriting), `--api-url <url>`
 - `push`: `--dry-run`, `--overwrite-targets`, `--prune`, `-y/--yes`, `--namespace <ns>`, `--status <draft|needs-review|approved>`
 - `pull` and `status`: `--from <working|env:slug>`, `--locale <locale>` (as named on disk), `--namespace <ns>`, `--only-approved`
 - `publish`: `--fail-on-withheld`, `--allow-errors`
@@ -300,48 +307,34 @@ When the project has **Require review** turned on in Translify:
 
 ## CI (GitHub Actions)
 
-Store the key in the repository secrets as `TRANSLIFY_SECRET_KEY`.
+Store the key in the repository secrets as `TRANSLIFY_SECRET_KEY`. Two ready-made workflows live in
+[`recipes/github-actions/`](https://github.com/chesterbrains/translify-cli/tree/main/recipes/github-actions); copy the
+one you need to `.github/workflows/` as it is.
 
-Push on main:
+- [`translify-push.yml`](https://github.com/chesterbrains/translify-cli/blob/main/recipes/github-actions/translify-push.yml)
+  runs `push --dry-run` on every pull request and keeps its output in one comment on the PR, updated on each push to the
+  branch (a refused push lands there too and fails the job); on `main` it pushes for real, with an optional `publish`
+  step. Key scope: `PUSH` (and `PUBLISH` for the optional step). Pull requests from forks are skipped: they have no
+  access to secrets.
+- [`translify-release.yml`](https://github.com/chesterbrains/translify-cli/blob/main/recipes/github-actions/translify-release.yml)
+  is for apps that bundle translations at build time: `lint`, then `pull`, your build, then `publish` to the environment
+  chosen in the Actions tab (or on a tag). Key scopes: `PULL` and `PUBLISH`.
 
-```yaml
-name: Translify push
-on:
-  push:
-    branches: [main]
-jobs:
-  push:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with: { node-version: 22 }
-      - run: npx translify push
-        env:
-          TRANSLIFY_SECRET_KEY: ${{ secrets.TRANSLIFY_SECRET_KEY }}
-```
+Both use `npx -y translify`, so they follow every 0.x release; pin a version (`npx -y @chesterbrains/translify-cli@0.6`) if a breaking
+release must not turn the workflow red on its own.
 
 Fail a pull request when local files drift from Translify:
 
 ```yaml
-name: Translify status
-on: pull_request
-jobs:
-  status:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with: { node-version: 22 }
-      - run: npx translify status
-        env:
-          TRANSLIFY_SECRET_KEY: ${{ secrets.TRANSLIFY_SECRET_KEY }}
+- run: npx -y translify status
+  env:
+    TRANSLIFY_SECRET_KEY: ${{ secrets.TRANSLIFY_SECRET_KEY }}
 ```
 
 Fail CI when translations in Translify have placeholder errors:
 
 ```yaml
-- run: npx translify lint --max-warnings 0
+- run: npx -y translify lint --max-warnings 0
   env:
     TRANSLIFY_SECRET_KEY: ${{ secrets.TRANSLIFY_SECRET_KEY }}
 ```
@@ -350,20 +343,6 @@ Fail CI when translations in Translify have placeholder errors:
 It covers what this repository pulls: only the namespaces of fixed-`namespace` rules, or the whole
 project when a rule uses `{namespace}`. It needs a key with the `pull` scope.
 
-Pull and publish on deploy:
-
-```yaml
-- run: npx translify lint
-  env:
-    TRANSLIFY_SECRET_KEY: ${{ secrets.TRANSLIFY_SECRET_KEY }}
-- run: npx translify pull
-  env:
-    TRANSLIFY_SECRET_KEY: ${{ secrets.TRANSLIFY_SECRET_KEY }}
-- run: npx translify publish production
-  env:
-    TRANSLIFY_SECRET_KEY: ${{ secrets.TRANSLIFY_SECRET_KEY }}
-```
-
 ## Exit codes
 
 | Code | Meaning |

package/dist/commands/init.js

@@ -1,58 +1,13 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import fg from 'fast-glob';
+import { assertSecret } from '../credentials.js';
+import { detectLayout } from '../detect/index.js';
+import { suggestLocaleMap } from '../detect/locales.js';
 import { CliError, EXIT } from '../errors.js';
 import { findFiles } from '../patterns.js';
 const SCHEMA_URL = 'https://unpkg.com/@chesterbrains/translify-cli/schema/translify.schema.json';
-const I18NEXT_ROOTS = ['locales', 'public/locales', 'src/locales', 'src/i18n'];
 const EXAMPLE_RULE = { pattern: 'locales/{locale}/{namespace}.json', format: 'json', jsonStyle: 'nested' };
-const unquote = (value) => value.replace(/^["']|["']$/g, '').replace(/^(\.\/)+/, '').replace(/\/+$/, '');
-async function detectFlutter(cwd) {
-    let yaml;
-    try {
-        yaml = await readFile(join(cwd, 'l10n.yaml'), 'utf8');
-    }
-    catch {
-        yaml = undefined;
-    }
-    if (yaml === undefined) {
-        const arbs = await fg('lib/l10n/*.arb', { cwd, onlyFiles: true });
-        return arbs.length > 0 ? [{ pattern: 'lib/l10n/app_{locale}.arb', format: 'arb', namespace: 'app' }] : [];
-    }
-    const dir = unquote(/^arb-dir:\s*(\S+)/m.exec(yaml)?.[1] ?? 'lib/l10n');
-    const template = unquote(/^template-arb-file:\s*(\S+)/m.exec(yaml)?.[1] ?? 'app_en.arb');
-    const prefix = /^(.*?)_[a-z]{2,3}(?:[_-](?:[A-Z]{2}|[0-9]{3}|[A-Z][a-z]{3}))*\.arb$/.exec(template)?.[1] ?? 'app';
-    return [{ pattern: `${dir}/${prefix}_{locale}.arb`, format: 'arb', namespace: 'app' }];
-}
-/** Recognises i18next and Flutter layouts; an empty list means "unknown, write an example". */
-export async function detectLayout(cwd) {
-    const rules = [];
-    for (const root of I18NEXT_ROOTS) {
-        const found = await fg(`${root}/*/*.json`, { cwd, onlyFiles: true });
-        if (found.length > 0)
-            rules.push({ pattern: `${root}/{locale}/{namespace}.json`, format: 'json', jsonStyle: 'nested' });
-    }
-    return [...rules, ...(await detectFlutter(cwd))];
-}
-const normalize = (locale) => locale.toLowerCase().replaceAll('_', '-');
-/** Disk locales that differ from a Translify locale only by case or separator (`en_US` → `en-US`). */
-export function suggestLocaleMap(diskLocales, translifyLocales) {
-    const known = new Set(translifyLocales);
-    const disk = new Set(diskLocales);
-    const map = {};
-    const targets = new Set();
-    for (const locale of diskLocales) {
-        if (known.has(locale))
-            continue;
-        const target = translifyLocales.find((code) => normalize(code) === normalize(locale));
-        // A bijection that cannot chain: loadConfig rejects anything else.
-        if (target === undefined || targets.has(target) || disk.has(target))
-            continue;
-        map[locale] = target;
-        targets.add(target);
-    }
-    return map;
-}
+const NO_KEY_LINE = 'Wrote translify.json. The key is not stored there: run `translify login` or set TRANSLIFY_SECRET_KEY.';
 const isHttpUrl = (value) => {
     try {
         return ['http:', 'https:'].includes(new URL(value).protocol);
@@ -70,35 +25,54 @@ async function exists(path) {
         return false;
     }
 }
+const label = (rule) => (rule.xliffDialect === undefined ? rule.pattern : `${rule.pattern} (${rule.xliffDialect})`);
 export async function runInit(deps) {
-    if (!deps.isTty) {
-        deps.out('`translify init` needs an interactive terminal. Write translify.json by hand in CI.');
+    if (!deps.isTty && !deps.yes) {
+        deps.out('`translify init` needs an interactive terminal. Pass `--yes` to take the detected defaults, or write translify.json by hand.');
         return EXIT.failed;
     }
     const target = join(deps.cwd, 'translify.json');
-    if ((await exists(target)) && !(await deps.prompt.confirm('translify.json already exists. Overwrite it?', false))) {
-        deps.out('Left translify.json unchanged.');
+    if (await exists(target)) {
+        if (deps.yes) {
+            deps.out('translify.json already exists. Delete it first.');
+            return EXIT.failed;
+        }
+        if (!(await deps.prompt.confirm('translify.json already exists. Overwrite it?', false))) {
+            deps.out('Left translify.json unchanged.');
+            return EXIT.failed;
+        }
+    }
+    const apiUrl = (deps.apiUrl ?? (deps.yes ? deps.apiUrlDefault : await deps.prompt.input('Translify API URL', deps.apiUrlDefault))).trim();
+    if (!isHttpUrl(apiUrl)) {
+        deps.out('The API URL must start with http:// or https://. Nothing was written.');
         return EXIT.failed;
     }
-    const detected = await detectLayout(deps.cwd);
+    // A typed key that is rejected throws here (exit 2): nothing is written and nothing is saved.
+    const me = await identify(deps, apiUrl);
+    if (me !== undefined) {
+        deps.out(`Project: ${me.project.name}, default locale ${me.project.defaultLocale ?? 'none'}; locales: ${me.locales.join(', ')}`);
+    }
+    const detection = await detectLayout(deps.cwd);
+    const detected = detection.rules;
     if (detected.length === 0) {
-        deps.out(`No i18next or Flutter layout found in ${deps.cwd} (detection looks only in the current directory). Wrote an example rule (${EXAMPLE_RULE.pattern}): edit files[] to match your project.`);
+        deps.out(`No i18next, Flutter, Angular or Xcode layout found in ${deps.cwd} (detection looks only in the current directory). Wrote an example rule (${EXAMPLE_RULE.pattern}): edit files[] to match your project.`);
     }
     else {
         deps.out(`Found: ${detected.map((rule) => `${rule.pattern} (${rule.format})`).join(', ')}`);
     }
+    for (const note of detection.notes)
+        deps.out(note);
     let files = detected.length > 0 ? detected : [EXAMPLE_RULE];
-    if (detected.length > 1) {
-        const chosen = await deps.prompt.choose('Several layouts found. Which one holds your translations?', detected.map((rule) => rule.pattern));
-        files = detected.filter((rule) => rule.pattern === chosen);
-        if (files.length === 0)
-            files = [detected[0]];
-        deps.out(`Dropped: ${detected.filter((rule) => !files.includes(rule)).map((rule) => rule.pattern).join(', ')}`);
-    }
-    const apiUrl = (await deps.prompt.input('Translify API URL', deps.apiUrlDefault)).trim();
-    if (!isHttpUrl(apiUrl)) {
-        deps.out('The API URL must start with http:// or https://. Nothing was written.');
-        return EXIT.failed;
+    if (detected.length > 1 && !deps.yes) {
+        const chosen = new Set(await deps.prompt.checkbox('Which layouts hold your translations?', detected.map(label)));
+        files = detected.filter((rule) => chosen.has(label(rule)));
+        if (files.length === 0) {
+            deps.out('Nothing selected. Nothing was written.');
+            return EXIT.failed;
+        }
+        const dropped = detected.filter((rule) => !files.includes(rule));
+        if (dropped.length > 0)
+            deps.out(`Dropped: ${dropped.map((rule) => rule.pattern).join(', ')}`);
     }
     // A config that cannot resolve its own files would fail on the first push or pull: refuse to write it.
     let matches;
@@ -111,21 +85,53 @@ export async function runInit(deps) {
         deps.out(`${error.message} Nothing was written.`);
         return EXIT.failed;
     }
-    let locales = {};
-    const me = await deps.fetchWhoami(apiUrl);
-    if (me !== undefined) {
-        deps.out(`Project: ${me.project.name}, default locale ${me.project.defaultLocale ?? 'none'}; locales: ${me.locales.join(', ')}`);
-        locales = await suggestMap(deps, matches, me.locales);
-    }
+    const locales = me === undefined ? {} : await suggestMap(deps, matches, me.locales);
     const config = { $schema: SCHEMA_URL, apiUrl, files, locales };
     // `locales` is omitted when empty; the schema defaults it.
     const body = { ...config };
     if (Object.keys(locales).length === 0)
         delete body.locales;
-    await writeFile(target, `${JSON.stringify(body, null, 2)}\n`);
-    deps.out('Wrote translify.json. The key is not stored there: run `translify login` or set TRANSLIFY_SECRET_KEY.');
+    const text = `${JSON.stringify(body, null, 2)}\n`;
+    deps.out(text.trimEnd());
+    if (!deps.yes && !(await deps.prompt.confirm('Write translify.json?', true))) {
+        deps.out('Nothing was written.');
+        return EXIT.failed;
+    }
+    await writeFile(target, text);
+    deps.out(me === undefined ? NO_KEY_LINE : 'Wrote translify.json.');
     return EXIT.ok;
 }
+/**
+ * The project this machine's key belongs to. A stored key that fails only costs the locale hints;
+ * a typed key that fails stops init (the error propagates), so a wrong key is never saved.
+ */
+async function identify(deps, apiUrl) {
+    const stored = await deps.findKey();
+    if (stored !== undefined) {
+        try {
+            return await deps.fetchWhoami(apiUrl, stored);
+        }
+        catch (error) {
+            if (!(error instanceof CliError))
+                throw error;
+            deps.out(error.exitCode === EXIT.auth
+                ? 'Stored key was rejected; run `translify login`. Continuing without project info.'
+                : `Could not reach Translify (${error.message}). Continuing without project info.`);
+            return undefined;
+        }
+    }
+    if (deps.yes)
+        return undefined;
+    const typed = (await deps.prompt.secret('Secret key (sk_…), Enter to skip')).trim();
+    if (typed === '')
+        return undefined;
+    // Before any network call, and the error never echoes the value.
+    assertSecret(typed);
+    const me = await deps.fetchWhoami(apiUrl, typed);
+    const path = await deps.saveKey(typed);
+    deps.out(`Logged in to ${me.project.name} (${me.project.slug}) with scopes ${me.key.scopes.join(', ')}. Saved to ${path}.`);
+    return me;
+}
 async function suggestMap(deps, matches, translifyLocales) {
     const diskLocales = [...new Set(matches.map((match) => match.locale))];
     const missing = diskLocales.filter((locale) => !translifyLocales.includes(locale));
@@ -135,6 +141,8 @@ async function suggestMap(deps, matches, translifyLocales) {
     }
     if (Object.keys(map).length === 0)
         return {};
+    if (deps.yes)
+        return map;
     const text = Object.entries(map).map(([from, to]) => `${from} → ${to}`).join(', ');
     return (await deps.prompt.confirm(`Map disk locales to Translify codes (${text})?`, true)) ? map : {};
 }

package/dist/credentials.js

@@ -10,6 +10,7 @@ export function credentialsPath(env = process.env) {
         return join(appData, 'translify', 'credentials');
     return join(absolute(env.XDG_CONFIG_HOME) ?? join(homedir(), '.config'), 'translify', 'credentials');
 }
+const SECRET_KEY_SHAPE = /^sk_[A-Za-z0-9_-]+$/;
 // Messages never echo the value: a mistyped key is still a secret.
 export const assertSecret = (key) => {
     if (key.startsWith('pk_')) {
@@ -17,9 +18,15 @@ export const assertSecret = (key) => {
     }
     if (!key.startsWith('sk_'))
         throw new CliError(EXIT.auth, 'Not a Translify secret key (expected sk_...).');
+    // A key is `sk_` plus base64url. Anything else (a pasted `…`, a space, a `/`) is caught here: fetch
+    // would refuse it as a header value, which reads as a connection error (TRLIFY-128).
+    if (!SECRET_KEY_SHAPE.test(key)) {
+        throw new CliError(EXIT.auth, 'The key has characters a secret key never has (only letters, digits, - and _ after sk_). Check TRANSLIFY_SECRET_KEY.');
+    }
     return key;
 };
-export async function resolveKey(env = process.env) {
+/** The key this machine has (env var first, then the credentials file), or undefined. Malformed values throw. */
+export async function findKey(env = process.env) {
     const fromEnv = env.TRANSLIFY_SECRET_KEY?.trim();
     if (fromEnv)
         return assertSecret(fromEnv);
@@ -28,11 +35,15 @@ export async function resolveKey(env = process.env) {
         stored = (await readFile(credentialsPath(env), 'utf8')).trim();
     }
     catch {
-        throw new CliError(EXIT.auth, 'No key. Set TRANSLIFY_SECRET_KEY or run `translify login`.');
+        return undefined;
     }
-    if (stored === '')
+    return stored === '' ? undefined : assertSecret(stored);
+}
+export async function resolveKey(env = process.env) {
+    const key = await findKey(env);
+    if (key === undefined)
         throw new CliError(EXIT.auth, 'No key. Set TRANSLIFY_SECRET_KEY or run `translify login`.');
-    return assertSecret(stored);
+    return key;
 }
 export async function saveKey(key, env = process.env) {
     const path = credentialsPath(env);

package/dist/detect/angular.js

@@ -0,0 +1,80 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { kebab, NONE, posixPath } from './shared.js';
+const DEFAULT_PATTERN = 'src/locale/messages.{locale}.xlf';
+const firstPath = (value) => {
+    const raw = typeof value === 'string' || Array.isArray(value) ? value : value.translation;
+    const first = Array.isArray(raw) ? raw[0] : raw;
+    return typeof first === 'string' ? first : undefined;
+};
+const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * The last occurrence of `code` bounded by non-alphanumerics, so `es` in `resources/` is not it, and
+ * not the language part of a regional name (`pt` in `messages.pt-BR.xlf`), which would split the file.
+ */
+const toPattern = (path, code) => {
+    const bounded = new RegExp(`(?<![A-Za-z0-9])${escape(code)}(?![A-Za-z0-9]|[-_][A-Za-z0-9])`, 'g');
+    const matches = [...path.matchAll(bounded)];
+    const last = matches.at(-1);
+    if (last === undefined)
+        return undefined;
+    return `${path.slice(0, last.index)}{locale}${path.slice(last.index + code.length)}`;
+};
+const rule = (pattern, namespace) => ({ pattern, format: 'xliff', namespace, xliffDialect: 'angular' });
+/** `angular.json` with an `i18n` block per project; the translation paths give the pattern. */
+export async function detectAngular(cwd) {
+    let raw;
+    try {
+        raw = await readFile(join(cwd, 'angular.json'), 'utf8');
+    }
+    catch {
+        return NONE;
+    }
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        return { rules: [], notes: ['angular.json is not valid JSON, skipped.'] };
+    }
+    const projects = Object.entries(json.projects ?? {});
+    const first = projects[0];
+    if (first === undefined)
+        return NONE;
+    const rules = [];
+    const notes = [];
+    const seen = new Set();
+    let sourceLocale;
+    for (const [name, project] of projects) {
+        const i18n = project.i18n;
+        if (i18n === undefined)
+            continue;
+        const namespace = kebab(name) || 'app';
+        const source = typeof i18n.sourceLocale === 'string' ? i18n.sourceLocale : i18n.sourceLocale?.code;
+        if (source !== undefined) {
+            sourceLocale ??= source;
+            notes.push(`Angular source locale for ${name}: ${source}.`);
+        }
+        for (const [code, value] of Object.entries(i18n.locales ?? {})) {
+            const path = firstPath(value);
+            if (path === undefined)
+                continue;
+            const clean = posixPath(path);
+            const pattern = toPattern(clean, code);
+            if (pattern === undefined) {
+                notes.push(`${clean} does not contain its locale code ${code}; add that rule by hand.`);
+                continue;
+            }
+            if (seen.has(pattern))
+                continue;
+            seen.add(pattern);
+            rules.push(rule(pattern, namespace));
+        }
+    }
+    if (rules.length === 0) {
+        rules.push(rule(DEFAULT_PATTERN, kebab(first[0]) || 'app'));
+        notes.push('angular.json has no usable i18n locales: the rule assumes the default src/locale/messages.<locale>.xlf layout.');
+    }
+    notes.push(`\`ng extract-i18n\` writes messages.xlf with no locale in its name; run it with --format=xlf2 --out-file messages.${sourceLocale ?? '<sourceLocale>'}.xlf so the source file matches the rule.`);
+    return { rules, notes };
+}

package/dist/detect/flutter.js

@@ -0,0 +1,22 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import fg from 'fast-glob';
+const unquote = (value) => value.replace(/^["']|["']$/g, '').replace(/^(\.\/)+/, '').replace(/\/+$/, '');
+export async function detectFlutter(cwd) {
+    let yaml;
+    try {
+        yaml = await readFile(join(cwd, 'l10n.yaml'), 'utf8');
+    }
+    catch {
+        yaml = undefined;
+    }
+    if (yaml === undefined) {
+        const arbs = await fg('lib/l10n/*.arb', { cwd, onlyFiles: true });
+        const rules = arbs.length > 0 ? [{ pattern: 'lib/l10n/app_{locale}.arb', format: 'arb', namespace: 'app' }] : [];
+        return { rules, notes: [] };
+    }
+    const dir = unquote(/^arb-dir:\s*(\S+)/m.exec(yaml)?.[1] ?? 'lib/l10n');
+    const template = unquote(/^template-arb-file:\s*(\S+)/m.exec(yaml)?.[1] ?? 'app_en.arb');
+    const prefix = /^(.*?)_[a-z]{2,3}(?:[_-](?:[A-Z]{2}|[0-9]{3}|[A-Z][a-z]{3}))*\.arb$/.exec(template)?.[1] ?? 'app';
+    return { rules: [{ pattern: `${dir}/${prefix}_{locale}.arb`, format: 'arb', namespace: 'app' }], notes: [] };
+}

package/dist/detect/i18next.js

@@ -0,0 +1,11 @@
+import fg from 'fast-glob';
+const I18NEXT_ROOTS = ['locales', 'public/locales', 'src/locales', 'src/i18n'];
+export async function detectI18next(cwd) {
+    const rules = [];
+    for (const root of I18NEXT_ROOTS) {
+        const found = await fg(`${root}/*/*.json`, { cwd, onlyFiles: true });
+        if (found.length > 0)
+            rules.push({ pattern: `${root}/{locale}/{namespace}.json`, format: 'json', jsonStyle: 'nested' });
+    }
+    return { rules, notes: [] };
+}

package/dist/detect/index.js

@@ -0,0 +1,16 @@
+import { detectAngular } from './angular.js';
+import { detectFlutter } from './flutter.js';
+import { detectI18next } from './i18next.js';
+import { detectXcode } from './xcode.js';
+const DETECTORS = [detectI18next, detectFlutter, detectAngular, detectXcode];
+/** Looks only in `cwd`. An empty `rules` list means "unknown, write an example". */
+export async function detectLayout(cwd) {
+    const rules = [];
+    const notes = [];
+    for (const detect of DETECTORS) {
+        const found = await detect(cwd);
+        rules.push(...found.rules);
+        notes.push(...found.notes);
+    }
+    return { rules, notes };
+}

package/dist/detect/locales.js

@@ -0,0 +1,33 @@
+const normalize = (locale) => locale.toLowerCase().replaceAll('_', '-');
+const LANGUAGE = /^[a-z]{2,3}$/i;
+const language = (code) => normalize(code).split('-')[0] ?? '';
+/**
+ * Disk locales that differ from a Translify locale only by case or separator (`en_US` → `en-US`),
+ * then bare languages with exactly one regional match (`en` → `en-US`, but not with `en-GB` too).
+ */
+export function suggestLocaleMap(diskLocales, translifyLocales) {
+    const known = new Set(translifyLocales);
+    const disk = new Set(diskLocales);
+    const map = {};
+    const targets = new Set();
+    // A bijection that cannot chain: loadConfig rejects anything else.
+    const take = (locale, target) => {
+        if (target === undefined || targets.has(target) || disk.has(target))
+            return;
+        map[locale] = target;
+        targets.add(target);
+    };
+    for (const locale of diskLocales) {
+        if (known.has(locale))
+            continue;
+        take(locale, translifyLocales.find((code) => normalize(code) === normalize(locale)));
+    }
+    for (const locale of diskLocales) {
+        if (known.has(locale) || map[locale] !== undefined || !LANGUAGE.test(locale))
+            continue;
+        const regional = translifyLocales.filter((code) => code.includes('-') && language(code) === locale.toLowerCase());
+        if (regional.length === 1)
+            take(locale, regional[0]);
+    }
+    return map;
+}

package/dist/detect/shared.js

@@ -0,0 +1,8 @@
+export const NONE = { rules: [], notes: [] };
+/** `MyApp_Web` → `myapp-web`; an empty result is the caller's problem (it picks a fallback). */
+export const kebab = (name) => name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+/** Patterns are written with `/`; a Windows-edited path still becomes one. */
+export const posixPath = (value) => value.replaceAll('\\', '/').replace(/^(\.\/)+/, '');

package/dist/detect/xcode.js

@@ -0,0 +1,93 @@
+import { readdir } from 'node:fs/promises';
+import { join, posix } from 'node:path';
+import fg from 'fast-glob';
+import { kebab, NONE } from './shared.js';
+const IGNORE = ['**/.build/**', '**/Pods/**', '**/node_modules/**', '**/DerivedData/**', '**/.git/**', '**/*.xcloc/**'];
+/** `LOCALE` from config.ts, with `_` allowed: that is how the locales map is used. */
+const LOCALE_FILE = /^[A-Za-z]{2,3}([_-][A-Za-z0-9]{2,8})*$/;
+const glob = async (cwd, pattern) => (await fg(pattern, { cwd, onlyFiles: true, dot: false, ignore: IGNORE })).sort();
+/** The one directory holding every `.xliff`, when each is named after a locale; else undefined. */
+const existingDir = async (cwd) => {
+    const xliffs = await glob(cwd, '**/*.xliff');
+    if (xliffs.length === 0)
+        return undefined;
+    const dirs = new Set(xliffs.map((path) => posix.dirname(path)));
+    if (dirs.size !== 1 || !xliffs.every((path) => LOCALE_FILE.test(posix.basename(path, '.xliff'))))
+        return undefined;
+    return [...dirs][0];
+};
+/** `localizable`, then `localizable-2` for a second catalog with the same basename. */
+const namespaces = (catalogs, notes) => {
+    const counts = new Map();
+    const bases = new Map();
+    return catalogs.map((catalog) => {
+        const base = kebab(posix.basename(catalog, '.xcstrings')) || 'strings';
+        const count = (counts.get(base) ?? 0) + 1;
+        counts.set(base, count);
+        if (count === 1) {
+            bases.set(base, posix.basename(catalog));
+            return base;
+        }
+        const namespace = `${base}-${count}`;
+        notes.push(`Two catalogs are named ${bases.get(base) ?? catalog}: the ${count === 2 ? 'second' : `${count}th`} one is namespace ${namespace}.`);
+        return namespace;
+    });
+};
+const PROJECT_MARKER = /\.(xcodeproj|xcworkspace)$|^Package\.swift$/;
+/**
+ * The directory Xcode resolves `<file original>` against: the nearest ancestor of the catalog (at or
+ * below `cwd`) holding an `.xcodeproj`, `.xcworkspace` or `Package.swift`; `.` when there is none.
+ */
+const projectRoot = async (cwd, catalog) => {
+    for (let dir = posix.dirname(catalog);; dir = posix.dirname(dir)) {
+        let entries;
+        try {
+            entries = await readdir(join(cwd, dir));
+        }
+        catch {
+            entries = [];
+        }
+        if (entries.some((entry) => PROJECT_MARKER.test(entry)))
+            return dir;
+        if (dir === '.')
+            return dir;
+    }
+};
+const rule = (pattern, namespace, original) => ({
+    pattern,
+    format: 'xliff',
+    namespace,
+    xliffDialect: 'xcode',
+    xliffOriginal: original,
+});
+/** Every `*.xcstrings` is a String Catalog; the XLIFF files Xcode imports live next to it, or will. */
+export async function detectXcode(cwd) {
+    const catalogs = await glob(cwd, '**/*.xcstrings');
+    const only = catalogs[0];
+    if (only === undefined)
+        return NONE;
+    const notes = [];
+    const names = namespaces(catalogs, notes);
+    const originals = [];
+    const roots = new Set();
+    for (const catalog of catalogs) {
+        const root = await projectRoot(cwd, catalog);
+        originals.push(root === '.' ? catalog : posix.relative(root, catalog));
+        if (root !== '.')
+            roots.add(root);
+    }
+    for (const root of roots)
+        notes.push(`Xcode project in ${root}/: xliffOriginal is relative to it, as Xcode expects.`);
+    if (catalogs.length === 1) {
+        const dir = await existingDir(cwd);
+        const pattern = dir === undefined ? 'Localization/{locale}.xliff' : dir === '.' ? '{locale}.xliff' : `${dir}/{locale}.xliff`;
+        if (dir === undefined) {
+            notes.push('No XLIFF files yet: `translify pull` creates Localization/<locale>.xliff; `xcodebuild -importLocalizations` reads them.');
+        }
+        return { rules: [rule(pattern, names[0] ?? 'strings', originals[0] ?? only)], notes };
+    }
+    return {
+        rules: catalogs.map((catalog, index) => rule(`Localization/${names[index] ?? 'strings'}/{locale}.xliff`, names[index] ?? 'strings', originals[index] ?? catalog)),
+        notes: ['Several String Catalogs: each gets its own folder under Localization/, created by `translify pull`.', ...notes],
+    };
+}

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { confirm, input, password, select } from '@inquirer/prompts';
+import { checkbox, confirm, input, password } from '@inquirer/prompts';
 import { Command, Option } from 'commander';
 import { runInit } from './commands/init.js';
 import { LINT_SEVERITIES, parseMaxWarnings, runLint } from './commands/lint.js';
@@ -9,7 +9,7 @@ import { runPull } from './commands/pull.js';
 import { PUSH_STATUSES, runPush } from './commands/push.js';
 import { loadConfig } from './config.js';
 import { askConfirm } from './confirm.js';
-import { resolveKey } from './credentials.js';
+import { findKey, resolveKey, saveKey } from './credentials.js';
 import { CliError, EXIT } from './errors.js';
 import { Api } from './http.js';
 import { VERSION } from './version.js';
@@ -44,25 +44,26 @@ const program = new Command('translify')
 program
     .command('init')
     .description('Create translify.json for this repository')
-    .action(async () => {
+    .option('-y, --yes', 'no prompts: take the detected defaults; the key comes from TRANSLIFY_SECRET_KEY or a previous login; never overwrites')
+    .option('--api-url <url>', `Translify API URL (default: ${DEFAULT_API_URL})`)
+    .action(async (opts) => {
     process.exitCode = await runInit({
         cwd: process.cwd(),
         isTty,
-        out,
+        yes: opts.yes === true,
+        apiUrl: opts.apiUrl,
         apiUrlDefault: DEFAULT_API_URL,
+        out,
         prompt: {
             input: async (message, defaultValue) => guarded(async () => input({ message, default: defaultValue }, { output: process.stderr }), ''),
             confirm: async (message, defaultValue) => guarded(async () => confirm({ message, default: defaultValue }, { output: process.stderr }), false),
-            choose: async (message, options) => guarded(async () => select({ message, choices: options.map((value) => ({ value })) }, { output: process.stderr }), options[0] ?? ''),
-        },
-        fetchWhoami: async (apiUrl) => {
-            try {
-                return await new Api(apiUrl, await resolveKey()).get('/cli/v1/whoami');
-            }
-            catch {
-                return undefined;
-            }
+            checkbox: async (message, options) => guarded(async () => checkbox({ message, choices: options.map((value) => ({ value, checked: true })) }, { output: process.stderr }), options),
+            // Ctrl+C here is "skip": init goes on without project info.
+            secret: async (message) => guarded(async () => password({ message, mask: '*' }, { output: process.stderr }), ''),
         },
+        findKey: async () => findKey(),
+        saveKey: async (key) => saveKey(key),
+        fetchWhoami: async (apiUrl, key) => new Api(apiUrl, key).get('/cli/v1/whoami'),
     });
 });
 program

package/dist/version.js

@@ -1,3 +1,3 @@
 // Must equal package.json "version"; src/version.test.ts fails when they drift.
-export const VERSION = '0.6.0';
+export const VERSION = '0.7.0';
 export const USER_AGENT = `translify-cli/${VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chesterbrains/translify-cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Push, pull and publish Translify translations from your repository",
   "license": "MIT",
   "repository": {