i18nsmith 0.3.3 → 0.4.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkBpC,eAAO,MAAM,OAAO,SAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmBpC,eAAO,MAAM,OAAO,SAAgB,CAAC"}

package/dist/test-helpers/ensure-cli-built.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ensure-cli-built.d.ts","sourceRoot":"","sources":["../../src/test-helpers/ensure-cli-built.ts"],"names":[],"mappings":"AAUA,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBnE"}
+{"version":3,"file":"ensure-cli-built.d.ts","sourceRoot":"","sources":["../../src/test-helpers/ensure-cli-built.ts"],"names":[],"mappings":"AAaA,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoCnE"}

package/dist/utils/adapter-preflight.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Adapter preflight utilities for CLI commands.
+ * Validates framework adapter dependencies before write operations.
+ */
+/**
+ * Run preflight checks for all registered framework adapters.
+ * Throws an error if any required dependencies are missing.
+ */
+export declare function runAdapterPreflight(): Promise<void>;
+//# sourceMappingURL=adapter-preflight.d.ts.map

package/dist/utils/adapter-preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-preflight.d.ts","sourceRoot":"","sources":["../../src/utils/adapter-preflight.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAeH;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CA8BzD"}

package/i18n.config.json

@@ -0,0 +1,14 @@
+{
+  "sourceLanguage": "en",
+  "targetLanguages": ["es", "fr"],
+  "localesDir": "locales",
+  "extraction": {
+    "minTextLength": 3,
+    "minLetterCount": 2,
+    "minLetterRatio": 0.5
+  },
+  "translationAdapter": {
+    "module": "@i18nsmith/translation",
+    "hookName": "t"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18nsmith",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "CLI for i18nsmith",
   "type": "module",
   "main": "dist/index.cjs",
@@ -24,11 +24,13 @@
     "chalk": "^5.0.0",
     "commander": "^11.0.0",
     "diff": "^8.0.2",
+    "eslint": "^8.57.1",
     "fast-glob": "^3.3.3",
     "inquirer": "^9.0.0",
     "p-limit": "^7.2.0",
     "p-retry": "^7.1.0",
-    "ts-morph": "^21.0.0"
+    "ts-morph": "^21.0.0",
+    "vue-eslint-parser": "^10.2.0"
   },
   "devDependencies": {
     "@i18nsmith/core": "workspace:*",

package/src/commands/detect.ts

@@ -0,0 +1,342 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import type { Command } from 'commander';
+import {
+  ProjectIntelligenceService,
+  type ProjectIntelligence,
+  type ConfidenceLevel,
+} from '@i18nsmith/core';
+import { withErrorHandling } from '../utils/errors.js';
+
+interface DetectOptions {
+  json?: boolean;
+  report?: string;
+  verbose?: boolean;
+  showConfig?: boolean;
+}
+
+/**
+ * Get colored confidence indicator based on level
+ */
+function getConfidenceIndicator(level: ConfidenceLevel): string {
+  switch (level) {
+    case 'high':
+      return chalk.green('●');
+    case 'medium':
+      return chalk.yellow('●');
+    case 'low':
+      return chalk.red('●');
+    case 'uncertain':
+    default:
+      return chalk.gray('○');
+  }
+}
+
+/**
+ * Format percentage for display
+ */
+function formatPercent(value: number): string {
+  return `${Math.round(value * 100)}%`;
+}
+
+/**
+ * Print framework detection results
+ */
+function printFrameworkDetection(result: ProjectIntelligence, verbose: boolean) {
+  console.log(chalk.blue('\n📦 Framework Detection'));
+
+  const { framework, confidence } = result;
+  const level = getConfidenceLevel(confidence.framework);
+  const indicator = getConfidenceIndicator(level);
+
+  if (framework.type === 'unknown') {
+    console.log(chalk.yellow('  • No framework detected'));
+  } else {
+    console.log(`  ${indicator} Framework: ${chalk.bold(framework.type)}`);
+
+    if (framework.adapter) {
+      console.log(`     i18n Adapter: ${chalk.cyan(framework.adapter)}`);
+    }
+
+    if (framework.routerType && framework.routerType !== 'unknown') {
+      console.log(`     Router: ${chalk.cyan(framework.routerType)} router`);
+    }
+
+    console.log(`     Confidence: ${formatPercent(confidence.framework)}`);
+  }
+
+  if (verbose && framework.evidence.length > 0) {
+    console.log(chalk.gray('\n  Evidence:'));
+    for (const evidence of framework.evidence) {
+      const sourceLabel = evidence.type === 'package' ? '📦' : '📄';
+      console.log(chalk.gray(`    ${sourceLabel} ${evidence.description} (weight: ${evidence.weight})`));
+    }
+  }
+}
+
+/**
+ * Get confidence level from score
+ */
+function getConfidenceLevel(score: number): ConfidenceLevel {
+  if (score >= 0.8) return 'high';
+  if (score >= 0.5) return 'medium';
+  if (score >= 0.3) return 'low';
+  return 'uncertain';
+}
+
+/**
+ * Print file patterns detection results
+ */
+function printFilePatterns(result: ProjectIntelligence, verbose: boolean) {
+  console.log(chalk.blue('\n📂 File Patterns'));
+
+  const { filePatterns, confidence } = result;
+  const level = getConfidenceLevel(confidence.filePatterns);
+  const indicator = getConfidenceIndicator(level);
+
+  console.log(`  ${indicator} Source directories:`);
+  for (const dir of filePatterns.sourceDirectories) {
+    console.log(`     • ${chalk.cyan(dir)}`);
+  }
+
+  const extensions: string[] = [];
+  if (filePatterns.hasTypeScript) extensions.push('.ts', '.tsx');
+  if (filePatterns.hasJsx && !filePatterns.hasTypeScript) extensions.push('.jsx');
+  if (filePatterns.hasVue) extensions.push('.vue');
+  if (filePatterns.hasSvelte) extensions.push('.svelte');
+  if (extensions.length === 0) extensions.push('.js');
+
+  console.log(`  ${indicator} Extensions: ${extensions.map((e: string) => chalk.cyan(e)).join(', ')}`);
+  console.log(`     Files: ~${filePatterns.sourceFileCount} source files`);
+  console.log(`     Confidence: ${formatPercent(confidence.filePatterns)}`);
+
+  if (verbose) {
+    console.log(chalk.gray('\n  Suggested include patterns:'));
+    for (const pattern of filePatterns.include) {
+      console.log(chalk.gray(`    + ${pattern}`));
+    }
+
+    console.log(chalk.gray('\n  Suggested exclude patterns:'));
+    for (const pattern of filePatterns.exclude.slice(0, 5)) {
+      console.log(chalk.gray(`    - ${pattern}`));
+    }
+    if (filePatterns.exclude.length > 5) {
+      console.log(chalk.gray(`    ... and ${filePatterns.exclude.length - 5} more`));
+    }
+  }
+}
+
+/**
+ * Print locale detection results
+ */
+function printLocaleDetection(result: ProjectIntelligence, verbose: boolean) {
+  console.log(chalk.blue('\n🌍 Locale Detection'));
+
+  const { locales, confidence } = result;
+  const level = getConfidenceLevel(confidence.locales);
+  const indicator = getConfidenceIndicator(level);
+
+  if (locales.existingFiles.length === 0) {
+    console.log(chalk.yellow('  • No existing locale files detected'));
+    return;
+  }
+
+  console.log(`  ${indicator} Locales directory: ${chalk.cyan(locales.localesDir || 'N/A')}`);
+  console.log(`     Format: ${chalk.cyan(locales.format)}`);
+  console.log(`     Source locale: ${chalk.cyan(locales.sourceLanguage || 'en')}`);
+
+  const allLangs = [locales.sourceLanguage, ...locales.targetLanguages].filter(Boolean);
+  console.log(`     Languages: ${allLangs.map((l: string) => chalk.cyan(l)).join(', ')}`);
+  console.log(`     Total keys: ${locales.existingKeyCount}`);
+  console.log(`     Confidence: ${formatPercent(confidence.locales)}`);
+
+  if (verbose && locales.existingFiles.length > 0) {
+    console.log(chalk.gray('\n  Locale files:'));
+    for (const file of locales.existingFiles.slice(0, 10)) {
+      const relativePath = file.path.includes('/') ? file.path.split('/').slice(-2).join('/') : file.path;
+      console.log(chalk.gray(`    • ${file.locale}: ${relativePath} (${file.keyCount} keys)`));
+    }
+    if (locales.existingFiles.length > 10) {
+      console.log(chalk.gray(`    ... and ${locales.existingFiles.length - 10} more files`));
+    }
+  }
+}
+
+/**
+ * Print existing setup detection results
+ */
+function printExistingSetup(result: ProjectIntelligence, verbose: boolean) {
+  const { existingSetup, confidence } = result;
+
+  if (!existingSetup.hasExistingConfig && existingSetup.runtimePackages.length === 0) {
+    return;
+  }
+
+  console.log(chalk.blue('\n⚙️ Existing i18n Setup'));
+
+  const level = getConfidenceLevel(confidence.existingSetup);
+  const indicator = getConfidenceIndicator(level);
+
+  if (existingSetup.hasExistingConfig && existingSetup.configPath) {
+    console.log(`  ${indicator} Existing config: ${chalk.cyan(existingSetup.configPath)}`);
+  }
+
+  for (const pkg of existingSetup.runtimePackages) {
+    console.log(`  ${indicator} ${chalk.cyan(pkg.name)}@${pkg.version || 'latest'}`);
+  }
+
+  if (existingSetup.translationUsage) {
+    const usage = existingSetup.translationUsage;
+    console.log(`     Hook: ${usage.hookName}() (${usage.filesWithHooks} files)`);
+    console.log(`     t() calls: ${usage.translationCalls} across ${usage.filesWithHooks} files`);
+  }
+
+  if (verbose && existingSetup.hasI18nProvider && existingSetup.providerPath) {
+    console.log(chalk.gray(`\n  Provider: ${existingSetup.providerPath}`));
+  }
+}
+
+/**
+ * Print overall confidence summary
+ */
+function printConfidenceSummary(result: ProjectIntelligence) {
+  console.log(chalk.blue('\n📊 Overall Confidence'));
+
+  const { confidence } = result;
+  const indicator = getConfidenceIndicator(confidence.level);
+
+  console.log(`  ${indicator} Overall: ${chalk.bold(formatPercent(confidence.overall))} (${confidence.level})`);
+
+  // Visual bar
+  const barLength = 30;
+  const filledLength = Math.round(confidence.overall * barLength);
+  const emptyLength = barLength - filledLength;
+  const bar = chalk.green('█'.repeat(filledLength)) + chalk.gray('░'.repeat(emptyLength));
+  console.log(`     ${bar}`);
+}
+
+/**
+ * Print warnings if any
+ */
+function printWarnings(result: ProjectIntelligence) {
+  if (result.warnings.length === 0) {
+    return;
+  }
+
+  console.log(chalk.blue('\n⚠️ Warnings'));
+  for (const warning of result.warnings) {
+    const label =
+      warning.severity === 'error'
+        ? chalk.red('ERROR')
+        : warning.severity === 'warn'
+          ? chalk.yellow('WARN')
+          : chalk.cyan('INFO');
+    console.log(`  • [${label}] ${warning.message}`);
+    if (warning.suggestion) {
+      console.log(chalk.gray(`    → ${warning.suggestion}`));
+    }
+  }
+}
+
+/**
+ * Print suggested configuration
+ */
+function printSuggestedConfig(result: ProjectIntelligence) {
+  console.log(chalk.blue('\n📝 Suggested Configuration'));
+
+  const { suggestedConfig } = result;
+
+  console.log(`  Source Language: ${chalk.cyan(suggestedConfig.sourceLanguage)}`);
+  if (suggestedConfig.targetLanguages.length > 0) {
+    console.log(`  Target Languages: ${suggestedConfig.targetLanguages.map((l: string) => chalk.cyan(l)).join(', ')}`);
+  }
+  console.log(`  Locales Dir: ${chalk.cyan(suggestedConfig.localesDir)}`);
+  console.log(`  Adapter: ${chalk.cyan(suggestedConfig.translationAdapter.module)}`);
+  console.log(`  Hook: ${chalk.cyan(suggestedConfig.translationAdapter.hookName)}`);
+}
+
+/**
+ * Print full config preview as JSON
+ */
+function printConfigPreview(result: ProjectIntelligence) {
+  console.log(chalk.blue('\n🔧 Full Config Preview'));
+
+  const config = {
+    localesDir: result.suggestedConfig.localesDir,
+    defaultLocale: result.suggestedConfig.sourceLanguage,
+    locales: [result.suggestedConfig.sourceLanguage, ...result.suggestedConfig.targetLanguages],
+    include: result.suggestedConfig.include,
+    exclude: result.suggestedConfig.exclude,
+    adapter: result.suggestedConfig.translationAdapter.module,
+    translationFunctionName: result.suggestedConfig.translationAdapter.hookName,
+  };
+
+  console.log(chalk.gray(JSON.stringify(config, null, 2)));
+}
+
+/**
+ * Print recommendations if any
+ */
+function printRecommendations(result: ProjectIntelligence) {
+  if (result.recommendations.length === 0) {
+    return;
+  }
+
+  console.log(chalk.blue('\n💡 Recommendations'));
+  for (const rec of result.recommendations) {
+    console.log(`  • ${rec}`);
+  }
+}
+
+export function registerDetect(program: Command) {
+  program
+    .command('detect')
+    .description('Detect project configuration automatically')
+    .option('--json', 'Output results as JSON', false)
+    .option('--report <path>', 'Write JSON report to a file')
+    .option('-v, --verbose', 'Show detailed evidence and suggestions', false)
+    .option('--show-config', 'Show full suggested configuration', false)
+    .action(
+      withErrorHandling(async (options: DetectOptions) => {
+        const workspaceRoot = process.cwd();
+
+        console.log(chalk.blue('🔍 Analyzing project...'));
+        console.log(chalk.gray(`   Working directory: ${workspaceRoot}\n`));
+
+        const service = new ProjectIntelligenceService();
+        const result = await service.analyze({ workspaceRoot });
+
+        // JSON output
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        // Write report file
+        if (options.report) {
+          const outputPath = path.resolve(workspaceRoot, options.report);
+          await fs.mkdir(path.dirname(outputPath), { recursive: true });
+          await fs.writeFile(outputPath, JSON.stringify(result, null, 2));
+          console.log(chalk.green(`Report written to ${outputPath}\n`));
+        }
+
+        // Pretty print results
+        printFrameworkDetection(result, options.verbose ?? false);
+        printFilePatterns(result, options.verbose ?? false);
+        printLocaleDetection(result, options.verbose ?? false);
+        printExistingSetup(result, options.verbose ?? false);
+        printConfidenceSummary(result);
+        printWarnings(result);
+        printSuggestedConfig(result);
+        printRecommendations(result);
+
+        if (options.showConfig) {
+          printConfigPreview(result);
+        }
+
+        // Helpful tip
+        console.log(chalk.gray('\n💡 Tip: Run `i18nsmith init` to generate configuration based on this analysis.'));
+      })
+    );
+}

package/src/commands/init.test.ts

@@ -1,6 +1,7 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Command } from 'commander';
 import { registerInit, parseGlobList } from './init.js';
+import fs from 'fs/promises';
 
 vi.mock('@i18nsmith/core', () => ({
   diagnoseWorkspace: vi.fn().mockResolvedValue({
@@ -23,6 +24,134 @@ vi.mock('@i18nsmith/core', () => ({
     conflicts: [],
     recommendations: [],
   }),
+  ensureGitignore: vi.fn().mockResolvedValue({ updated: false }),
+  ProjectIntelligenceService: vi.fn().mockImplementation(() => ({
+    analyze: vi.fn().mockResolvedValue({
+      framework: {
+        type: 'react',
+        adapter: 'react-i18next',
+        hookName: 'useTranslation',
+        features: [],
+        confidence: 0.8,
+        evidence: []
+      },
+      locales: {
+        sourceLanguage: 'en',
+        targetLanguages: [],
+        localesDir: 'locales',
+        format: 'flat',
+        existingFiles: [],
+        existingKeyCount: 0,
+        confidence: 0.5
+      },
+      filePatterns: {
+        include: ['src/**/*.{ts,tsx,js,jsx}'],
+        exclude: ['node_modules/**', 'dist/**'],
+        sourceDirectories: ['src'],
+        hasTypeScript: true,
+        hasJsx: true,
+        hasVue: false,
+        hasSvelte: false,
+        sourceFileCount: 10,
+        confidence: 0.7
+      },
+      existingSetup: {
+        hasExistingConfig: false,
+        hasExistingLocales: false,
+        hasI18nProvider: false,
+        runtimePackages: [],
+        translationUsage: {
+          hookName: 'useTranslation',
+          translationIdentifier: 't',
+          filesWithHooks: 0,
+          translationCalls: 0,
+          exampleFiles: []
+        }
+      },
+      confidence: {
+        framework: 0.8,
+        filePatterns: 0.7,
+        existingSetup: 0.3,
+        locales: 0.5,
+        overall: 0.75,
+        level: 'high'
+      },
+      warnings: [],
+      recommendations: [],
+      suggestedConfig: {
+        sourceLanguage: 'en',
+        targetLanguages: [],
+        localesDir: 'locales',
+        include: ['src/**/*.{ts,tsx,js,jsx}'],
+        exclude: ['node_modules/**', 'dist/**'],
+        translationAdapter: {
+          module: 'react-i18next',
+          hookName: 'useTranslation'
+        },
+        keyGeneration: {
+          namespace: 'common',
+          shortHashLen: 6
+        }
+      }
+    })
+  })),
+  Scanner: {
+    create: vi.fn().mockResolvedValue({
+      scan: vi.fn().mockResolvedValue({
+        buckets: {
+          highConfidence: [
+            {
+              id: 'test-1',
+              filePath: 'src/components/Button.tsx',
+              kind: 'jsx-text',
+              text: 'Hello World',
+              context: 'Button component',
+              position: { line: 5, column: 10 }
+            }
+          ],
+          needsReview: [],
+          skipped: []
+        },
+        candidates: [],
+        filesScanned: 5,
+        filesExamined: ['src/components/Button.tsx'],
+      })
+    })
+  },
+  KeyGenerator: vi.fn().mockImplementation(() => ({
+    generate: vi.fn().mockReturnValue({
+      key: 'common.button.hello-world.abc123',
+      hash: 'abc123',
+      preview: 'Hello World'
+    })
+  }))
+}));
+
+vi.mock('../utils/scaffold.js', () => ({
+  scaffoldTranslationContext: vi.fn().mockResolvedValue({
+    path: 'src/contexts/translation-context.tsx',
+    content: '// mock content',
+    written: true
+  }),
+  scaffoldI18next: vi.fn().mockResolvedValue({
+    i18nPath: 'src/lib/i18n.ts',
+    providerPath: 'src/components/i18n-provider.tsx',
+    i18nResult: { path: 'src/lib/i18n.ts', content: '// i18n content', written: true },
+    providerResult: { path: 'src/components/i18n-provider.tsx', content: '// provider content', written: true }
+  })
+}));
+
+vi.mock('../utils/package-manager.js', () => ({
+  detectPackageManager: vi.fn().mockResolvedValue('pnpm'),
+  installDependencies: vi.fn().mockResolvedValue(undefined)
+}));
+
+vi.mock('../utils/pkg.js', () => ({
+  hasDependency: vi.fn().mockReturnValue(false),
+  readPackageJson: vi.fn().mockResolvedValue({
+    dependencies: {},
+    devDependencies: {}
+  })
 }));
 
 vi.mock('inquirer', () => ({
@@ -35,19 +164,97 @@ vi.mock('inquirer', () => ({
   },
 }));
 
+vi.mock('chalk', () => ({
+  default: {
+    blue: vi.fn((text) => text),
+    green: vi.fn((text) => text),
+    yellow: vi.fn((text) => text),
+    red: vi.fn((text) => text),
+    dim: vi.fn((text) => text),
+    cyan: vi.fn((text) => text),
+  }
+}));
+
 vi.mock('fs/promises', () => ({
   default: {
     writeFile: vi.fn().mockResolvedValue(undefined),
     mkdir: vi.fn().mockResolvedValue(undefined),
+    readFile: vi.fn().mockResolvedValue('{}'),
+    access: vi.fn().mockResolvedValue(undefined),
   },
 }));
 
 describe('init command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
   it('should register the init command', () => {
     const program = new Command();
     registerInit(program);
     const command = program.commands.find((cmd) => cmd.name() === 'init');
     expect(command).toBeDefined();
+    expect(command?.options.some(opt => opt.flags === '--scaffold')).toBe(true);
+  });
+
+  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/**/*']);
+    });
+  });
+
+  describe('non-interactive mode', () => {
+    it('should seed source locale with detected keys', async () => {
+      const program = new Command();
+      registerInit(program);
+      const command = program.commands.find((cmd) => cmd.name() === 'init')!;
+
+      // Mock process.cwd to return a test directory
+      const originalCwd = process.cwd;
+      process.cwd = vi.fn().mockReturnValue('/test/project');
+
+      // Mock fs.access to throw (config doesn't exist)
+      const originalAccess = fs.access;
+      vi.mocked(fs.access).mockRejectedValue(new Error('File not found'));
+
+      try {
+        // Execute command with --yes
+        await (command as any).parseAsync(['--yes'], { from: 'user' });
+      } finally {
+        process.cwd = originalCwd;
+        vi.mocked(fs.access).mockRestore();
+      }
+
+      // Should have written the seeded locale file
+      expect(vi.mocked(fs.writeFile)).toHaveBeenCalledWith(
+        expect.stringContaining('locales/en.json'),
+        expect.stringContaining('common.button.hello-world.abc123')
+      );
+    });
   });
 });