i18nsmith 0.1.0

package/src/commands/debug-patterns.ts

@@ -0,0 +1,257 @@
+import path from 'path';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import fg from 'fast-glob';
+import { loadConfigWithMeta } from '@i18nsmith/core';
+
+interface DebugPatternsOptions {
+  config?: string;
+  json?: boolean;
+  verbose?: boolean;
+}
+
+interface PatternMatch {
+  pattern: string;
+  type: 'include' | 'exclude';
+  matchedFiles: string[];
+  matchCount: number;
+}
+
+interface DebugPatternsSummary {
+  projectRoot: string;
+  includePatterns: PatternMatch[];
+  excludePatterns: PatternMatch[];
+  totalIncluded: number;
+  totalExcluded: number;
+  effectiveFiles: string[];
+  unmatchedSuggestions: string[];
+}
+
+export function registerDebugPatterns(program: Command) {
+  program
+    .command('debug-patterns')
+    .description('Debug include/exclude glob patterns to understand file matching')
+    .option('-c, --config <path>', 'Path to i18nsmith config file', 'i18n.config.json')
+    .option('--json', 'Print raw JSON results', false)
+    .option('--verbose', 'Show all matched files for each pattern', false)
+    .action(async (options: DebugPatternsOptions) => {
+      try {
+        const { config, projectRoot, configPath } = await loadConfigWithMeta(options.config);
+        
+        console.log(chalk.blue('Debugging glob patterns...'));
+        console.log(chalk.gray(`Config: ${path.relative(process.cwd(), configPath)}`));
+        console.log(chalk.gray(`Project root: ${projectRoot}\n`));
+
+        const includePatterns = config.include ?? ['**/*.tsx', '**/*.ts', '**/*.jsx', '**/*.js'];
+        const excludePatterns = config.exclude ?? ['**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*'];
+
+        const summary = await analyzePatterns(projectRoot, includePatterns, excludePatterns, options.verbose);
+
+        if (options.json) {
+          console.log(JSON.stringify(summary, null, 2));
+          return;
+        }
+
+        printPatternAnalysis(summary, options.verbose);
+      } catch (error) {
+        console.error(chalk.red('Pattern debug failed:'), (error as Error).message);
+        process.exitCode = 1;
+      }
+    });
+}
+
+async function analyzePatterns(
+  projectRoot: string,
+  includePatterns: string[],
+  excludePatterns: string[],
+  verbose?: boolean
+): Promise<DebugPatternsSummary> {
+  const includeMatches: PatternMatch[] = [];
+  const excludeMatches: PatternMatch[] = [];
+
+  // Analyze each include pattern individually
+  for (const pattern of includePatterns) {
+    const files = await fg(pattern, {
+      cwd: projectRoot,
+      ignore: ['**/node_modules/**'],
+      onlyFiles: true,
+      absolute: false,
+    });
+    includeMatches.push({
+      pattern,
+      type: 'include',
+      matchedFiles: files.sort(),
+      matchCount: files.length,
+    });
+  }
+
+  // Analyze each exclude pattern individually
+  for (const pattern of excludePatterns) {
+    const files = await fg(pattern, {
+      cwd: projectRoot,
+      onlyFiles: true,
+      absolute: false,
+    });
+    excludeMatches.push({
+      pattern,
+      type: 'exclude',
+      matchedFiles: files.sort(),
+      matchCount: files.length,
+    });
+  }
+
+  // Calculate effective files (include - exclude)
+  const allIncluded = new Set<string>();
+  for (const match of includeMatches) {
+    for (const file of match.matchedFiles) {
+      allIncluded.add(file);
+    }
+  }
+
+  const allExcluded = new Set<string>();
+  for (const match of excludeMatches) {
+    for (const file of match.matchedFiles) {
+      allExcluded.add(file);
+    }
+  }
+
+  const effectiveFiles = Array.from(allIncluded)
+    .filter(file => !allExcluded.has(file))
+    .sort();
+
+  // Generate suggestions for unmatched patterns
+  const suggestions = generateSuggestions(includeMatches, excludeMatches, projectRoot);
+
+  return {
+    projectRoot,
+    includePatterns: includeMatches,
+    excludePatterns: excludeMatches,
+    totalIncluded: allIncluded.size,
+    totalExcluded: allExcluded.size,
+    effectiveFiles,
+    unmatchedSuggestions: suggestions,
+  };
+}
+
+function generateSuggestions(
+  includeMatches: PatternMatch[],
+  excludeMatches: PatternMatch[],
+  projectRoot: string
+): string[] {
+  const suggestions: string[] = [];
+
+  // Check for patterns with no matches
+  for (const match of includeMatches) {
+    if (match.matchCount === 0) {
+      const suggestion = suggestPatternFix(match.pattern, projectRoot);
+      if (suggestion) {
+        suggestions.push(`Include pattern "${match.pattern}" matched 0 files. ${suggestion}`);
+      } else {
+        suggestions.push(`Include pattern "${match.pattern}" matched 0 files. Check if files exist or adjust the pattern.`);
+      }
+    }
+  }
+
+  // Check if excludes are too broad
+  const totalIncluded = includeMatches.reduce((sum, m) => sum + m.matchCount, 0);
+  const totalExcluded = excludeMatches.reduce((sum, m) => sum + m.matchCount, 0);
+  
+  if (totalExcluded > totalIncluded * 0.9 && totalIncluded > 0) {
+    suggestions.push('Warning: Exclude patterns are filtering out most files. Consider narrowing exclusions.');
+  }
+
+  // Check for common pattern mistakes
+  for (const match of includeMatches) {
+    if (match.pattern.startsWith('/')) {
+      suggestions.push(`Pattern "${match.pattern}" starts with "/" which may not match relative paths. Try "${match.pattern.slice(1)}".`);
+    }
+    if (match.pattern.includes('\\')) {
+      suggestions.push(`Pattern "${match.pattern}" contains backslashes. Use forward slashes "/" for glob patterns.`);
+    }
+  }
+
+  return suggestions;
+}
+
+function suggestPatternFix(pattern: string, projectRoot: string): string | null {
+  // Common fixes for patterns that don't match
+  
+  // If pattern is like "src/**/*.tsx" but files are in "app/**/*.tsx"
+  if (pattern.startsWith('src/')) {
+    return 'Try "app/**/*" or check your source directory structure.';
+  }
+  
+  // If pattern uses .tsx but project has .jsx
+  if (pattern.includes('.tsx')) {
+    return 'Try replacing ".tsx" with ".jsx" if using JavaScript.';
+  }
+  
+  // If pattern uses double asterisk incorrectly
+  if (pattern.includes('/**') && !pattern.includes('/**/')) {
+    return 'Use "**/" for recursive matching (e.g., "src/**/*.tsx").';
+  }
+
+  return null;
+}
+
+function printPatternAnalysis(summary: DebugPatternsSummary, verbose?: boolean) {
+  console.log(chalk.blue('📁 Include Patterns\n'));
+  
+  for (const match of summary.includePatterns) {
+    const status = match.matchCount > 0 ? chalk.green('✓') : chalk.red('✗');
+    console.log(`  ${status} ${chalk.cyan(match.pattern)} → ${match.matchCount} file(s)`);
+    
+    if (verbose && match.matchCount > 0) {
+      const preview = match.matchedFiles.slice(0, 10);
+      preview.forEach(file => console.log(chalk.gray(`      • ${file}`)));
+      if (match.matchedFiles.length > 10) {
+        console.log(chalk.gray(`      ... and ${match.matchedFiles.length - 10} more`));
+      }
+    }
+  }
+
+  console.log(chalk.blue('\n🚫 Exclude Patterns\n'));
+  
+  for (const match of summary.excludePatterns) {
+    const status = match.matchCount > 0 ? chalk.yellow('⚠') : chalk.gray('○');
+    console.log(`  ${status} ${chalk.cyan(match.pattern)} → ${match.matchCount} file(s)`);
+    
+    if (verbose && match.matchCount > 0) {
+      const preview = match.matchedFiles.slice(0, 5);
+      preview.forEach(file => console.log(chalk.gray(`      • ${file}`)));
+      if (match.matchedFiles.length > 5) {
+        console.log(chalk.gray(`      ... and ${match.matchedFiles.length - 5} more`));
+      }
+    }
+  }
+
+  console.log(chalk.blue('\n📊 Summary\n'));
+  console.log(`  Total matched by include patterns: ${summary.totalIncluded}`);
+  console.log(`  Total matched by exclude patterns: ${summary.totalExcluded}`);
+  console.log(chalk.green(`  Effective files to scan: ${summary.effectiveFiles.length}`));
+
+  if (verbose && summary.effectiveFiles.length > 0) {
+    console.log(chalk.blue('\n📄 Effective Files (first 20)\n'));
+    summary.effectiveFiles.slice(0, 20).forEach(file => {
+      console.log(chalk.gray(`  • ${file}`));
+    });
+    if (summary.effectiveFiles.length > 20) {
+      console.log(chalk.gray(`  ... and ${summary.effectiveFiles.length - 20} more`));
+    }
+  }
+
+  if (summary.unmatchedSuggestions.length > 0) {
+    console.log(chalk.yellow('\n💡 Suggestions\n'));
+    summary.unmatchedSuggestions.forEach(suggestion => {
+      console.log(chalk.yellow(`  • ${suggestion}`));
+    });
+  }
+
+  if (summary.effectiveFiles.length === 0) {
+    console.log(chalk.red('\n⚠️  No files will be scanned! Check your patterns.'));
+    console.log(chalk.gray('  Common issues:'));
+    console.log(chalk.gray('  • Include patterns don\'t match your source directory'));
+    console.log(chalk.gray('  • Exclude patterns are too broad'));
+    console.log(chalk.gray('  • File extensions don\'t match (.tsx vs .jsx, .ts vs .js)'));
+  }
+}

package/src/commands/diagnose.ts

@@ -0,0 +1,136 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import type { Command } from 'commander';
+import { loadConfig, diagnoseWorkspace } from '@i18nsmith/core';
+import type { DiagnosisReport } from '@i18nsmith/core';
+import { getDiagnosisExitSignal } from '../utils/diagnostics-exit.js';
+
+interface DiagnoseCommandOptions {
+  config?: string;
+  json?: boolean;
+  report?: string;
+}
+
+function printDiagnosisReport(report: DiagnosisReport) {
+  console.log(chalk.green(`Locales directory: ${report.localesDir}`));
+
+  console.log(chalk.blue('\nLocales'));
+  if (report.localeFiles.length === 0) {
+    console.log(chalk.yellow('  • No locale files detected.'));
+  } else {
+    for (const entry of report.localeFiles) {
+      const relPath = path.relative(process.cwd(), entry.path);
+      const status = entry.missing
+        ? chalk.red('missing')
+        : entry.parseError
+        ? chalk.red('invalid JSON')
+        : `${entry.keyCount} keys`;
+      console.log(`  • ${entry.locale} — ${status}${entry.missing ? '' : ` (${relPath})`}`);
+    }
+  }
+
+  console.log(chalk.blue('\nRuntime packages'));
+  if (report.runtimePackages.length === 0) {
+    console.log(chalk.yellow('  • None detected in package.json.'));
+  } else {
+    for (const pkg of report.runtimePackages) {
+      console.log(`  • ${pkg.name}@${pkg.version ?? 'latest'} (${pkg.source})`);
+    }
+  }
+
+  console.log(chalk.blue('\nProvider candidates'));
+  if (report.providerFiles.length === 0) {
+    console.log(chalk.gray('  • No provider files discovered.'));
+  } else {
+    for (const provider of report.providerFiles) {
+      const flags: string[] = [];
+      if (provider.frameworkHint !== 'unknown') {
+        flags.push(provider.frameworkHint);
+      }
+      if (provider.hasI18nProvider) {
+        flags.push('wraps <I18nProvider>');
+      }
+      if (provider.usesTranslationHook) {
+        flags.push('imports translation hook');
+      }
+      const flagLabel = flags.length ? ` (${flags.join(', ')})` : '';
+      console.log(`  • ${provider.relativePath}${flagLabel}`);
+    }
+  }
+
+  console.log(chalk.blue('\nTranslation usage'));
+  console.log(
+    `  • Files scanned: ${report.translationUsage.filesExamined} — ` +
+      `${report.translationUsage.hookOccurrences} ${report.translationUsage.hookName} hooks, ` +
+      `${report.translationUsage.identifierOccurrences} ${report.translationUsage.translationIdentifier}() calls`
+  );
+
+  if (report.translationUsage.hookExampleFiles.length) {
+    console.log(
+      chalk.gray(`    Examples: ${report.translationUsage.hookExampleFiles.concat(report.translationUsage.identifierExampleFiles).slice(0, 5).join(', ')}`)
+    );
+  }
+
+  if (report.actionableItems.length) {
+    console.log(chalk.blue('\nActionable items'));
+    for (const item of report.actionableItems) {
+      const label = item.severity === 'error' ? chalk.red('ERROR') : item.severity === 'warn' ? chalk.yellow('WARN') : chalk.cyan('INFO');
+      console.log(`  • [${label}] ${item.message}`);
+    }
+  }
+
+  if (report.recommendations.length) {
+    console.log(chalk.blue('\nRecommendations'));
+    for (const rec of report.recommendations) {
+      console.log(`  • ${rec}`);
+    }
+  }
+
+  if (report.conflicts.length) {
+    console.log(chalk.red('\nConflicts'));
+    for (const conflict of report.conflicts) {
+      const files = conflict.files?.length ? ` (${conflict.files.join(', ')})` : '';
+      console.log(`  • ${conflict.message}${files}`);
+    }
+  }
+}
+
+export function registerDiagnose(program: Command) {
+  program
+    .command('diagnose')
+    .description('Detect existing i18n assets and potential merge conflicts')
+    .option('-c, --config <path>', 'Path to i18nsmith config file', 'i18n.config.json')
+    .option('--json', 'Print raw JSON results', false)
+    .option('--report <path>', 'Write JSON report to a file (for CI or editors)')
+    .action(async (options: DiagnoseCommandOptions) => {
+      console.log(chalk.blue('Running repository diagnostics...'));
+      try {
+        const config = await loadConfig(options.config);
+        const report = await diagnoseWorkspace(config);
+
+        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(report, null, 2));
+          console.log(chalk.green(`Diagnosis report written to ${outputPath}`));
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify(report, null, 2));
+        } else {
+          printDiagnosisReport(report);
+        }
+
+        const exitSignal = getDiagnosisExitSignal(report);
+        if (exitSignal) {
+          console.error(chalk.red(`\nBlocking conflicts detected (${report.conflicts.length}).`));
+          console.error(chalk.red(`Exit code ${exitSignal.code}: ${exitSignal.reason}`));
+          process.exitCode = exitSignal.code;
+        }
+      } catch (error) {
+        console.error(chalk.red('Diagnose failed:'), (error as Error).message);
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/init.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Command } from 'commander';
+import { registerInit, parseGlobList } from './init.js';
+
+vi.mock('@i18nsmith/core', () => ({
+  diagnoseWorkspace: vi.fn().mockResolvedValue({
+    localesDir: 'locales',
+    localeFiles: [],
+    detectedLocales: [],
+    runtimePackages: [],
+    providerFiles: [],
+    adapterFiles: [],
+    translationUsage: {
+      hookName: 'useTranslation',
+      translationIdentifier: 't',
+      filesExamined: 0,
+      hookOccurrences: 0,
+      identifierOccurrences: 0,
+      hookExampleFiles: [],
+      identifierExampleFiles: [],
+    },
+    actionableItems: [],
+    conflicts: [],
+    recommendations: [],
+  }),
+}));
+
+vi.mock('inquirer', () => ({
+  default: {
+    prompt: vi.fn().mockResolvedValue({
+      sourceLanguage: 'en',
+      adapter: 'custom',
+      localesDir: 'locales',
+    }),
+  },
+}));
+
+vi.mock('fs/promises', () => ({
+  default: {
+    writeFile: vi.fn().mockResolvedValue(undefined),
+    mkdir: vi.fn().mockResolvedValue(undefined),
+  },
+}));
+
+describe('init command', () => {
+  it('should register the init command', () => {
+    const program = new Command();
+    registerInit(program);
+    const command = program.commands.find((cmd) => cmd.name() === 'init');
+    expect(command).toBeDefined();
+  });
+});
+
+describe('parseGlobList', () => {
+  it('treats brace-expanded globs as atomic tokens', () => {
+    const input = 'src/**/*.{ts,tsx,js,jsx}, app/**/*.{ts,tsx}';
+    expect(parseGlobList(input)).toEqual([
+      'src/**/*.{ts,tsx,js,jsx}',
+      'app/**/*.{ts,tsx}',
+    ]);
+  });
+
+  it('handles nested braces', () => {
+    const input = 'src/**/*.{ts,tsx,{spec,test}.ts}';
+    expect(parseGlobList(input)).toEqual(['src/**/*.{ts,tsx,{spec,test}.ts}']);
+  });
+
+  it('splits simple comma-separated values', () => {
+    const input = 'en, fr, es';
+    expect(parseGlobList(input)).toEqual(['en', 'fr', 'es']);
+  });
+
+  it('handles empty input', () => {
+    expect(parseGlobList('')).toEqual([]);
+    expect(parseGlobList('   ')).toEqual([]);
+  });
+
+  it('trims whitespace around entries', () => {
+    const input = '  src/**/*  ,  app/**/*  ';
+    expect(parseGlobList(input)).toEqual(['src/**/*', 'app/**/*']);
+  });
+});