i18nsmith 0.1.9 → 0.2.0

package/src/commands/translate/index.ts

@@ -4,6 +4,7 @@
 
 import chalk from 'chalk';
 import inquirer from 'inquirer';
+import path from 'path';
 import type { Command } from 'commander';
 import {
   DEFAULT_PLACEHOLDER_FORMATS,
@@ -19,6 +20,7 @@ import type { TranslateCommandOptions, TranslateSummary, ProviderSettings } from
 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';
 
 // Re-export types for external use
 export * from './types.js';
@@ -98,7 +100,14 @@ export function registerTranslate(program: Command): void {
     .option('--strict-placeholders', 'Fail if translated output has placeholder mismatches (for CI)', false)
     .option('--export <path>', 'Export missing translations to a CSV file for external translation')
     .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) => {
+      if (options.applyPreview) {
+        await applyPreviewFile('translate', options.applyPreview, ['--yes']);
+        return;
+      }
+
       // Handle CSV export mode
       if (options.export) {
         await handleCsvExport(options);
@@ -111,9 +120,14 @@ export function registerTranslate(program: Command): void {
         return;
       }
 
-      console.log(
-        chalk.blue(options.write ? 'Translating locale files...' : 'Planning translations (dry-run)...')
-      );
+      const previewMode = Boolean(options.previewOutput);
+      const writeEnabled = Boolean(options.write) && !previewMode;
+      if (previewMode && options.write) {
+        console.log(chalk.yellow('Preview requested; ignoring --write and running in dry-run mode.'));
+      }
+      options.write = writeEnabled;
+
+      console.log(chalk.blue(writeEnabled ? 'Translating locale files...' : 'Planning translations (dry-run)...'));
 
       try {
         const config = await loadConfig(options.config);
@@ -142,6 +156,12 @@ export function registerTranslate(program: Command): void {
         };
 
         if (!options.write) {
+          if (previewMode && options.previewOutput) {
+            const savedPath = await writePreviewFile('translate', summary, options.previewOutput);
+            console.log(chalk.green(`Preview written to ${path.relative(process.cwd(), savedPath)}`));
+            return;
+          }
+
           if (options.estimate && providerSettings.name !== 'manual') {
             await maybePrintEstimate(plan, providerSettings);
           }

package/src/commands/translate/types.ts

@@ -19,6 +19,8 @@ export interface TranslateCommandOptions {
   strictPlaceholders?: boolean;
   export?: string;
   import?: string;
+  previewOutput?: string;
+  applyPreview?: string;
 }
 
 export interface TranslateLocaleResult extends TranslationWriteSummary {

package/src/commands/translate.test.ts

@@ -1,12 +1,19 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, beforeAll } from 'vitest';
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import { execSync } from 'child_process';
+import { ensureCliBuilt } from '../test-helpers/ensure-cli-built';
+
+const CLI_PATH = path.resolve(__dirname, '..', '..', 'dist', 'index.js');
 
 describe('translate command', () => {
   let tempDir: string;
 
+  beforeAll(async () => {
+    await ensureCliBuilt(CLI_PATH);
+  });
+
   beforeEach(async () => {
     tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'i18nsmith-translate-test-'));
     
@@ -55,9 +62,8 @@ export function App() {
   });
 
   const runCli = (args: string): string => {
-    const cliPath = path.resolve(__dirname, '..', '..', 'dist', 'index.js');
     try {
-      return execSync(`node ${cliPath} ${args}`, {
+      return execSync(`node ${CLI_PATH} ${args}`, {
         cwd: tempDir,
         encoding: 'utf8',
         stdio: ['pipe', 'pipe', 'pipe'],

package/src/e2e.test.ts

@@ -9,6 +9,7 @@ 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);
@@ -84,17 +85,8 @@ function extractJson<T>(output: string): T {
   return JSON.parse(jsonMatch[0]);
 }
 
-beforeAll(() => {
-  const cliRoot = path.resolve(__dirname, '..');
-  const result = spawnSync('pnpm', ['build'], {
-    cwd: cliRoot,
-    stdio: 'inherit',
-    env: { ...process.env },
-  });
-
-  if (result.status !== 0) {
-    throw new Error('Failed to build CLI before running E2E tests');
-  }
+beforeAll(async () => {
+  await ensureCliBuilt(CLI_PATH);
 });
 
 describe('E2E Fixture Tests', () => {

package/src/index.ts

@@ -15,6 +15,7 @@ import { registerBackup } from './commands/backup.js';
 import { registerRename } from './commands/rename.js';
 import { registerInstallHooks } from './commands/install-hooks.js';
 import { registerConfig } from './commands/config.js';
+import { registerReview } from './commands/review.js';
 
 export const program = new Command();
 
@@ -38,6 +39,7 @@ registerBackup(program);
 registerRename(program);
 registerInstallHooks(program);
 registerConfig(program);
+registerReview(program);
 
 
 program.parse();

package/src/integration.test.ts

@@ -3,17 +3,19 @@
  * These tests run the actual CLI commands against real file systems
  */
 
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, beforeAll } 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);
 
 // Get the correct CLI path regardless of where tests are run from
+// During tests, __dirname points to src/, so we go up one level to find dist/
 const CLI_PATH = path.resolve(__dirname, '../dist/index.js');
 
 // Helper to run CLI commands
@@ -33,6 +35,11 @@ function runCli(
     },
   });
 
+  // Log errors for debugging
+  if (result.error) {
+    console.error('CLI execution error:', result.error);
+  }
+
   const stdout = result.stdout ?? '';
   const stderr = result.stderr ?? '';
 
@@ -56,6 +63,10 @@ function extractJson<T>(output: string): T {
 describe('CLI Integration Tests', () => {
   let tmpDir: string;
 
+  beforeAll(async () => {
+    await ensureCliBuilt(CLI_PATH);
+  });
+
   beforeEach(async () => {
     tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'i18nsmith-cli-integration-'));
   });

package/src/test-helpers/ensure-cli-built.ts

@@ -0,0 +1,32 @@
+import { stat } from 'fs/promises';
+
+const DEFAULT_MAX_ATTEMPTS = 20;
+const DEFAULT_DELAY_MS = 300;
+const MIN_FILE_SIZE_BYTES = 1024;
+
+function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export async function ensureCliBuilt(cliPath: string): Promise<void> {
+  const maxAttempts = Number(process.env.I18NSMITH_TEST_CLI_ATTEMPTS ?? DEFAULT_MAX_ATTEMPTS);
+  const delayMs = Number(process.env.I18NSMITH_TEST_CLI_DELAY_MS ?? DEFAULT_DELAY_MS);
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const stats = await stat(cliPath);
+      if (stats.size >= MIN_FILE_SIZE_BYTES) {
+        return;
+      }
+    } catch {
+      // ignore and retry
+    }
+
+    await sleep(delayMs);
+  }
+
+  throw new Error(
+    `CLI not found at ${cliPath} after ${maxAttempts} attempts. ` +
+      "Ensure 'pnpm build' completes successfully before running tests."
+  );
+}

package/src/utils/preview.ts

@@ -0,0 +1,126 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { spawn } from 'child_process';
+
+export interface PreviewPayload<TSummary> {
+  type: string;
+  version: number;
+  command: string;
+  args: string[];
+  timestamp: string;
+  summary: TSummary;
+}
+
+export type PreviewKind = 'sync' | 'transform' | 'rename-key' | 'translate';
+
+export async function writePreviewFile<TSummary>(
+  kind: PreviewKind,
+  summary: TSummary,
+  outputPath: string
+): Promise<string> {
+  const resolvedPath = path.resolve(process.cwd(), outputPath);
+  const payload: PreviewPayload<TSummary> = {
+  type: `${kind}-preview`,
+    version: 1,
+    command: buildCommandString(),
+    args: process.argv.slice(2),
+    timestamp: new Date().toISOString(),
+    summary,
+  };
+
+  await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+  await fs.writeFile(resolvedPath, JSON.stringify(payload, null, 2), 'utf8');
+  return resolvedPath;
+}
+
+export async function readPreviewFile<TSummary>(
+  expectedKind: PreviewKind,
+  previewPath: string
+): Promise<PreviewPayload<TSummary>> {
+  const resolved = path.resolve(process.cwd(), previewPath);
+  const raw = await fs.readFile(resolved, 'utf8');
+  const payload = JSON.parse(raw) as PreviewPayload<TSummary>;
+  if (!payload?.type?.startsWith(`${expectedKind}-preview`)) {
+    throw new Error(`Preview kind mismatch. Expected ${expectedKind}, got ${payload?.type ?? 'unknown'}.`);
+  }
+  if (!Array.isArray(payload.args) || payload.args.length === 0) {
+    throw new Error('Preview file is missing recorded CLI arguments.');
+  }
+  return payload;
+}
+
+export async function applyPreviewFile(
+  expectedKind: PreviewKind,
+  previewPath: string,
+  extraArgs: string[] = []
+): Promise<void> {
+  const payload = await readPreviewFile(expectedKind, previewPath);
+  const sanitizedArgs = sanitizePreviewArgs(payload.args);
+  const [command, ...rest] = sanitizedArgs;
+  if (!command) {
+    throw new Error('Preview file does not include the original command.');
+  }
+  if (command !== expectedKind) {
+    throw new Error(`Preview command mismatch. Expected ${expectedKind}, got ${command}.`);
+  }
+
+  const replayArgs = [command, ...rest];
+  if (!replayArgs.some((arg) => arg === '--write' || arg.startsWith('--write='))) {
+    replayArgs.push('--write');
+  }
+  for (const extra of extraArgs) {
+    if (!replayArgs.includes(extra)) {
+      replayArgs.push(extra);
+    }
+  }
+
+  console.log(`Applying preview from ${path.relative(process.cwd(), path.resolve(previewPath))}…`);
+  await spawnCli(replayArgs);
+}
+
+function sanitizePreviewArgs(args: string[]): string[] {
+  const sanitized: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const token = args[i];
+    if (token === '--preview-output') {
+      i += 1;
+      continue;
+    }
+    if (token?.startsWith('--preview-output=')) {
+      continue;
+    }
+    sanitized.push(token);
+  }
+  return sanitized;
+}
+
+function spawnCli(args: string[]): Promise<void> {
+  const entry = process.argv[1];
+  if (!entry) {
+    return Promise.reject(new Error('Unable to determine CLI entry point for preview apply.'));
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.argv[0], [entry, ...args], {
+      stdio: 'inherit',
+    });
+
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Preview apply command exited with code ${code ?? 'unknown'}`));
+      }
+    });
+
+    child.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+function buildCommandString(): string {
+  // Ignore the node + script path, keep user arguments only
+  const args = process.argv.slice(2);
+  return args.length ? `i18nsmith ${args.join(' ')}` : 'i18nsmith';
+}