@chesterbrains/translify-cli 0.6.1 → 0.8.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,6 +128,8 @@ server converts both ways:
 { "files": [{ "pattern": "src/locale/messages.{locale}.xlf", "format": "xliff", "namespace": "web", "xliffDialect": "angular" }] }
 ```
 
+`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:
@@ -171,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
@@ -228,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 |
@@ -238,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`
@@ -252,34 +257,38 @@ Options:
 - **Source locale: your files win.** Existing source translations are overwritten with what is in the file.
 - **Target locales: Translify fills only the gaps.** Keys that already have a translation are left alone and counted as skipped.
 - `--overwrite-targets` also overwrites existing target translations.
-- `--prune` deletes keys that no longer exist in your source files, together with their translations. See [Prune safety](#prune-safety).
+- `--prune` moves keys that no longer exist in your source files to the Translify trash, together with their translations. They can be restored for 30 days. See [Prune safety](#prune-safety).
 - `--yes` skips the confirmation prompt for the two destructive flags. Without a terminal and without `--yes`, a destructive push is refused and nothing changes.
 - `--dry-run` shows the effect of any combination and writes nothing.
 
 ## Prune safety
 
-`translify push --prune` is the only command that deletes keys. What it deletes, and what stops it:
+`translify push --prune` is the only command that removes keys. It never deletes on the spot: it archives them. What
+it archives, and what stops it:
 
 - **Only the namespaces in this push.** A key is an orphan when its namespace is in the push and its source file no
   longer has it. Namespaces you did not push (another rule, another repository, `--namespace` left them out) are never
   touched.
-- **Never published keys.** A key published to any environment is listed as kept and survives. Unpublish it in
-  Translify first if it really should go.
+- **Archived, not deleted.** A pruned key goes to the trash in Translify, with its translations and their history.
+  It is deleted for good 30 days later. Until then, restore it from the trash on the project's Translations tab, or
+  push a source file that names it again: the push restores it in place and reports it as restored.
+- **Live keys too.** A key that is live in an environment is archived like any other, but the
+  environment keeps serving it until its next publish, which drops it. Restore it before then if it should stay.
 - **Never a whole namespace by accident.** If a source file in the push has no entries, the push is refused
-  (`VALIDATION_FAILED` with `emptySourcePrune`) instead of deleting every key in that namespace. Emptying a namespace
+  (`VALIDATION_FAILED` with `emptySourcePrune`) instead of archiving every key in that namespace. Emptying a namespace
   is done in the Translify web app.
-- **Exactly the list you confirmed.** The CLI always runs a dry run first, shows the keys it would delete and asks
+- **Exactly the list you confirmed.** The CLI always runs a dry run first, shows the keys it would archive and asks
   for confirmation. The real push sends a digest of that list; if the server's list differs by then (keys added,
-  removed or published in between), it refuses with `ORPHANS_CHANGED` and writes nothing. A server too old to return
+  removed, archived or restored in between), it refuses with `ORPHANS_CHANGED` and writes nothing. A server too old to return
   the digest makes `--prune` refuse.
 - **No silent prune in CI.** Without a terminal, `--prune` is refused unless you pass `--yes`.
-- **Atomic.** The whole push, deletions included, is one transaction: if anything fails, nothing is written.
+- **Atomic.** The whole push, archives and restores included, is one transaction: if anything fails, nothing is written.
 
 `--yes` confirms whatever that run's dry run lists, so in CI review the list before it runs unattended. One way:
 show the orphans on pull requests and prune on `main`.
 
 ```yaml
-# on pull_request: list what a prune would delete, change nothing
+# on pull_request: list what a prune would archive, change nothing
 - run: npx translify push --prune --dry-run
   env:
     TRANSLIFY_SECRET_KEY: ${{ secrets.TRANSLIFY_SECRET_KEY }}
@@ -302,48 +311,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 }}
 ```
@@ -352,20 +347,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 |
@@ -387,7 +368,7 @@ The server's error `code` decides the exit code first; the HTTP status is only u
 | `VALIDATION_FAILED` | 1 | Nothing was written. The output lists `file:line key: reason`; fix those entries and push again. |
 | `LOCALE_NOT_FOUND` | 1 | A locale in your files is not enabled in the project. Enable it in Translify, or map it with `locales` in `translify.json`. |
 | `NAMESPACE_NOT_FOUND` | 1 | The namespace does not exist in the project. Create it in Translify or fix the `--namespace` / pattern. |
-| `VALIDATION_FAILED` with `emptySourcePrune` | 1 | `--prune` was refused because a source file in the push has no entries (it would delete the whole namespace). Push the real source file, or drop `--prune`; emptying a namespace is done in the Translify web app. |
+| `VALIDATION_FAILED` with `emptySourcePrune` | 1 | `--prune` was refused because a source file in the push has no entries (it would archive the whole namespace). Push the real source file, or drop `--prune`; emptying a namespace is done in the Translify web app. |
 | `JSON_STYLE_REQUIRES_JSON` | 1 | `jsonStyle` only applies to rules with `"format": "json"`. Remove it from the other rules. |
 | `BAD_REQUEST` | 1 | The request was malformed. Re-run with `--debug` for the server's message. |
 | `ENVIRONMENT_NOT_FOUND` / `ENVIRONMENT_ARCHIVED` | 1 | Check the environment slug passed to `publish` or `--from env:<slug>`, and that it is not archived. |
@@ -400,7 +381,7 @@ The server's error `code` decides the exit code first; the HTTP status is only u
 | `QUOTA_EXCEEDED` | 3 | Your plan limit was reached (usually translation keys). Remove keys, or push a smaller set. |
 | `PUSH_TOO_LARGE` | 4 | Split the push by namespace: `translify push --namespace <ns>`. |
 | `CLI_TOO_OLD` | 4 | Upgrade: `npm i -g @chesterbrains/translify-cli@latest` (or use `npx translify@latest`). |
-| `ORPHANS_CHANGED` | 1 | The orphan list changed between the dry run and the real push (keys were added, removed or published). Nothing was written; run `translify push --prune` again to review the new list. |
+| `ORPHANS_CHANGED` | 1 | The orphan list changed between the dry run and the real push (keys were added, removed, archived or restored). Nothing was written; run `translify push --prune` again to review the new list. |
 | `REVIEW_DISABLED` | 1 | `push --status draft` or `--status needs-review` on a project without review. Turn on **Require review** in the project settings, or drop `--status`. Nothing was written. |
 | `APPROVED_ONLY_REQUIRES_WORKING` | 1 | `--only-approved` was combined with `--from env:<slug>`. Pull an environment without it; it already holds only what its gate allowed. |
 | `INVALID_CELLS` | 6 | `publish` refused: translations that would go live have placeholder errors. Nothing was published; the output lists them like `lint` does. Fix them in Translify, or re-run with `--allow-errors` to publish anyway (recorded in the activity log). |

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/commands/push.js

@@ -42,10 +42,11 @@ const buildForm = (uploads, opts, dryRun, prune, pruneDigest) => {
  */
 const describeDamage = async (preview, opts, api) => {
     const damage = [];
-    // Published orphans are kept by the server, so they are not part of the damage.
-    const deletable = preview.orphans.filter((orphan) => !orphan.published).length;
-    if (opts.prune === true && deletable > 0)
-        damage.push(`delete ${deletable} key(s) and all their translations`);
+    // Every orphan is archived, live ones included: they keep serving until the next publish.
+    const archivable = preview.orphans.length;
+    if (opts.prune === true && archivable > 0) {
+        damage.push(`move ${archivable} key(s) and their translations to the trash (restorable for 30 days in Translify)`);
+    }
     if (opts.overwriteTargets === true) {
         const { project } = await api.get('/cli/v1/whoami');
         const overwritten = Object.entries(preview.locales)
@@ -90,12 +91,12 @@ export async function runPush(opts, deps) {
     }
     const preview = await deps.api.post(PUSH, buildForm(uploads, opts, true, opts.prune === true));
     if (opts.prune === true && typeof preview.pruneDigest !== 'string') {
-        deps.err('This server cannot confirm a prune (its dry run returned no pruneDigest), so --prune would delete without a bound. ' +
+        deps.err('This server cannot confirm a prune (its dry run returned no pruneDigest), so --prune would archive without a bound. ' +
             'Nothing was changed. Upgrade the Translify server, or push without --prune.');
         return EXIT.failed;
     }
     const damage = await describeDamage(preview, opts, deps.api);
-    // Nothing would be deleted or overwritten: no question to ask (F19).
+    // Nothing would be archived or overwritten: no question to ask (F19).
     if (damage.length > 0) {
         // With --json, stdout is reserved for the final document.
         (opts.json === true ? deps.err : deps.out)(renderPush(preview));
@@ -111,10 +112,9 @@ export async function runPush(opts, deps) {
             }
         }
     }
-    // With deletable orphans the real push sends the digest of the list the user confirmed: if the server's
-    // deletable set differs it answers 409 ORPHANS_CHANGED and writes nothing. With none, there is nothing to prune.
-    const deletable = preview.orphans.filter((orphan) => !orphan.published).length;
-    const prune = opts.prune === true && deletable > 0;
+    // With orphans the real push sends the digest of the list the user confirmed: if the server's orphan
+    // set differs it answers 409 ORPHANS_CHANGED and writes nothing. With none, there is nothing to prune.
+    const prune = opts.prune === true && preview.orphans.length > 0;
     const res = await deps.api.post(PUSH, buildForm(uploads, opts, false, prune, prune ? preview.pruneDigest : undefined));
     show(res, preview);
     return EXIT.ok;

package/dist/credentials.js

@@ -25,7 +25,8 @@ export const assertSecret = (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);
@@ -34,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/http.js

@@ -85,7 +85,7 @@ const describeBody = (status, body) => {
         case 'NAMESPACE_NOT_FOUND':
             return `Unknown namespace(s): ${list(body.namespaces)}.`;
         case 'ORPHANS_CHANGED':
-            return 'The orphans changed since the dry run (keys were added, removed or published meanwhile). Nothing was written. Run translify push --prune again to review the new list.';
+            return 'The orphans changed since the dry run (keys were added, removed, archived or restored meanwhile). Nothing was written. Run translify push --prune again to review the new list.';
         case 'REVIEW_DISABLED':
             return 'Review is off for this project, so --status draft or needs-review cannot be used. Turn on "Require review" in the project settings, or drop --status.';
         case 'APPROVED_ONLY_REQUIRES_WORKING':

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
@@ -88,7 +89,7 @@ program
     .description('Upload source and target files')
     .option('--dry-run', 'show what would change, write nothing')
     .option('--overwrite-targets', 'overwrite existing target-locale translations')
-    .option('--prune', 'delete keys missing from your source files; published keys are kept; deletes exactly the keys you confirmed, and refuses if anything changed meanwhile (re-run to review)')
+    .option('--prune', 'move keys missing from your source files to the Translify trash (restorable for 30 days); archives exactly the keys you confirmed, and refuses if anything changed meanwhile (re-run to review)')
     .option('-y, --yes', 'confirm destructive flags without prompting')
     .option('--namespace <ns>', 'only this namespace')
     .addOption(new Option('--status <status>', 'status target-locale cells land in (default: needs-review when the project requires review, approved otherwise)').choices(PUSH_STATUSES))

package/dist/render.js

@@ -14,8 +14,8 @@ export function summarizePush(res) {
         skippedFilled: 0,
         unknownKeys: 0,
         orphans: res.orphans.length,
-        publishedOrphans: res.orphans.filter((orphan) => orphan.published).length,
         pruned: res.pruned,
+        keysRestored: res.keysRestored ?? 0,
         staleReset: res.staleReset ?? 0,
     };
     for (const counts of Object.values(res.locales)) {
@@ -47,36 +47,36 @@ export function renderPush(res, view = {}) {
     if (stale > 0) {
         lines.push(pc.yellow(`${stale} approved translation(s) ${res.dryRun ? 'would go' : 'went'} back to review because their source text changed.`));
     }
-    // `pruned` is what a dry run would delete or a real push did delete: unpublished orphans only.
-    const unpublished = res.orphans.filter((orphan) => !orphan.published);
-    const published = res.orphans.filter((orphan) => orphan.published);
-    const listed = unpublished;
-    const names = (list) => {
-        for (const orphan of list.slice(0, MAX_ORPHANS))
-            lines.push(`    ${orphan.namespace}:${orphan.key}`);
-        if (list.length > MAX_ORPHANS)
-            lines.push(`    …and ${list.length - MAX_ORPHANS} more`);
-    };
+    const restored = res.keysRestored ?? 0;
+    if (restored > 0) {
+        lines.push(pc.green(`${res.dryRun ? 'Would restore' : 'Restored'} ${restored} key(s) from the trash.`));
+    }
+    // A prune archives every orphan (it goes to the trash, purged 30 days later); `pruned` is what a dry
+    // run would archive or a real push did. A real prune can archive fewer than it listed when some
+    // orphans were archived from the web app meanwhile.
+    const listed = res.orphans;
     if (listed.length > 0) {
+        const meanwhile = listed.length - res.pruned;
         const header = res.pruned === 0
             ? `${listed.length} key(s) in Translify are not in your source files:`
             : res.dryRun
-                ? `${listed.length} key(s) not in your source files would be deleted:`
-                : `Deleted ${res.pruned} key(s) that were not in your source files${listed.length > res.pruned ? ` (${listed.length - res.pruned} kept: published during the push)` : ''}:`;
+                ? `${listed.length} key(s) not in your source files would be moved to the trash:`
+                : `Moved ${res.pruned} key(s) that were not in your source files to the trash (restorable for 30 days${meanwhile > 0 ? `; ${meanwhile} already archived meanwhile` : ''}):`;
         lines.push(pc.yellow(`  ${header}`));
-        names(listed);
+        for (const orphan of listed.slice(0, MAX_ORPHANS))
+            lines.push(`    ${orphan.namespace}:${orphan.key}`);
+        if (listed.length > MAX_ORPHANS)
+            lines.push(`    …and ${listed.length - MAX_ORPHANS} more`);
         if (res.pruned === 0 && view.prune !== true)
-            lines.push(pc.dim('  Use --prune to delete them.'));
+            lines.push(pc.dim('  Use --prune to move them to the trash.'));
     }
-    if (published.length > 0) {
-        lines.push(pc.yellow(`  ${published.length} key(s) kept — published; unpublish it in Translify to delete it:`));
-        names(published);
+    if (res.pruned > 0 && res.dryRun) {
+        lines.push(pc.yellow(`  Would move ${res.pruned} key(s) to the trash (restorable for 30 days).`));
     }
-    if (res.pruned > 0 && res.dryRun)
-        lines.push(pc.yellow(`  Would delete ${res.pruned} key(s).`));
     // A real prune's orphan header already says it; repeat it only when there was no list.
-    if (res.pruned > 0 && !res.dryRun && listed.length === 0)
-        lines.push(pc.red(`  Deleted ${res.pruned} key(s).`));
+    if (res.pruned > 0 && !res.dryRun && listed.length === 0) {
+        lines.push(pc.yellow(`  Moved ${res.pruned} key(s) to the Translify trash (restorable for 30 days).`));
+    }
     return lines.join('\n');
 }
 const MAX_VALUE = 80;

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.1';
+export const VERSION = '0.8.0';
 export const USER_AGENT = `translify-cli/${VERSION}`;

package/package.json

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