i18nsmith 0.1.0

package/src/commands/backup.ts

@@ -0,0 +1,96 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { listBackups, restoreBackup } from '@i18nsmith/core';
+
+/**
+ * Registers backup-related commands (backup-list, backup-restore)
+ */
+export function registerBackup(program: Command): void {
+  program
+    .command('backup-list')
+    .description('List available locale file backups')
+    .option('--backup-dir <path>', 'Custom backup directory (default: .i18nsmith-backup)')
+    .action(async (options: { backupDir?: string }) => {
+      try {
+        const workspaceRoot = process.cwd();
+        const backups = await listBackups(workspaceRoot, { backupDir: options.backupDir });
+
+        if (backups.length === 0) {
+          console.log(chalk.yellow('No backups found.'));
+          console.log(chalk.gray('Backups are created automatically when using --write --prune'));
+          return;
+        }
+
+        console.log(chalk.blue(`Found ${backups.length} backup(s):\n`));
+
+        for (const backup of backups) {
+          const date = new Date(backup.createdAt);
+          const formattedDate = date.toLocaleString();
+          console.log(`  ${chalk.cyan(backup.timestamp)}  ${formattedDate}  (${backup.fileCount} files)`);
+        }
+
+        console.log(chalk.gray(`\nRestore a backup with: i18nsmith backup-restore <timestamp>`));
+      } catch (err) {
+        console.error(chalk.red('Error listing backups:'), err instanceof Error ? err.message : err);
+        process.exitCode = 1;
+      }
+    });
+
+  program
+    .command('backup-restore')
+    .description('Restore locale files from a previous backup')
+    .argument('<timestamp>', 'Backup timestamp (from backup-list) or "latest" for most recent')
+    .option('--backup-dir <path>', 'Custom backup directory (default: .i18nsmith-backup)')
+    .action(async (timestamp: string, options: { backupDir?: string }) => {
+      try {
+        const workspaceRoot = process.cwd();
+        const backups = await listBackups(workspaceRoot, { backupDir: options.backupDir });
+
+        if (backups.length === 0) {
+          console.error(chalk.red('No backups found.'));
+          process.exitCode = 1;
+          return;
+        }
+
+        let targetBackup = timestamp === 'latest'
+          ? backups[0]
+          : backups.find((b) => b.timestamp === timestamp);
+
+        if (!targetBackup) {
+          console.error(chalk.red(`Backup not found: ${timestamp}`));
+          console.log(chalk.gray('Available backups:'));
+          for (const b of backups.slice(0, 5)) {
+            console.log(`  ${b.timestamp}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        // Confirm restore
+        const { confirmed } = await inquirer.prompt<{ confirmed: boolean }>([
+          {
+            type: 'confirm',
+            name: 'confirmed',
+            message: `Restore ${targetBackup.fileCount} locale files from backup ${targetBackup.timestamp}? This will overwrite current locale files.`,
+            default: false,
+          },
+        ]);
+
+        if (!confirmed) {
+          console.log(chalk.yellow('Restore cancelled.'));
+          return;
+        }
+
+        const result = await restoreBackup(targetBackup.path, workspaceRoot);
+
+        console.log(chalk.green(`\n✅ ${result.summary}`));
+        for (const file of result.restored) {
+          console.log(chalk.gray(`   Restored: ${file}`));
+        }
+      } catch (err) {
+        console.error(chalk.red('Error restoring backup:'), err instanceof Error ? err.message : err);
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/check.ts

@@ -0,0 +1,191 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import type { Command } from 'commander';
+import { loadConfigWithMeta, CheckRunner } from '@i18nsmith/core';
+import type { CheckSummary } from '@i18nsmith/core';
+import { printLocaleDiffs } from '../utils/diff-utils.js';
+import { getDiagnosisExitSignal } from '../utils/diagnostics-exit.js';
+import { CHECK_EXIT_CODES } from '../utils/exit-codes.js';
+
+interface CheckCommandOptions {
+  config?: string;
+  json?: boolean;
+  target?: string[];
+  report?: string;
+  listFiles?: boolean;
+  include?: string[];
+  exclude?: string[];
+  failOn?: 'none' | 'conflicts' | 'warnings';
+  assume?: string[];
+  assumeGlobs?: string[];
+  validateInterpolations?: boolean;
+  emptyValues?: boolean;
+  diff?: boolean;
+  invalidateCache?: boolean;
+  preferDiagnosticsExit?: boolean;
+}
+
+const collectAssumedKeys = (value: string, previous: string[]) => {
+  const tokens = value
+    .split(',')
+    .map((token) => token.trim())
+    .filter(Boolean);
+  return [...previous, ...tokens];
+};
+
+const collectTargetPatterns = (value: string | string[], previous: string[]) => {
+  const list = Array.isArray(value) ? value : [value];
+  const tokens = list
+    .flatMap((entry) => entry.split(','))
+    .map((token) => token.trim())
+    .filter(Boolean);
+  return [...previous, ...tokens];
+};
+
+function printCheckSummary(summary: CheckSummary) {
+  const report = summary.diagnostics;
+  console.log(chalk.green(`Locales directory: ${report.localesDir}`));
+  console.log(
+    chalk.gray(
+      `Detected locales: ${report.detectedLocales.length ? report.detectedLocales.join(', ') : 'none'}`
+    )
+  );
+  console.log(
+    chalk.gray(
+      `Runtime packages: ${report.runtimePackages.length ? report.runtimePackages.map((pkg) => pkg.name).join(', ') : 'none'}`
+    )
+  );
+  console.log(
+    chalk.gray(
+      `Translation references scanned: ${summary.sync.references.length} across ${summary.sync.filesScanned} file${summary.sync.filesScanned === 1 ? '' : 's'}`
+    )
+  );
+
+  if (summary.actionableItems.length) {
+    console.log(chalk.blue('\nActionable items'));
+    summary.actionableItems.slice(0, 25).forEach((item) => {
+      const label = formatSeverityLabel(item.severity);
+      console.log(`  • [${label}] ${item.message}`);
+    });
+    if (summary.actionableItems.length > 25) {
+      console.log(chalk.gray(`  ...and ${summary.actionableItems.length - 25} more.`));
+    }
+  } else {
+    console.log(chalk.green('\nNo actionable issues detected.'));
+  }
+
+  if (summary.suggestedCommands.length) {
+    console.log(chalk.blue('\nSuggested commands'));
+    summary.suggestedCommands.forEach((suggestion) => {
+      const label = formatSeverityLabel(suggestion.severity);
+      console.log(`  • [${label}] ${suggestion.label}`);
+      console.log(`      ${chalk.cyan(suggestion.command)}`);
+      console.log(chalk.gray(`      ${suggestion.reason}`));
+    });
+  } else {
+    console.log(chalk.gray('\nNo automated suggestions—review actionable items above.'));
+  }
+}
+
+function formatSeverityLabel(severity: 'info' | 'warn' | 'error'): string {
+  if (severity === 'error') {
+    return chalk.red('ERROR');
+  }
+  if (severity === 'warn') {
+    return chalk.yellow('WARN');
+  }
+  return chalk.cyan('INFO');
+}
+
+export function registerCheck(program: Command) {
+  program
+    .command('check')
+    .description('Run diagnostics plus a sync dry-run for a consolidated health report')
+    .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('--fail-on <level>', 'Failure threshold: none | conflicts | warnings', 'conflicts')
+    .option('--assume <keys...>', 'List of runtime keys to assume (comma-separated)', collectAssumedKeys, [])
+    .option('--assume-globs <patterns...>', 'Glob patterns for dynamic key namespaces (e.g., errors.*, navigation.**)', collectTargetPatterns, [])
+    .option('--validate-interpolations', 'Validate interpolation placeholders across locales', false)
+    .option('--no-empty-values', 'Treat empty or placeholder locale values as failures')
+    .option('--diff', 'Include locale diff previews for missing/unused key fixes', false)
+    .option('--invalidate-cache', 'Ignore cached sync analysis and rescan all source files', false)
+    .option('--target <pattern...>', 'Limit translation reference scanning to specific files or patterns', collectTargetPatterns, [])
+    .option('--prefer-diagnostics-exit', 'Prefer diagnostics exit codes when --fail-on=conflicts and blocking conflicts exist', false)
+    .action(async (options: CheckCommandOptions) => {
+      console.log(chalk.blue('Running guided repository health check...'));
+      try {
+        const { config, projectRoot, configPath } = await loadConfigWithMeta(options.config);
+        
+        // Inform user if config was found in a parent directory
+        const cwd = process.cwd();
+        if (projectRoot !== cwd) {
+          console.log(chalk.gray(`Config found at ${path.relative(cwd, configPath)}`));
+          console.log(chalk.gray(`Using project root: ${projectRoot}\n`));
+        }
+        
+        // Merge --assume-globs with config
+        if (options.assumeGlobs?.length) {
+          config.sync = config.sync ?? {};
+          config.sync.dynamicKeyGlobs = [
+            ...(config.sync.dynamicKeyGlobs ?? []),
+            ...options.assumeGlobs,
+          ];
+        }
+        const runner = new CheckRunner(config, { workspaceRoot: projectRoot });
+        const summary = await runner.run({
+          assumedKeys: options.assume,
+          validateInterpolations: options.validateInterpolations,
+          emptyValuePolicy: options.emptyValues === false ? 'fail' : undefined,
+          diff: options.diff,
+          targets: options.target,
+          invalidateCache: options.invalidateCache,
+        });
+
+        if (options.report) {
+          const outputPath = path.resolve(process.cwd(), options.report);
+          await fs.mkdir(path.dirname(outputPath), { recursive: true });
+          await fs.writeFile(outputPath, JSON.stringify(summary, null, 2));
+          console.log(chalk.green(`Health report written to ${outputPath}`));
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify(summary, null, 2));
+        } else {
+          printCheckSummary(summary);
+          if (options.diff) {
+            printLocaleDiffs(summary.sync.diffs);
+          }
+        }
+
+        // If diagnostics discovered blocking conflicts, prefer the diagnostics' exit
+        // signal so CI can branch on specific failure modes (missing source locale,
+        // invalid JSON, etc.). This mirrors `i18nsmith diagnose` behavior.
+        // Only when --prefer-diagnostics-exit is true and --fail-on=conflicts.
+        const diagExit = getDiagnosisExitSignal(summary.diagnostics);
+        if (diagExit && options.preferDiagnosticsExit && options.failOn === 'conflicts') {
+          console.error(chalk.red(`\nBlocking diagnostic conflict detected: ${diagExit.reason}`));
+          console.error(chalk.red(`Exit code ${diagExit.code}`));
+          process.exitCode = diagExit.code;
+          return;
+        }
+
+        const failMode = (options.failOn ?? 'conflicts').toLowerCase();
+        const hasErrors = summary.actionableItems.some((item) => item.severity === 'error');
+        const hasWarnings = summary.actionableItems.some((item) => item.severity === 'warn');
+
+        if (failMode === 'conflicts' && hasErrors) {
+          console.error(chalk.red('\nBlocking issues detected. Resolve the actionable errors above.'));
+          process.exitCode = CHECK_EXIT_CODES.CONFLICTS;
+        } else if (failMode === 'warnings' && (hasErrors || hasWarnings)) {
+          console.error(chalk.red('\nWarnings detected. Use --fail-on conflicts to limit failures to blocking issues.'));
+          process.exitCode = CHECK_EXIT_CODES.WARNINGS;
+        }
+      } catch (error) {
+        console.error(chalk.red('Check failed:'), (error as Error).message);
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/config.ts

@@ -0,0 +1,263 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import type { Command } from 'commander';
+import { loadConfigWithMeta, DEFAULT_CONFIG_FILENAME } from '@i18nsmith/core';
+
+interface ConfigCommandOptions {
+  config?: string;
+  json?: boolean;
+}
+
+interface ConfigSetOptions extends ConfigCommandOptions {
+  key: string;
+  value: string;
+}
+
+interface ConfigGetOptions extends ConfigCommandOptions {
+  key: string;
+}
+
+/**
+ * Parse a dot-notation key path into segments.
+ * e.g., 'translationAdapter.module' => ['translationAdapter', 'module']
+ */
+function parseKeyPath(keyPath: string): string[] {
+  return keyPath.split('.').filter(Boolean);
+}
+
+/**
+ * Get a nested value from an object using a key path.
+ */
+function getNestedValue(obj: Record<string, unknown>, keyPath: string[]): unknown {
+  let current: unknown = obj;
+  for (const key of keyPath) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[key];
+  }
+  return current;
+}
+
+/**
+ * Set a nested value in an object using a key path.
+ * Creates intermediate objects as needed.
+ */
+function setNestedValue(obj: Record<string, unknown>, keyPath: string[], value: unknown): void {
+  let current = obj;
+  for (let i = 0; i < keyPath.length - 1; i++) {
+    const key = keyPath[i];
+    if (!(key in current) || typeof current[key] !== 'object' || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key] as Record<string, unknown>;
+  }
+  const finalKey = keyPath[keyPath.length - 1];
+  current[finalKey] = value;
+}
+
+/**
+ * Parse a value string into an appropriate type.
+ * Handles booleans, numbers, arrays, and strings.
+ */
+function parseValue(valueStr: string): unknown {
+  // Boolean
+  if (valueStr === 'true') return true;
+  if (valueStr === 'false') return false;
+  
+  // Null
+  if (valueStr === 'null') return null;
+  
+  // Number
+  if (/^-?\d+(\.\d+)?$/.test(valueStr)) {
+    return parseFloat(valueStr);
+  }
+  
+  // JSON array or object
+  if ((valueStr.startsWith('[') && valueStr.endsWith(']')) ||
+      (valueStr.startsWith('{') && valueStr.endsWith('}'))) {
+    try {
+      return JSON.parse(valueStr);
+    } catch {
+      // Fall through to string
+    }
+  }
+  
+  // Remove surrounding quotes if present
+  if ((valueStr.startsWith('"') && valueStr.endsWith('"')) ||
+      (valueStr.startsWith("'") && valueStr.endsWith("'"))) {
+    return valueStr.slice(1, -1);
+  }
+  
+  return valueStr;
+}
+
+/**
+ * Read the raw config file content (unparsed JSON with comments preserved formatting).
+ */
+async function readRawConfig(configPath: string): Promise<{ content: string; parsed: Record<string, unknown> }> {
+  const content = await fs.readFile(configPath, 'utf-8');
+  const parsed = JSON.parse(content);
+  return { content, parsed };
+}
+
+/**
+ * Write config back to file with nice formatting.
+ */
+async function writeConfig(configPath: string, config: Record<string, unknown>): Promise<void> {
+  const content = JSON.stringify(config, null, 2);
+  await fs.writeFile(configPath, content, 'utf-8');
+}
+
+export function registerConfig(program: Command) {
+  const configCmd = program
+    .command('config')
+    .description('View or modify i18nsmith configuration');
+
+  // Subcommand: config get <key>
+  configCmd
+    .command('get <key>')
+    .description('Get a configuration value by key path (e.g., translationAdapter.module)')
+    .option('-c, --config <path>', 'Path to i18nsmith config file', DEFAULT_CONFIG_FILENAME)
+    .option('--json', 'Output as JSON', false)
+    .action(async (key: string, options: ConfigGetOptions) => {
+      try {
+        const { config, configPath } = await loadConfigWithMeta(options.config);
+        const keyPath = parseKeyPath(key);
+        const value = getNestedValue(config as unknown as Record<string, unknown>, keyPath);
+
+        if (value === undefined) {
+          console.log(chalk.yellow(`Key "${key}" not found in config`));
+          process.exitCode = 1;
+          return;
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify({ key, value }, null, 2));
+        } else {
+          if (typeof value === 'object' && value !== null) {
+            console.log(JSON.stringify(value, null, 2));
+          } else {
+            console.log(String(value));
+          }
+        }
+      } catch (error) {
+        console.error(chalk.red('Failed to get config:'), (error as Error).message);
+        process.exitCode = 1;
+      }
+    });
+
+  // Subcommand: config set <key> <value>
+  configCmd
+    .command('set <key> <value>')
+    .description('Set a configuration value by key path (e.g., translationAdapter.module "src/i18n.ts")')
+    .option('-c, --config <path>', 'Path to i18nsmith config file', DEFAULT_CONFIG_FILENAME)
+    .option('--json', 'Output result as JSON', false)
+    .action(async (key: string, value: string, options: ConfigSetOptions) => {
+      try {
+        const { configPath } = await loadConfigWithMeta(options.config);
+        const { parsed } = await readRawConfig(configPath);
+        
+        const keyPath = parseKeyPath(key);
+        const parsedValue = parseValue(value);
+        
+        setNestedValue(parsed, keyPath, parsedValue);
+        
+        await writeConfig(configPath, parsed);
+
+        if (options.json) {
+          console.log(JSON.stringify({ key, value: parsedValue, configPath }, null, 2));
+        } else {
+          console.log(chalk.green(`✓ Set ${key} = ${JSON.stringify(parsedValue)}`));
+          console.log(chalk.dim(`  Updated: ${configPath}`));
+        }
+      } catch (error) {
+        console.error(chalk.red('Failed to set config:'), (error as Error).message);
+        process.exitCode = 1;
+      }
+    });
+
+  // Subcommand: config list
+  configCmd
+    .command('list')
+    .description('List all configuration values')
+    .option('-c, --config <path>', 'Path to i18nsmith config file', DEFAULT_CONFIG_FILENAME)
+    .option('--json', 'Output as JSON', false)
+    .action(async (options: ConfigCommandOptions) => {
+      try {
+        const { config, configPath } = await loadConfigWithMeta(options.config);
+
+        if (options.json) {
+          console.log(JSON.stringify(config, null, 2));
+        } else {
+          console.log(chalk.blue(`Configuration from: ${configPath}`));
+          console.log();
+          console.log(JSON.stringify(config, null, 2));
+        }
+      } catch (error) {
+        console.error(chalk.red('Failed to read config:'), (error as Error).message);
+        process.exitCode = 1;
+      }
+    });
+
+  // Subcommand: config path
+  configCmd
+    .command('path')
+    .description('Print the path to the active config file')
+    .option('-c, --config <path>', 'Path to i18nsmith config file', DEFAULT_CONFIG_FILENAME)
+    .action(async (options: ConfigCommandOptions) => {
+      try {
+        const { configPath } = await loadConfigWithMeta(options.config);
+        console.log(configPath);
+      } catch (error) {
+        console.error(chalk.red('Failed to find config:'), (error as Error).message);
+        process.exitCode = 1;
+      }
+    });
+
+  // Subcommand: config init-adapter <path>
+  configCmd
+    .command('init-adapter <adapterPath>')
+    .description('Configure a translation adapter module in the config file')
+    .option('-c, --config <path>', 'Path to i18nsmith config file', DEFAULT_CONFIG_FILENAME)
+    .option('--hook <name>', 'Name of the translation hook (default: useTranslation)', 'useTranslation')
+    .option('--json', 'Output result as JSON', false)
+    .action(async (adapterPath: string, options: { config?: string; hook: string; json?: boolean }) => {
+      try {
+        const { configPath } = await loadConfigWithMeta(options.config);
+        const { parsed } = await readRawConfig(configPath);
+
+        // Resolve relative path
+        const projectRoot = path.dirname(configPath);
+        const relativePath = path.isAbsolute(adapterPath)
+          ? path.relative(projectRoot, adapterPath)
+          : adapterPath;
+
+        // Update translationAdapter
+        if (!parsed.translationAdapter || typeof parsed.translationAdapter !== 'object') {
+          parsed.translationAdapter = {};
+        }
+        const adapter = parsed.translationAdapter as Record<string, unknown>;
+        adapter.module = relativePath;
+        adapter.hookName = options.hook;
+
+        await writeConfig(configPath, parsed);
+
+        if (options.json) {
+          console.log(JSON.stringify({
+            translationAdapter: parsed.translationAdapter,
+            configPath,
+          }, null, 2));
+        } else {
+          console.log(chalk.green('✓ Translation adapter configured:'));
+          console.log(chalk.dim(`  module: ${relativePath}`));
+          console.log(chalk.dim(`  hookName: ${options.hook}`));
+          console.log(chalk.dim(`  Updated: ${configPath}`));
+        }
+      } catch (error) {
+        console.error(chalk.red('Failed to configure adapter:'), (error as Error).message);
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/debug-patterns.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, 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';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CLI_PATH = path.resolve(__dirname, '../../dist/index.js');
+
+function runCli(args: string[], options: { cwd?: string } = {}) {
+  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,
+  };
+}
+
+describe('debug-patterns command', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'i18nsmith-debug-patterns-'));
+    
+    // Create a basic config
+    const config = {
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      localesDir: 'locales',
+      include: ['src/**/*.tsx', 'src/**/*.ts'],
+      exclude: ['**/*.test.ts', '**/node_modules/**'],
+    };
+    await fs.writeFile(path.join(tmpDir, 'i18n.config.json'), JSON.stringify(config, null, 2));
+    
+    // Create some source files
+    await fs.mkdir(path.join(tmpDir, 'src'));
+    await fs.writeFile(path.join(tmpDir, 'src', 'App.tsx'), 'export function App() { return <div>Hello</div>; }');
+    await fs.writeFile(path.join(tmpDir, 'src', 'utils.ts'), 'export const add = (a: number, b: number) => a + b;');
+    await fs.writeFile(path.join(tmpDir, 'src', 'utils.test.ts'), 'test("add", () => expect(add(1, 2)).toBe(3));');
+    
+    // Create locales directory
+    await fs.mkdir(path.join(tmpDir, 'locales'));
+    await fs.writeFile(path.join(tmpDir, 'locales', 'en.json'), '{}');
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should show include patterns with file counts', () => {
+    const result = runCli(['debug-patterns'], { cwd: tmpDir });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.output).toContain('Include Patterns');
+    expect(result.output).toContain('src/**/*.tsx');
+    expect(result.output).toContain('src/**/*.ts');
+  });
+
+  it('should show exclude patterns', () => {
+    const result = runCli(['debug-patterns'], { cwd: tmpDir });
+
+    expect(result.output).toContain('Exclude Patterns');
+    expect(result.output).toContain('**/*.test.ts');
+  });
+
+  it('should show summary with effective file count', () => {
+    const result = runCli(['debug-patterns'], { cwd: tmpDir });
+
+    expect(result.output).toContain('Summary');
+    expect(result.output).toContain('Effective files to scan');
+  });
+
+  it('should list files in verbose mode', () => {
+    const result = runCli(['debug-patterns', '--verbose'], { cwd: tmpDir });
+
+    expect(result.output).toContain('App.tsx');
+    expect(result.output).toContain('utils.ts');
+  });
+
+  it('should output JSON when --json flag is used', () => {
+    const result = runCli(['debug-patterns', '--json'], { cwd: tmpDir });
+
+    // Extract JSON from output
+    const jsonMatch = result.stdout.match(/\{[\s\S]*\}/);
+    expect(jsonMatch).not.toBeNull();
+    
+    const parsed = JSON.parse(jsonMatch![0]);
+    expect(parsed).toHaveProperty('includePatterns');
+    expect(parsed).toHaveProperty('excludePatterns');
+    expect(parsed).toHaveProperty('effectiveFiles');
+    expect(Array.isArray(parsed.effectiveFiles)).toBe(true);
+  });
+
+  it('should detect unmatched patterns and suggest fixes', async () => {
+    // Update config with a pattern that won't match
+    const config = {
+      sourceLanguage: 'en',
+      targetLanguages: ['fr'],
+      localesDir: 'locales',
+      include: ['app/**/*.tsx', 'src/**/*.tsx'],  // app/ doesn't exist
+      exclude: ['**/node_modules/**'],
+    };
+    await fs.writeFile(path.join(tmpDir, 'i18n.config.json'), JSON.stringify(config, null, 2));
+
+    const result = runCli(['debug-patterns'], { cwd: tmpDir });
+
+    // Should show the pattern that matched 0 files
+    expect(result.output).toContain('app/**/*.tsx');
+    expect(result.output).toContain('0 file(s)');
+  });
+
+  it('should handle missing config gracefully', async () => {
+    await fs.rm(path.join(tmpDir, 'i18n.config.json'));
+
+    const result = runCli(['debug-patterns'], { cwd: tmpDir });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.output).toContain('failed');
+  });
+});