i18nsmith 0.1.9 → 0.2.1

package/src/commands/transform.ts

@@ -4,8 +4,9 @@ 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';
 
 interface TransformOptions {
   config?: string;
@@ -17,6 +18,8 @@ interface TransformOptions {
   diff?: boolean;
   patchDir?: string;
   migrateTextKeys?: boolean;
+  previewOutput?: string;
+  applyPreview?: string;
 }
 
 const collectTargetPatterns = (value: string | string[], previous: string[]) => {
@@ -29,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}).`
     )
   );
 
@@ -50,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}`));
@@ -70,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')
@@ -83,11 +164,30 @@ export function registerTransform(program: Command) {
     .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', collectTargetPatterns, [])
     .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) => {
+      if (options.applyPreview) {
+        await applyPreviewFile('transform', options.applyPreview);
+        return;
+      }
+
       const diffEnabled = Boolean(options.diff || options.patchDir);
-      console.log(
-        chalk.blue(options.write ? 'Running transform (write mode)...' : 'Planning transform (dry-run)...')
-      );
+      const previewMode = Boolean(options.previewOutput);
+      const diffRequested = diffEnabled || previewMode;
+      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;
+
+      const banner = previewMode
+        ? 'Generating transform preview...'
+        : writeEnabled
+        ? 'Running transform (write mode)...'
+        : 'Planning transform (dry-run)...';
+      console.log(chalk.blue(banner));
 
       try {
         const { config, projectRoot, configPath } = await loadConfigWithMeta(options.config);
@@ -100,12 +200,20 @@ 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: diffEnabled,
+          diff: diffRequested,
           migrateTextKeys: options.migrateTextKeys,
+          onProgress: progressLogger.emit,
         });
+        progressLogger.flush();
+
+        if (previewMode && options.previewOutput) {
+          const savedPath = await writePreviewFile('transform', summary, options.previewOutput);
+          console.log(chalk.green(`Preview written to ${path.relative(process.cwd(), savedPath)}`));
+        }
 
         if (options.report) {
           const outputPath = path.resolve(process.cwd(), options.report);

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', () => {
@@ -152,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/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.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']);
+  });
+});

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';
+}