1.3.0

* feat: add incognito mode for private translations

## New
- Add `--incognito` CLI flag to `translate` and `init` commands
- Add `incognito` config option in `lara.yaml` schema
- Add interactive prompt for incognito mode during `lara-cli init`
- Support incognito across all translate modes (config, --file, --text)
- CLI flag overrides config value when both are set
- Add 8 integration tests covering all incognito scenarios

## Changed
- Bump version from 1.2.0 to 1.3.0
- Export shared mock translate function from test-helpers for call assertions

* refactor: rename --incognito to --no-trace

Align CLI flag and config naming with the @translated/lara SDK's
noTrace option. Commander.js --no-* negation semantics are used:
--no-trace sets trace=false, which maps to noTrace=true.

## Changed
- Rename --incognito CLI flag to --no-trace on translate and init commands
- Rename incognito config field to noTrace in lara.yaml schema
- Update all tests, docs, and messages accordingly

* refactor: remove no-trace interactive prompt

## Changed
- No-trace mode in interactive init is now set only via --no-trace flag, no longer prompted

* docs: improve no-trace mode documentation

## Changed
- Expand translate.md no-trace section with per-invocation and permanent config subsections
- Add noTrace field to config README basic structure example
- Add noTrace to schema relations diagram in structure.md

## New
- Add "Initialize with No-Trace Mode" example to init.md

Author: Starllordz

README.md

@@ -6,7 +6,7 @@ Lara Cli automates translation of your i18n files with a single command, preserv
 
 Supports multiple file formats including JSON, PO (gettext), TypeScript, Vue I18n single-file components, Markdown and MDX files, Android XML string resource files, Xcode localization files (.strings, .stringsdict, .xcstrings), and plain text (.txt) files. See [Supported Formats](docs/config/formats.md) for details.
 
-[![Version](https://img.shields.io/badge/version-1.2.0-blue.svg)](https://github.com/translated/lara-cli)
+[![Version](https://img.shields.io/badge/version-1.3.0-blue.svg)](https://github.com/translated/lara-cli)
 
 </div>
 

docs/commands/init.md

@@ -21,6 +21,7 @@ lara-cli init [options]
 | `-i, --instruction <instruction>` | Set project instruction for translation quality |
 | `-m, --translation-memories <memories>` | Set comma-separated Translation Memory IDs |
 | `-g, --glossaries <glossaries>` | Set comma-separated Glossary IDs |
+| `--no-trace` | Prevent server-side storage of translated content |
 | `-h, --help` | Display help information |
 
 ## Operating Modes
@@ -92,6 +93,14 @@ lara-cli init --source "en" --target "de, fr, it" \
 lara-cli init --reset-credentials
 ```
 
+### Initialize with No-Trace Mode
+
+```bash
+lara-cli init --no-trace
+```
+
+This sets `noTrace: true` in `lara.yaml`, which prevents the translation API from storing or logging your content server-side. All subsequent `lara-cli translate` runs will automatically use no-trace mode. You can also pass `--no-trace` directly to the translate command for one-off usage.
+
 ## Related
 
 - [Configuration Reference](../config/README.md)

docs/commands/translate.md

@@ -15,6 +15,7 @@ lara-cli translate [options]
 | `-t, --target <locales>` | Comma-separated list of target locales to translate to |
 | `-p, --paths <paths>` | Comma-separated list of specific file paths to translate (overrides config) |
 | `-f, --force` | Force retranslation of all content, even if unchanged |
+| `--no-trace` | Prevent server-side storage of translated content |
 | `-h, --help` | Display help information |
 
 ## Examples
@@ -129,6 +130,38 @@ Use `--force` when you need to:
 - Fix translation errors by regenerating all translations
 - Reset translations after configuration changes
 
+## No-Trace Mode
+
+Use `--no-trace` to prevent the translation API from storing or logging your content server-side. This is useful when translating sensitive or confidential content.
+
+### Per-Invocation
+
+Pass `--no-trace` to any translate command:
+
+```bash
+lara-cli translate --no-trace
+lara-cli translate --text "Sensitive data" --source en --target fr --no-trace
+lara-cli translate --file "confidential.json" --source en --target de --no-trace
+```
+
+### Permanent Configuration
+
+To enable no-trace for all translations in a project, either:
+
+1. Initialize with `--no-trace`:
+
+   ```bash
+   lara-cli init --no-trace
+   ```
+
+2. Or add it manually to `lara.yaml`:
+
+   ```yaml
+   noTrace: true
+   ```
+
+When set in the config, all `lara-cli translate` runs will use no-trace mode automatically. The `--no-trace` CLI flag always takes precedence over the config value.
+
 ## Direct Translation
 
 In addition to config-based translation, the `translate` command supports direct file and text translation. This mode is designed for CI/CD pipelines, scripting, and one-off translations — no `lara.yaml` configuration file is needed.
@@ -175,6 +208,7 @@ Only [supported file formats](../config/formats.md) are accepted (JSON, PO, XML,
 | `-o, --output <path>` | Output file path (only with `--file`) |
 | `-m, --translation-memories <ids>` | Translation Memory IDs (comma-separated) |
 | `-g, --glossaries <ids>` | Glossary IDs (comma-separated) |
+| `--no-trace` | Prevent server-side storage of translated content |
 
 ### Using Translation Memories & Glossaries
 

docs/config/README.md

@@ -21,6 +21,7 @@ memories:
   - mem_abc123
 glossaries:
   - gls_xyz789
+noTrace: false
 files:
   json:
     include:

docs/config/structure.md

@@ -13,6 +13,7 @@ lara.yaml
 ├── locales         # Language settings
 ├── memories        # Translation memory settings
 ├── glossaries      # Terminology settings
+├── noTrace         # No-trace mode (prevents server-side storage)
 └── files           # File path and processing rules
 ```
 
@@ -46,6 +47,9 @@ glossaries:
   - gls_xyz789
   - gls_uvw012
 
+# No-trace mode — prevents server-side storage of translated content
+noTrace: false
+
 # File path and processing rules
 files:
   json:
@@ -91,7 +95,9 @@ The diagram below shows how the different configuration sections relate to each
 ┌─────────────────┐           ┌───────────────────┐
 │ memories        │           │ files             │
 │ glossaries      │           │ (paths & rules)   │
-│ (terminology)   │           │                   │
+│ noTrace         │           │                   │
+│ (terminology &  │           │                   │
+│  privacy)       │           │                   │
 └─────────────────┘           └───────────────────┘
 ```
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@translated/lara-cli",
   "type": "module",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "CLI tool for automated i18n file translation using Lara Translate",
   "repository": {
     "type": "git",

src/__tests__/integration/cli.integration.test.ts

@@ -5,7 +5,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import yaml from 'yaml';
 
-import { executeCommand } from './test-helpers.js';
+import { executeCommand, mockTranslate } from './test-helpers.js';
 import initCommand from '../../cli/cmd/init/init.js';
 import translateCommand from '../../cli/cmd/translate/translate.js';
 import { ConfigProvider } from '#modules/config/config.provider.js';
@@ -516,4 +516,137 @@ describe('CLI Integration Tests', () => {
       expect(itContent.welcome).toBe('[it] Welcome');
     });
   });
+
+  describe('no-trace mode', () => {
+    it('should save noTrace: true to lara.yaml when --no-trace flag is passed to init', async () => {
+      await mkdir(path.join(testDir, 'src', 'i18n'), { recursive: true });
+      await writeFile(
+        path.join(testDir, 'src', 'i18n', 'en.json'),
+        JSON.stringify({ greeting: 'Hello' }, null, 2)
+      );
+
+      await executeCommand(initCommand, [
+        '--non-interactive',
+        '--source',
+        'en',
+        '--target',
+        'it',
+        '--paths',
+        'src/i18n/[locale].json',
+        '--no-trace',
+      ]);
+
+      const configPath = path.join(testDir, 'lara.yaml');
+      const configContent = await readFile(configPath, 'utf-8');
+      const config = yaml.parse(configContent);
+
+      expect(config.noTrace).toBe(true);
+    });
+
+    it('should default noTrace to false in lara.yaml when --no-trace flag is not passed', async () => {
+      await mkdir(path.join(testDir, 'src', 'i18n'), { recursive: true });
+      await writeFile(
+        path.join(testDir, 'src', 'i18n', 'en.json'),
+        JSON.stringify({ greeting: 'Hello' }, null, 2)
+      );
+
+      await executeCommand(initCommand, [
+        '--non-interactive',
+        '--source',
+        'en',
+        '--target',
+        'it',
+        '--paths',
+        'src/i18n/[locale].json',
+      ]);
+
+      const configPath = path.join(testDir, 'lara.yaml');
+      const configContent = await readFile(configPath, 'utf-8');
+      const config = yaml.parse(configContent);
+
+      expect(config.noTrace).toBe(false);
+    });
+
+    it('should pass noTrace: true when noTrace is enabled in config', async () => {
+      await mkdir(path.join(testDir, 'src', 'i18n'), { recursive: true });
+      await writeFile(
+        path.join(testDir, 'src', 'i18n', 'en.json'),
+        JSON.stringify({ greeting: 'Hello' }, null, 2)
+      );
+
+      await executeCommand(initCommand, [
+        '--non-interactive',
+        '--source',
+        'en',
+        '--target',
+        'it',
+        '--paths',
+        'src/i18n/[locale].json',
+        '--no-trace',
+      ]);
+
+      (ConfigProvider as any).instance = null;
+      mockTranslate.mockClear();
+
+      await executeCommand(translateCommand, []);
+
+      expect(mockTranslate).toHaveBeenCalled();
+      const lastCallOptions = mockTranslate.mock.calls[0]![3];
+      expect(lastCallOptions).toEqual(expect.objectContaining({ noTrace: true }));
+    });
+
+    it('should pass noTrace: true when --no-trace flag is used on translate command', async () => {
+      await mkdir(path.join(testDir, 'src', 'i18n'), { recursive: true });
+      await writeFile(
+        path.join(testDir, 'src', 'i18n', 'en.json'),
+        JSON.stringify({ greeting: 'Hello' }, null, 2)
+      );
+
+      await executeCommand(initCommand, [
+        '--non-interactive',
+        '--source',
+        'en',
+        '--target',
+        'it',
+        '--paths',
+        'src/i18n/[locale].json',
+      ]);
+
+      (ConfigProvider as any).instance = null;
+      mockTranslate.mockClear();
+
+      await executeCommand(translateCommand, ['--no-trace']);
+
+      expect(mockTranslate).toHaveBeenCalled();
+      const lastCallOptions = mockTranslate.mock.calls[0]![3];
+      expect(lastCallOptions).toEqual(expect.objectContaining({ noTrace: true }));
+    });
+
+    it('should not pass noTrace when noTrace is disabled', async () => {
+      await mkdir(path.join(testDir, 'src', 'i18n'), { recursive: true });
+      await writeFile(
+        path.join(testDir, 'src', 'i18n', 'en.json'),
+        JSON.stringify({ greeting: 'Hello' }, null, 2)
+      );
+
+      await executeCommand(initCommand, [
+        '--non-interactive',
+        '--source',
+        'en',
+        '--target',
+        'it',
+        '--paths',
+        'src/i18n/[locale].json',
+      ]);
+
+      (ConfigProvider as any).instance = null;
+      mockTranslate.mockClear();
+
+      await executeCommand(translateCommand, []);
+
+      expect(mockTranslate).toHaveBeenCalled();
+      const lastCallOptions = mockTranslate.mock.calls[0]![3] as Record<string, unknown>;
+      expect(lastCallOptions.noTrace).toBeUndefined();
+    });
+  });
 });

src/__tests__/integration/direct-translate.integration.test.ts

@@ -4,7 +4,7 @@ import { existsSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
-import { executeCommand } from './test-helpers.js';
+import { executeCommand, mockTranslate } from './test-helpers.js';
 import translateCommand from '../../cli/cmd/translate/translate.js';
 import { ConfigProvider } from '#modules/config/config.provider.js';
 
@@ -597,4 +597,62 @@ describe('Direct Translation Integration Tests', () => {
       expect(stdoutCalls).toContainEqual('[fr] Hello\n');
     });
   });
+
+  describe('no-trace mode', () => {
+    it('should pass noTrace: true when --no-trace is used with --text', async () => {
+      mockTranslate.mockClear();
+
+      await executeCommand(translateCommand, [
+        '--text',
+        'Hello',
+        '--source',
+        'en',
+        '--target',
+        'fr',
+        '--no-trace',
+      ]);
+
+      expect(mockTranslate).toHaveBeenCalled();
+      const lastCallOptions = mockTranslate.mock.calls[0]![3];
+      expect(lastCallOptions).toEqual(expect.objectContaining({ noTrace: true }));
+    });
+
+    it('should pass noTrace: true when --no-trace is used with --file', async () => {
+      const inputFile = path.join(testDir, 'hello.txt');
+      await writeFile(inputFile, 'Hello');
+
+      mockTranslate.mockClear();
+
+      await executeCommand(translateCommand, [
+        '--file',
+        inputFile,
+        '--source',
+        'en',
+        '--target',
+        'fr',
+        '--no-trace',
+      ]);
+
+      expect(mockTranslate).toHaveBeenCalled();
+      const lastCallOptions = mockTranslate.mock.calls[0]![3];
+      expect(lastCallOptions).toEqual(expect.objectContaining({ noTrace: true }));
+    });
+
+    it('should not pass noTrace when --no-trace is not used with --text', async () => {
+      mockTranslate.mockClear();
+
+      await executeCommand(translateCommand, [
+        '--text',
+        'Hello',
+        '--source',
+        'en',
+        '--target',
+        'fr',
+      ]);
+
+      expect(mockTranslate).toHaveBeenCalled();
+      const lastCallOptions = mockTranslate.mock.calls[0]![3] as Record<string, unknown>;
+      expect(lastCallOptions.noTrace).toBeUndefined();
+    });
+  });
 });

src/__tests__/integration/test-helpers.ts

@@ -1,18 +1,27 @@
 import { vi } from 'vitest';
 import { Command, Option } from 'commander';
 
+// Shared mock translate function, exported so tests can assert on call args
+export const mockTranslate = vi.fn(
+  async (
+    textBlocks: { text: string; translatable: boolean }[],
+    _sourceLocale: string,
+    targetLocale: string,
+    _options?: Record<string, unknown>
+  ) => {
+    return textBlocks.map((block: { text: string; translatable: boolean }) => ({
+      text: block.translatable ? `[${targetLocale}] ${block.text}` : block.text,
+      translatable: block.translatable,
+    }));
+  }
+);
+
 // Mock translation service
 vi.mock('#modules/translation/translation.service.js', () => {
   return {
     TranslationService: {
       getInstance: vi.fn(() => ({
-        translate: vi.fn(async (textBlocks, _sourceLocale, targetLocale) => {
-          // Return mock translations based on target locale
-          return textBlocks.map((block: { text: string; translatable: boolean }) => ({
-            text: block.translatable ? `[${targetLocale}] ${block.text}` : block.text,
-            translatable: block.translatable,
-          }));
-        }),
+        translate: mockTranslate,
       })),
     },
   };