i18nsmith 0.2.1 → 0.3.1

package/src/commands/transform.ts

@@ -7,6 +7,7 @@ import { Transformer } from '@i18nsmith/transformer';
 import type { TransformProgress, TransformSummary } from '@i18nsmith/transformer';
 import { printLocaleDiffs, writeLocaleDiffPatches } from '../utils/diff-utils.js';
 import { applyPreviewFile, writePreviewFile } from '../utils/preview.js';
+import { CliError, withErrorHandling } from '../utils/errors.js';
 
 interface TransformOptions {
   config?: string;
@@ -102,16 +103,26 @@ function createProgressLogger() {
   let lastPercent = -1;
   let lastLogTime = 0;
   let pendingCarriageReturn = false;
+  let lastPlainLog = 0;
+  let emittedZero = false;
+  const isTTY = Boolean(process.stdout.isTTY);
+  const minPercentStep = isTTY ? 5 : 15;
+  const minIntervalMs = isTTY ? 1000 : 4000;
 
   const writeLine = (line: string, final = false) => {
-    if (process.stdout.isTTY) {
+    if (isTTY) {
       process.stdout.write(`\r${line}`);
       pendingCarriageReturn = !final;
       if (final) {
         process.stdout.write('\n');
       }
-    } else {
+      return;
+    }
+
+    const now = Date.now();
+    if (final || now - lastPlainLog >= minIntervalMs) {
       console.log(line);
+      lastPlainLog = now;
     }
   };
 
@@ -122,25 +133,40 @@ function createProgressLogger() {
       }
 
       const now = Date.now();
-      const shouldLog =
-        progress.processed === progress.total ||
-        progress.percent === 0 ||
-        progress.percent >= lastPercent + 2 ||
-        now - lastLogTime > 1500;
+      const computedPercent =
+        typeof progress.percent === 'number'
+          ? Math.max(0, Math.min(100, Math.round(progress.percent)))
+          : progress.total
+          ? Math.round((progress.processed / progress.total) * 100)
+          : 0;
+      const reachedEnd = progress.processed === progress.total;
+      const percentAdvanced =
+        (!emittedZero && computedPercent === 0) || computedPercent >= lastPercent + minPercentStep || reachedEnd;
+      const timedOut = now - lastLogTime >= minIntervalMs;
 
-      if (!shouldLog) {
+      if (!percentAdvanced && !timedOut) {
         return;
       }
 
-      lastPercent = progress.percent;
+      if (!emittedZero && computedPercent === 0) {
+        emittedZero = true;
+      }
+
+      lastPercent = Math.max(lastPercent, computedPercent);
       lastLogTime = now;
+
+      const remaining =
+        typeof progress.remaining === 'number'
+          ? progress.remaining
+          : Math.max(progress.total - progress.processed, 0);
+
       const line =
-        `Applying transforms ${progress.processed}/${progress.total} (${progress.percent}%)` +
+        `Applying transforms ${progress.processed}/${progress.total} (${computedPercent}%)` +
         ` | applied: ${progress.applied ?? 0}` +
         ` | skipped: ${progress.skipped ?? 0}` +
         (progress.errors ? ` | errors: ${progress.errors}` : '') +
-        ` | remaining: ${progress.remaining ?? progress.total - progress.processed}`;
-      writeLine(line, progress.processed === progress.total);
+        ` | remaining: ${remaining}`;
+      writeLine(line, reachedEnd);
     },
     flush() {
       if (pendingCarriageReturn && process.stdout.isTTY) {
@@ -166,7 +192,8 @@ export function registerTransform(program: Command) {
     .option('--migrate-text-keys', 'Migrate existing t("Text") calls to structured keys')
     .option('--preview-output <path>', 'Write preview summary (JSON) to a file (implies dry-run)')
     .option('--apply-preview <path>', 'Apply a previously saved transform preview JSON file safely')
-    .action(async (options: TransformOptions) => {
+    .action(
+      withErrorHandling(async (options: TransformOptions) => {
       if (options.applyPreview) {
         await applyPreviewFile('transform', options.applyPreview);
         return;
@@ -247,13 +274,14 @@ export function registerTransform(program: Command) {
           console.log(chalk.yellow('Run again with --write to apply these changes.'));
         }
       } catch (error) {
-        const errorMessage = (error as Error).message;
+        const errorMessage = error instanceof Error ? error.message : String(error);
         if (options.json) {
           console.log(JSON.stringify({ ok: false, error: { message: errorMessage } }, null, 2));
-        } else {
-          console.error(chalk.red('Transform failed:'), errorMessage);
+          process.exitCode = 1;
+          return;
         }
-        process.exitCode = 1;
+        throw new CliError(`Transform failed: ${errorMessage}`);
       }
-    });
+    })
+    );
 }

package/src/commands/translate/index.ts

@@ -21,6 +21,7 @@ import { emitTranslateOutput, maybePrintEstimate } from './reporter.js';
 import { handleCsvExport, handleCsvImport } from './csv-handler.js';
 import { executeTranslations } from './executor.js';
 import { applyPreviewFile, writePreviewFile } from '../../utils/preview.js';
+import { CliError, withErrorHandling } from '../../utils/errors.js';
 
 // Re-export types for external use
 export * from './types.js';
@@ -102,7 +103,8 @@ export function registerTranslate(program: Command): void {
     .option('--import <path>', 'Import translations from a CSV file and merge into locale files')
     .option('--preview-output <path>', 'Write preview summary (JSON) to a file (implies dry-run)')
     .option('--apply-preview <path>', 'Apply a previously saved translate preview JSON file safely')
-    .action(async (options: TranslateCommandOptions) => {
+    .action(
+      withErrorHandling(async (options: TranslateCommandOptions) => {
       if (options.applyPreview) {
         await applyPreviewFile('translate', options.applyPreview, ['--yes']);
         return;
@@ -233,8 +235,9 @@ export function registerTranslate(program: Command): void {
             ? error
             : new Error(typeof error === 'string' ? error : JSON.stringify(error));
 
-        console.error(chalk.red('Translate failed:'), translatorError?.message ?? normalizedError.message);
-        process.exitCode = 1;
+        const message = translatorError?.message ?? normalizedError.message;
+        throw new CliError(`Translate failed: ${message}`);
       }
-    });
+    })
+    );
 }

package/src/e2e.test.ts

@@ -85,6 +85,17 @@ function extractJson<T>(output: string): T {
   return JSON.parse(jsonMatch[0]);
 }
 
+function parseRenameMap(content: string): Record<string, string> {
+  const mapping: Record<string, string> = {};
+  for (const line of content.split('\n')) {
+    const match = line.trim().match(/^"([^"]+)"\s*=\s*"([^"]+)"/);
+    if (match) {
+      mapping[match[1]] = match[2];
+    }
+  }
+  return mapping;
+}
+
 beforeAll(async () => {
   await ensureCliBuilt(CLI_PATH);
 });
@@ -258,20 +269,29 @@ describe('E2E Fixture Tests', () => {
 
       const enLocalePath = path.join(fixtureDir, 'locales', 'en.json');
       const frLocalePath = path.join(fixtureDir, 'locales', 'fr.json');
-      const enLocale = JSON.parse(await fs.readFile(enLocalePath, 'utf8'));
-      const frLocale = JSON.parse(await fs.readFile(frLocalePath, 'utf8'));
-
-      expect(enLocale).toHaveProperty('common.hello-world');
-      expect(enLocale).not.toHaveProperty('Hello World');
-      expect(frLocale).toHaveProperty('common.hello-world');
-
-      const sourceFile = await fs.readFile(path.join(fixtureDir, 'src', 'BadKeys.tsx'), 'utf8');
-      expect(sourceFile).toContain("t('common.hello-world')");
-      expect(sourceFile).not.toContain("t('Hello World')");
-
-      const mapPath = path.join(fixtureDir, 'auto-rename-map.txt');
-      const mapContents = await fs.readFile(mapPath, 'utf8');
-      expect(mapContents).toContain('"Hello World" = "common.hello-world"');
+  const enLocale = JSON.parse(await fs.readFile(enLocalePath, 'utf8'));
+  const frLocale = JSON.parse(await fs.readFile(frLocalePath, 'utf8'));
+
+  expect(enLocale).not.toHaveProperty('Hello World');
+  expect(frLocale).not.toHaveProperty('Hello World');
+
+  const mapPath = path.join(fixtureDir, 'auto-rename-map.txt');
+  const mapContents = await fs.readFile(mapPath, 'utf8');
+  expect(mapContents).toContain('"Hello World" = ');
+  const renameMap = parseRenameMap(mapContents);
+  const helloKey = renameMap['Hello World'];
+  expect(helloKey).toBeDefined();
+  const submitKey = renameMap['buttons.submit'];
+  expect(submitKey).toBeDefined();
+
+  expect(enLocale).toHaveProperty(helloKey!);
+  expect(frLocale).toHaveProperty(helloKey!);
+  expect(enLocale).toHaveProperty(submitKey!);
+  expect(frLocale).toHaveProperty(submitKey!);
+
+  const sourceFile = await fs.readFile(path.join(fixtureDir, 'src', 'BadKeys.tsx'), 'utf8');
+  expect(sourceFile).toContain(`t('${helloKey!}')`);
+  expect(sourceFile).not.toContain("t('Hello World')");
     });
   });
 

package/src/integration.test.ts

@@ -281,6 +281,45 @@ export function App() {
       expect(enData).not.toHaveProperty('existing.key');
     });
 
+    it('should delegate --check to the health check command', async () => {
+      await fs.writeFile(
+        path.join(tmpDir, 'src', 'App.tsx'),
+        `import { useTranslation } from 'react-i18next';
+export function App() {
+  const { t } = useTranslation();
+  return <div>{t('existing.key')}</div>;
+}`
+      );
+
+      const result = runCli(['sync', '--check'], { cwd: tmpDir });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.output).toContain('guided repository health check');
+    });
+
+    it('should fail via delegated check when using --check --strict and audit issues exist', async () => {
+      const duplicateLocale = {
+        'existing.key': 'Existing Value',
+        'buttons.submit': 'Submit',
+        'cta.submit': 'Submit',
+      };
+      await fs.writeFile(path.join(tmpDir, 'locales', 'en.json'), JSON.stringify(duplicateLocale, null, 2));
+      await fs.writeFile(path.join(tmpDir, 'locales', 'fr.json'), JSON.stringify(duplicateLocale, null, 2));
+      await fs.writeFile(
+        path.join(tmpDir, 'src', 'App.tsx'),
+        `import { useTranslation } from 'react-i18next';
+export function App() {
+  const { t } = useTranslation();
+  return <div>{t('existing.key')}</div>;
+}`
+      );
+
+      const result = runCli(['sync', '--check', '--strict'], { cwd: tmpDir });
+
+      expect(result.exitCode).toBe(10);
+      expect(result.output).toContain('Audit detected');
+    });
+
     it('should create backup when pruning', async () => {
       await fs.writeFile(
         path.join(tmpDir, 'src', 'App.tsx'),
@@ -445,5 +484,52 @@ export function App() {
       expect(parsed).toHaveProperty('diagnostics');
       expect(parsed).toHaveProperty('sync');
     });
+
+    it('should surface locale audit results and fail with --audit-strict', async () => {
+      const duplicateLocale = {
+        'hello': 'Hello',
+        'buttons.submit': 'Submit',
+        'cta.submit': 'Submit',
+      };
+      await fs.writeFile(path.join(tmpDir, 'locales', 'en.json'), JSON.stringify(duplicateLocale, null, 2));
+      await fs.writeFile(path.join(tmpDir, 'locales', 'fr.json'), JSON.stringify(duplicateLocale, null, 2));
+      await fs.writeFile(
+        path.join(tmpDir, 'src', 'App.tsx'),
+        `import { useTranslation } from 'react-i18next';
+export function App() {
+  const { t } = useTranslation();
+  return <div>{t('hello')}</div>;
+}`
+      );
+
+      const result = runCli(['check', '--audit', '--audit-strict'], { cwd: tmpDir });
+
+      expect(result.exitCode).toBe(10);
+      expect(result.output).toContain('Locale quality audit');
+    });
+
+    it('should include audit payload in JSON output when --audit is set', async () => {
+      const duplicateLocale = {
+        'hello': 'Hello',
+        'buttons.submit': 'Submit',
+        'cta.submit': 'Submit',
+      };
+      await fs.writeFile(path.join(tmpDir, 'locales', 'en.json'), JSON.stringify(duplicateLocale, null, 2));
+      await fs.writeFile(path.join(tmpDir, 'locales', 'fr.json'), JSON.stringify(duplicateLocale, null, 2));
+      await fs.writeFile(
+        path.join(tmpDir, 'src', 'App.tsx'),
+        `import { useTranslation } from 'react-i18next';
+export function App() {
+  const { t } = useTranslation();
+  return <div>{t('hello')}</div>;
+}`
+      );
+
+      const result = runCli(['check', '--audit', '--json'], { cwd: tmpDir });
+      const parsed = extractJson<{ audit?: { totalQualityIssues: number } }>(result.stdout);
+
+      expect(parsed).toHaveProperty('audit');
+      expect(parsed.audit?.totalQualityIssues ?? 0).toBeGreaterThan(0);
+    });
   });
 });

package/src/rename-suspicious.test.ts

@@ -0,0 +1,124 @@
+
+import { describe, it, expect, beforeAll, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { ensureCliBuilt } from './test-helpers/ensure-cli-built';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const CLI_PATH = path.resolve(__dirname, '../dist/index.js');
+const FIXTURES_DIR = path.resolve(__dirname, './fixtures');
+
+function runCli(
+  args: string[],
+  options: { cwd?: string } = {}
+): { stdout: string; stderr: string; output: string; exitCode: number } {
+  const result = spawnSync('node', [CLI_PATH, ...args], {
+    cwd: options.cwd ?? process.cwd(),
+    encoding: 'utf8',
+    timeout: 30000,
+    env: {
+      ...process.env,
+      CI: 'true',
+      NO_COLOR: '1',
+      FORCE_COLOR: '0',
+    },
+  });
+
+  return {
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+    output: (result.stdout ?? '') + (result.stderr ?? ''),
+    exitCode: result.status ?? 1,
+  };
+}
+
+async function setupFixture(fixtureName: string): Promise<string> {
+  const fixtureSource = path.join(FIXTURES_DIR, fixtureName);
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), `i18nsmith-e2e-${fixtureName}-`));
+  await fs.cp(fixtureSource, tmpDir, { recursive: true });
+  return tmpDir;
+}
+
+async function cleanupFixture(fixtureDir: string): Promise<void> {
+  await fs.rm(fixtureDir, { recursive: true, force: true });
+}
+
+describe('Rename Suspicious Keys E2E', () => {
+  let tmpDir: string;
+
+  beforeAll(async () => {
+    await ensureCliBuilt(CLI_PATH);
+  });
+
+  afterEach(async () => {
+    if (tmpDir) {
+      await cleanupFixture(tmpDir);
+    }
+  });
+
+  it('should generate rename diffs when running sync with auto-rename and preview output', async () => {
+    tmpDir = await setupFixture('suspicious-keys');
+    const previewPath = path.join(tmpDir, 'preview.json');
+
+    const { output, exitCode } = runCli(
+      ['sync', '--diff', '--auto-rename-suspicious', '--preview-output', previewPath],
+      { cwd: tmpDir }
+    );
+
+    expect(exitCode).toBe(0);
+    expect(output).toContain('Preview written to');
+
+    const previewContent = await fs.readFile(previewPath, 'utf8');
+    const preview = JSON.parse(previewContent);
+
+    expect(preview.summary).toBeDefined();
+    expect(preview.summary.suspiciousKeys.length).toBeGreaterThan(0);
+    
+    // Check for renameDiffs
+    expect(preview.summary.renameDiffs).toBeDefined();
+    expect(preview.summary.renameDiffs.length).toBeGreaterThan(0);
+    
+    // Check for localeDiffs
+    expect(preview.summary.localeDiffs).toBeDefined();
+    expect(preview.summary.localeDiffs.length).toBeGreaterThan(0);
+
+    // Verify specific rename proposal
+    const renameDiff = preview.summary.renameDiffs.find((d: any) => d.relativePath.includes('BadKeys.tsx'));
+    expect(renameDiff).toBeDefined();
+    // console.log('Actual diff:', renameDiff.diff);
+    expect(renameDiff.diff).toContain('-      <h1>{t(\'Hello World\')}</h1>');
+    // Key generation includes hash and file slug
+    expect(renameDiff.diff).toMatch(/\+      <h1>{t\('common\.badkeys\.hello-world\.[a-f0-9]+'\)}<\/h1>/); 
+  });
+
+  it('should handle existing keys that are suspicious (key-equals-value or contains-spaces)', async () => {
+    // This covers the user's specific scenario: key exists in locale but is suspicious
+    tmpDir = await setupFixture('suspicious-keys');
+    const previewPath = path.join(tmpDir, 'preview.json');
+
+    // "Hello World" exists in en.json and is suspicious
+    const { output, exitCode } = runCli(
+      ['sync', '--diff', '--auto-rename-suspicious', '--preview-output', previewPath],
+      { cwd: tmpDir }
+    );
+
+    expect(exitCode).toBe(0);
+    
+    const preview = JSON.parse(await fs.readFile(previewPath, 'utf8'));
+    
+    // Verify "Hello World" is in suspiciousKeys
+    const helloWorldSuspicious = preview.summary.suspiciousKeys.find((k: any) => k.key === 'Hello World');
+    expect(helloWorldSuspicious).toBeDefined();
+    // It might be 'contains-spaces' or 'key-equals-value' depending on priority
+    expect(['key-equals-value', 'contains-spaces']).toContain(helloWorldSuspicious.reason);
+
+    // Verify it has a rename diff
+    const renameDiff = preview.summary.renameDiffs.find((d: any) => d.relativePath.includes('BadKeys.tsx'));
+    expect(renameDiff).toBeDefined();
+  });
+});

package/src/utils/diff-utils.ts

@@ -1,3 +1,9 @@
+/**
+ * CLI presentation layer for diff utilities.
+ * This module handles printing and writing locale diffs for CLI commands.
+ * Core diff building logic is in packages/core/src/diff-utils.ts.
+ */
+
 import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';

package/src/utils/errors.ts

@@ -0,0 +1,34 @@
+import chalk from 'chalk';
+
+export class CliError extends Error {
+  constructor(message: string, public exitCode = 1) {
+    super(message);
+    this.name = 'CliError';
+  }
+}
+
+type MaybePromise<T> = T | Promise<T>;
+
+export function withErrorHandling<A extends unknown[], R>(
+  action: (...args: A) => MaybePromise<R>
+): (...args: A) => Promise<R | undefined> {
+  return async (...args: A): Promise<R | undefined> => {
+    try {
+      return (await action(...args)) as R;
+    } catch (error) {
+      if (error instanceof CliError) {
+        console.error(chalk.red(error.message));
+        process.exitCode = error.exitCode;
+        return undefined;
+      }
+
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk.red(`Unexpected error: ${message}`));
+      if (error instanceof Error && error.stack) {
+        console.error(chalk.gray(error.stack));
+      }
+      process.exitCode = 1;
+      return undefined;
+    }
+  };
+}