i18nsmith 0.2.0 → 0.2.1

package/dist/commands/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/commands/transform.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwEzC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,QAsGjD"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/commands/transform.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsJzC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,QAyGjD"}

package/dist/index.js

@@ -108399,6 +108399,9 @@ async function formatFileWithPrettier(filePath, loadPrettier = defaultLoader) {
 var Transformer = class _Transformer {
   constructor(config, options8 = {}) {
     this.config = config;
+    // Per-run dedupe state. Must be cleared at the beginning of each run.
+    // Keeping it on the instance caused subsequent runs to mislabel candidates as duplicates
+    // and could lead to confusing multi-pass behavior/reporting.
     this.seenHashes = /* @__PURE__ */ new Map();
     this.workspaceRoot = options8.workspaceRoot ?? process.cwd();
     this.project = options8.project ?? new Project6({ skipAddingFilesFromTsConfig: true });
@@ -108418,6 +108421,7 @@ var Transformer = class _Transformer {
     this.translationAdapter = this.normalizeTranslationAdapter(config.translationAdapter);
   }
   async run(runOptions = {}) {
+    this.seenHashes.clear();
     const write = runOptions.write ?? this.defaultWrite;
     const generateDiffs = runOptions.diff ?? false;
     if (write) {
@@ -108439,15 +108443,47 @@ var Transformer = class _Transformer {
       scanCalls: runOptions.migrateTextKeys
     });
     const enriched = await this.enrichCandidates(summary.detailedCandidates);
+    const transformableCandidates = enriched.filter(
+      (candidate) => candidate.status === "pending" || candidate.status === "existing"
+    );
     const filesChanged = /* @__PURE__ */ new Map();
     const skippedFiles = [];
     const shouldProcess = write || generateDiffs;
+    const enableProgress = Boolean(write && runOptions.onProgress && transformableCandidates.length > 0);
+    const progressState = {
+      processed: 0,
+      applied: 0,
+      skipped: 0,
+      errors: 0,
+      total: transformableCandidates.length
+    };
+    const emitProgress = () => {
+      if (!enableProgress || !runOptions.onProgress) {
+        return;
+      }
+      const percent = progressState.total === 0 ? 100 : Math.min(100, Math.round(progressState.processed / progressState.total * 100));
+      const payload = {
+        stage: "apply",
+        processed: progressState.processed,
+        total: progressState.total,
+        percent,
+        applied: progressState.applied,
+        skipped: progressState.skipped,
+        remaining: Math.max(progressState.total - progressState.processed, 0),
+        errors: progressState.errors,
+        message: "Applying transformations"
+      };
+      runOptions.onProgress(payload);
+    };
+    emitProgress();
     if (shouldProcess) {
       const fileImportCache = /* @__PURE__ */ new Map();
       for (const candidate of enriched) {
         if (candidate.status !== "pending" && candidate.status !== "existing") {
           continue;
         }
+        progressState.processed += 1;
+        let skipCounted = false;
         const wasExisting = candidate.status === "existing";
         try {
           const sourceFile = candidate.raw.sourceFile;
@@ -108478,6 +108514,9 @@ var Transformer = class _Transformer {
             candidate.status = "skipped";
             candidate.reason = "No React component/function scope found";
             skippedFiles.push({ filePath: candidate.filePath, reason: candidate.reason });
+            progressState.skipped += 1;
+            skipCounted = true;
+            emitProgress();
             continue;
           }
           if (write) {
@@ -108486,6 +108525,7 @@ var Transformer = class _Transformer {
             this.applyCandidate(candidate);
             candidate.status = "applied";
             filesChanged.set(candidate.filePath, sourceFile);
+            progressState.applied += 1;
           }
           if (!wasExisting) {
             const sourceValue = await this.findLegacyLocaleValue(this.sourceLocale, candidate.text) ?? candidate.text ?? generateValueFromKey(candidate.suggestedKey);
@@ -108502,15 +108542,30 @@ var Transformer = class _Transformer {
           candidate.status = "skipped";
           candidate.reason = error.message;
           skippedFiles.push({ filePath: candidate.filePath, reason: candidate.reason });
+          progressState.skipped += 1;
+          progressState.errors += 1;
+          skipCounted = true;
+        }
+        if (candidate.status === "skipped" && !skipCounted) {
+          progressState.skipped += 1;
+          skipCounted = true;
         }
+        emitProgress();
       }
       if (write) {
+        const changedFiles = Array.from(filesChanged.values());
         await Promise.all(
-          Array.from(filesChanged.values()).map(async (file) => {
+          changedFiles.map(async (file) => {
             await file.save();
             await formatFileWithPrettier(file.getFilePath());
           })
         );
+        for (const file of changedFiles) {
+          try {
+            file.refreshFromFileSystemSync();
+          } catch {
+          }
+        }
       }
     }
     const localeStats = write ? await this.localeStore.flush() : [];
@@ -108581,7 +108636,7 @@ var Transformer = class _Transformer {
       const generated = this.keyGenerator.generate(candidate.text, this.buildContext(candidate));
       let status = "pending";
       let reason;
-      const { node: _node, sourceFile: _sourceFile, ...serializableCandidate } = candidate;
+      const { node, sourceFile, ...serializableCandidate } = candidate;
       const validation = this.keyValidator.validate(generated.key, candidate.text);
       if (!validation.valid) {
         status = "skipped";
@@ -108711,9 +108766,21 @@ var collectTargetPatterns3 = (value, previous) => {
   return [...previous, ...tokens];
 };
 function printTransformSummary(summary) {
+  const counts = summary.candidates.reduce(
+    (acc, c7) => {
+      acc.total += 1;
+      if (c7.status === "applied") acc.applied += 1;
+      else if (c7.status === "pending") acc.pending += 1;
+      else if (c7.status === "duplicate") acc.duplicate += 1;
+      else if (c7.status === "existing") acc.existing += 1;
+      else if (c7.status === "skipped") acc.skipped += 1;
+      return acc;
+    },
+    { total: 0, applied: 0, pending: 0, duplicate: 0, existing: 0, skipped: 0 }
+  );
   console.log(
     chalk14.green(
-      `Scanned ${summary.filesScanned} file${summary.filesScanned === 1 ? "" : "s"}; ${summary.candidates.length} candidate${summary.candidates.length === 1 ? "" : "s"} processed.`
+      `Scanned ${summary.filesScanned} file${summary.filesScanned === 1 ? "" : "s"}; ${counts.total} candidate${counts.total === 1 ? "" : "s"} found (applied: ${counts.applied}, pending: ${counts.pending}, duplicates: ${counts.duplicate}, existing: ${counts.existing}, skipped: ${counts.skipped}).`
     )
   );
   const preview = summary.candidates.slice(0, 50).map((candidate) => ({
@@ -108725,6 +108792,15 @@ function printTransformSummary(summary) {
     Preview: candidate.text.length > 40 ? `${candidate.text.slice(0, 37)}...` : candidate.text
   }));
   console.table(preview);
+  const pending = summary.candidates.filter((candidate) => candidate.status === "pending").length;
+  if (pending > 0) {
+    console.log(
+      chalk14.yellow(
+        `
+${pending} candidate${pending === 1 ? "" : "s"} still pending. This can happen when candidates are filtered for safety (e.g., not in a React scope). Re-run with --write after reviewing skipped reasons if you want to keep iterating.`
+      )
+    );
+  }
   if (summary.filesChanged.length) {
     console.log(chalk14.blue(`Files changed (${summary.filesChanged.length}):`));
     summary.filesChanged.forEach((file) => console.log(`  \u2022 ${file}`));
@@ -108742,6 +108818,44 @@ function printTransformSummary(summary) {
     summary.skippedFiles.forEach((item) => console.log(`  \u2022 ${item.filePath}: ${item.reason}`));
   }
 }
+function createProgressLogger() {
+  let lastPercent = -1;
+  let lastLogTime = 0;
+  let pendingCarriageReturn = false;
+  const writeLine = (line3, final = false) => {
+    if (process.stdout.isTTY) {
+      process.stdout.write(`\r${line3}`);
+      pendingCarriageReturn = !final;
+      if (final) {
+        process.stdout.write("\n");
+      }
+    } else {
+      console.log(line3);
+    }
+  };
+  return {
+    emit(progress) {
+      if (progress.stage !== "apply" || progress.total === 0) {
+        return;
+      }
+      const now = Date.now();
+      const shouldLog = progress.processed === progress.total || progress.percent === 0 || progress.percent >= lastPercent + 2 || now - lastLogTime > 1500;
+      if (!shouldLog) {
+        return;
+      }
+      lastPercent = progress.percent;
+      lastLogTime = now;
+      const line3 = `Applying transforms ${progress.processed}/${progress.total} (${progress.percent}%) | applied: ${progress.applied ?? 0} | skipped: ${progress.skipped ?? 0}` + (progress.errors ? ` | errors: ${progress.errors}` : "") + ` | remaining: ${progress.remaining ?? progress.total - progress.processed}`;
+      writeLine(line3, progress.processed === progress.total);
+    },
+    flush() {
+      if (pendingCarriageReturn && process.stdout.isTTY) {
+        process.stdout.write("\n");
+        pendingCarriageReturn = false;
+      }
+    }
+  };
+}
 function registerTransform(program2) {
   program2.command("transform").description("Scan project and apply i18n transformations").option("-c, --config <path>", "Path to i18nsmith config file", "i18n.config.json").option("--json", "Print raw JSON results", false).option("--report <path>", "Write JSON summary to a file (for CI or editors)").option("--write", "Write changes to disk (defaults to dry-run)", false).option("--check", "Exit with error code if changes are needed", false).option("--diff", "Display unified diffs for locale files that would change", false).option("--patch-dir <path>", "Write locale diffs to .patch files in the specified directory").option("--target <pattern...>", "Limit scanning to specific files or glob patterns", collectTargetPatterns3, []).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 (options8) => {
     if (options8.applyPreview) {
@@ -108767,12 +108881,15 @@ function registerTransform(program2) {
 `));
       }
       const transformer = new Transformer(config, { workspaceRoot: projectRoot });
+      const progressLogger = createProgressLogger();
       const summary = await transformer.run({
         write: options8.write,
         targets: options8.target,
         diff: diffRequested,
-        migrateTextKeys: options8.migrateTextKeys
+        migrateTextKeys: options8.migrateTextKeys,
+        onProgress: progressLogger.emit
       });
+      progressLogger.flush();
       if (previewMode && options8.previewOutput) {
         const savedPath = await writePreviewFile("transform", summary, options8.previewOutput);
         console.log(chalk14.green(`Preview written to ${path33.relative(process.cwd(), savedPath)}`));

package/dist/utils/preview.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=preview.test.d.ts.map

package/dist/utils/preview.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.test.d.ts","sourceRoot":"","sources":["../../src/utils/preview.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18nsmith",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "CLI for i18nsmith",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/transform.ts

@@ -4,7 +4,7 @@ import chalk from 'chalk';
 import type { Command } from 'commander';
 import { loadConfigWithMeta } from '@i18nsmith/core';
 import { Transformer } from '@i18nsmith/transformer';
-import type { TransformSummary } 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';
 
@@ -32,10 +32,24 @@ const collectTargetPatterns = (value: string | string[], previous: string[]) =>
 };
 
 function printTransformSummary(summary: TransformSummary) {
+  const counts = summary.candidates.reduce(
+    (acc, c) => {
+      acc.total += 1;
+      if (c.status === 'applied') acc.applied += 1;
+      else if (c.status === 'pending') acc.pending += 1;
+      else if (c.status === 'duplicate') acc.duplicate += 1;
+      else if (c.status === 'existing') acc.existing += 1;
+      else if (c.status === 'skipped') acc.skipped += 1;
+      return acc;
+    },
+    { total: 0, applied: 0, pending: 0, duplicate: 0, existing: 0, skipped: 0 }
+  );
+
   console.log(
     chalk.green(
       `Scanned ${summary.filesScanned} file${summary.filesScanned === 1 ? '' : 's'}; ` +
-        `${summary.candidates.length} candidate${summary.candidates.length === 1 ? '' : 's'} processed.`
+        `${counts.total} candidate${counts.total === 1 ? '' : 's'} found ` +
+        `(applied: ${counts.applied}, pending: ${counts.pending}, duplicates: ${counts.duplicate}, existing: ${counts.existing}, skipped: ${counts.skipped}).`
     )
   );
 
@@ -53,6 +67,17 @@ function printTransformSummary(summary: TransformSummary) {
 
   console.table(preview);
 
+  const pending = summary.candidates.filter((candidate) => candidate.status === 'pending').length;
+  if (pending > 0) {
+    console.log(
+      chalk.yellow(
+        `\n${pending} candidate${pending === 1 ? '' : 's'} still pending. ` +
+          `This can happen when candidates are filtered for safety (e.g., not in a React scope). ` +
+          `Re-run with --write after reviewing skipped reasons if you want to keep iterating.`
+      )
+    );
+  }
+
   if (summary.filesChanged.length) {
     console.log(chalk.blue(`Files changed (${summary.filesChanged.length}):`));
     summary.filesChanged.forEach((file) => console.log(`  • ${file}`));
@@ -73,6 +98,59 @@ function printTransformSummary(summary: TransformSummary) {
   }
 }
 
+function createProgressLogger() {
+  let lastPercent = -1;
+  let lastLogTime = 0;
+  let pendingCarriageReturn = false;
+
+  const writeLine = (line: string, final = false) => {
+    if (process.stdout.isTTY) {
+      process.stdout.write(`\r${line}`);
+      pendingCarriageReturn = !final;
+      if (final) {
+        process.stdout.write('\n');
+      }
+    } else {
+      console.log(line);
+    }
+  };
+
+  return {
+    emit(progress: TransformProgress) {
+      if (progress.stage !== 'apply' || progress.total === 0) {
+        return;
+      }
+
+      const now = Date.now();
+      const shouldLog =
+        progress.processed === progress.total ||
+        progress.percent === 0 ||
+        progress.percent >= lastPercent + 2 ||
+        now - lastLogTime > 1500;
+
+      if (!shouldLog) {
+        return;
+      }
+
+      lastPercent = progress.percent;
+      lastLogTime = now;
+      const line =
+        `Applying transforms ${progress.processed}/${progress.total} (${progress.percent}%)` +
+        ` | 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);
+    },
+    flush() {
+      if (pendingCarriageReturn && process.stdout.isTTY) {
+        process.stdout.write('\n');
+        pendingCarriageReturn = false;
+      }
+    },
+  };
+}
+
 export function registerTransform(program: Command) {
   program
     .command('transform')
@@ -122,12 +200,15 @@ export function registerTransform(program: Command) {
         }
         
         const transformer = new Transformer(config, { workspaceRoot: projectRoot });
+        const progressLogger = createProgressLogger();
         const summary = await transformer.run({
           write: options.write,
           targets: options.target,
           diff: diffRequested,
           migrateTextKeys: options.migrateTextKeys,
+          onProgress: progressLogger.emit,
         });
+        progressLogger.flush();
 
         if (previewMode && options.previewOutput) {
           const savedPath = await writePreviewFile('transform', summary, options.previewOutput);

package/src/e2e.test.ts

@@ -144,6 +144,50 @@ describe('E2E Fixture Tests', () => {
       
       expect(parsed).toHaveProperty('diagnostics');
     });
+
+    it('applies preview selections to add missing keys and prune unused keys', async () => {
+      const appFile = path.join(fixtureDir, 'src', 'App.tsx');
+      const localeFile = path.join(fixtureDir, 'locales', 'en.json');
+      const previewDir = path.join(fixtureDir, '.i18nsmith', 'previews');
+      const previewPath = path.join(previewDir, 'integration-preview.json');
+      const selectionPath = path.join(previewDir, 'integration-selection.json');
+
+      const appContent = await fs.readFile(appFile, 'utf8');
+      const injected = appContent.replace(
+        '</div>',
+        "      <p>{t('integration.preview-missing')}</p>\n    </div>"
+      );
+      await fs.writeFile(appFile, injected, 'utf8');
+
+      const locale = JSON.parse(await fs.readFile(localeFile, 'utf8'));
+      locale['unused.preview.key'] = 'Preview-only key';
+      await fs.writeFile(localeFile, JSON.stringify(locale, null, 2));
+
+      const previewResult = runCli(['sync', '--preview-output', previewPath], { cwd: fixtureDir });
+      expect(previewResult.exitCode).toBe(0);
+
+      const payload = JSON.parse(await fs.readFile(previewPath, 'utf8')) as {
+        summary: { missingKeys: { key: string }[]; unusedKeys: { key: string }[] };
+      };
+      const selection = {
+        missing: payload.summary.missingKeys.map((entry) => entry.key),
+        unused: payload.summary.unusedKeys.map((entry) => entry.key),
+      };
+      expect(selection.missing).toContain('integration.preview-missing');
+      expect(selection.unused).toContain('unused.preview.key');
+      await fs.mkdir(previewDir, { recursive: true });
+      await fs.writeFile(selectionPath, JSON.stringify(selection, null, 2));
+
+      const applyResult = runCli(
+        ['sync', '--apply-preview', previewPath, '--selection-file', selectionPath, '--prune', '--yes'],
+        { cwd: fixtureDir }
+      );
+      expect(applyResult.exitCode).toBe(0);
+
+      const finalLocale = JSON.parse(await fs.readFile(localeFile, 'utf8'));
+      expect(finalLocale).toHaveProperty('integration.preview-missing');
+      expect(finalLocale).not.toHaveProperty('unused.preview.key');
+    });
   });
 
   describe('suspicious-keys fixture', () => {

package/src/utils/preview.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const mockSpawn = vi.fn();
+
+vi.mock('child_process', () => ({
+  spawn: (...args: Parameters<typeof mockSpawn>) => mockSpawn(...args),
+}));
+
+async function writePreviewFixture(args: string[]): Promise<string> {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'preview-test-'));
+  const previewPath = path.join(tempDir, 'sync-preview.json');
+  const payload = {
+    type: 'sync-preview',
+    version: 1,
+    command: 'i18nsmith sync --preview-output tmp.json',
+    args,
+    timestamp: new Date().toISOString(),
+    summary: { missingKeys: [], unusedKeys: [] },
+  };
+  await fs.writeFile(previewPath, JSON.stringify(payload, null, 2), 'utf8');
+  return previewPath;
+}
+
+function mockSuccessfulSpawn() {
+  mockSpawn.mockImplementation(() => {
+    const child = {
+      on(event: string, handler: (code?: number) => void) {
+        if (event === 'exit') {
+          setImmediate(() => handler(0));
+        }
+        return child;
+      },
+    } as unknown as ReturnType<typeof mockSpawn>;
+    return child;
+  });
+}
+
+describe('applyPreviewFile', () => {
+  beforeEach(() => {
+    mockSpawn.mockReset();
+    mockSuccessfulSpawn();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('replays preview with --write and extra args (selection + prune)', async () => {
+    const previewPath = await writePreviewFixture([
+      'sync',
+      '--target',
+      'src/app/**',
+      '--preview-output',
+      'tmp.json',
+    ]);
+    const selectionFile = path.join(path.dirname(previewPath), 'selection.json');
+
+    const { applyPreviewFile } = await import('./preview.js');
+
+    await applyPreviewFile('sync', previewPath, ['--selection-file', selectionFile, '--prune']);
+
+    expect(mockSpawn).toHaveBeenCalledTimes(1);
+    const [, spawnedArgs] = mockSpawn.mock.calls[0];
+    const [, ...forwardedArgs] = spawnedArgs as string[];
+    expect(forwardedArgs).toEqual([
+      'sync',
+      '--target',
+      'src/app/**',
+      '--write',
+      '--selection-file',
+      selectionFile,
+      '--prune',
+    ]);
+  });
+
+  it('does not duplicate --write when already present in preview args', async () => {
+    const previewPath = await writePreviewFixture(['sync', '--write', '--json']);
+    const { applyPreviewFile } = await import('./preview.js');
+
+    await applyPreviewFile('sync', previewPath);
+
+    expect(mockSpawn).toHaveBeenCalledTimes(1);
+    const [, spawnedArgs] = mockSpawn.mock.calls[0];
+    const [, ...forwardedArgs] = spawnedArgs as string[];
+    expect(forwardedArgs).toEqual(['sync', '--write', '--json']);
+  });
+});