transcripto-cli 1.0.0

package/src/cli/report.ts

@@ -0,0 +1,160 @@
+import { promises as fs } from 'fs';
+import chalk from 'chalk';
+import { ExtractedString } from '../core/stringExtractor';
+
+interface ReportData {
+  totalStrings: number;
+  filesScanned: number;
+  languages: string[];
+  coverage: number;
+  missingTranslations: string[];
+  stringsByFile: Record<string, number>;
+}
+
+export async function reportCommand(): Promise<void> {
+  console.log(chalk.blue('📊 Generating localization report...'));
+
+  try {
+    const report = await generateReport();
+    displayReport(report);
+
+  } catch (error) {
+    console.error(chalk.red('❌ Report generation failed:'), error);
+    process.exit(1);
+  }
+}
+
+async function generateReport(): Promise<ReportData> {
+  // Load extracted strings
+  const strings = await loadExtractedStrings();
+  
+  // Load config
+  const config = await loadConfig();
+  
+  // Load existing translations
+  const translations = await loadTranslations(config.i18n.languages);
+  
+  // Calculate metrics
+  const filesScanned = new Set(strings.map(s => s.filePath)).size;
+  const stringsByFile: Record<string, number> = {};
+  
+  strings.forEach(str => {
+    const fileName = str.filePath.split('/').pop() || str.filePath;
+    stringsByFile[fileName] = (stringsByFile[fileName] || 0) + 1;
+  });
+
+  // Check missing translations
+  const missingTranslations: string[] = [];
+  for (const lang of config.i18n.languages) {
+    if (lang !== 'en' && (!translations[lang] || Object.keys(translations[lang]).length < strings.length)) {
+      missingTranslations.push(lang);
+    }
+  }
+
+  const coverage = strings.length > 0 
+    ? Math.round((translations.en ? Object.keys(translations.en).length : 0) / strings.length * 100)
+    : 0;
+
+  return {
+    totalStrings: strings.length,
+    filesScanned,
+    languages: config.i18n.languages,
+    coverage,
+    missingTranslations,
+    stringsByFile
+  };
+}
+
+function displayReport(report: ReportData): void {
+  console.log(chalk.green('\n📈 Transcripto Localization Report'));
+  console.log(chalk.gray('='.repeat(40)));
+  
+  console.log(chalk.white(`\n📝 Total Strings: ${report.totalStrings}`));
+  console.log(chalk.white(`📁 Files Scanned: ${report.filesScanned}`));
+  console.log(chalk.white(`🌐 Languages: ${report.languages.join(', ')}`));
+  
+  // Coverage with color coding
+  let coverageColor = chalk.red;
+  if (report.coverage >= 80) coverageColor = chalk.green;
+  else if (report.coverage >= 50) coverageColor = chalk.yellow;
+  
+  console.log(coverageColor(`📊 Coverage: ${report.coverage}%`));
+  
+  // Missing translations
+  if (report.missingTranslations.length > 0) {
+    console.log(chalk.red(`\n⚠️  Missing Translations: ${report.missingTranslations.join(', ')}`));
+  } else {
+    console.log(chalk.green('\n✅ All languages have complete translations'));
+  }
+  
+  // Strings by file
+  if (Object.keys(report.stringsByFile).length > 0) {
+    console.log(chalk.white('\n📋 Strings by File:'));
+    const sortedFiles = Object.entries(report.stringsByFile)
+      .sort(([,a], [,b]) => b - a)
+      .slice(0, 10);
+    
+    sortedFiles.forEach(([file, count]) => {
+      console.log(chalk.gray(`  ${file}: ${count} strings`));
+    });
+    
+    if (Object.keys(report.stringsByFile).length > 10) {
+      console.log(chalk.gray(`  ... and ${Object.keys(report.stringsByFile).length - 10} more files`));
+    }
+  }
+  
+  // Recommendations
+  console.log(chalk.white('\n💡 Recommendations:'));
+  
+  if (report.totalStrings === 0) {
+    console.log(chalk.yellow('  • Run "transcripto scan" to extract UI strings'));
+  } else if (report.coverage < 100) {
+    console.log(chalk.yellow('  • Run "transcripto generate" to update translation files'));
+  }
+  
+  if (report.missingTranslations.length > 0) {
+    console.log(chalk.yellow('  • Run "npx lingo.dev@latest run" to generate missing translations'));
+  }
+  
+  if (report.totalStrings > 0 && report.coverage === 100) {
+    console.log(chalk.green('  • Localization is complete! 🎉'));
+  }
+}
+
+async function loadExtractedStrings(): Promise<ExtractedString[]> {
+  try {
+    const content = await fs.readFile('.transcripto/extracted-strings.json', 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    return [];
+  }
+}
+
+async function loadConfig() {
+  try {
+    const configContent = await fs.readFile('.transcripto/config.json', 'utf-8');
+    return JSON.parse(configContent);
+  } catch (error) {
+    return {
+      i18n: {
+        languages: ['en', 'hi', 'kn'],
+        outputDir: './src/i18n'
+      }
+    };
+  }
+}
+
+async function loadTranslations(languages: string[]): Promise<Record<string, Record<string, string>>> {
+  const translations: Record<string, Record<string, string>> = {};
+  
+  for (const lang of languages) {
+    try {
+      const content = await fs.readFile(`./src/i18n/${lang}.json`, 'utf-8');
+      translations[lang] = JSON.parse(content);
+    } catch (error) {
+      translations[lang] = {};
+    }
+  }
+  
+  return translations;
+}

package/src/cli/scan.ts

@@ -0,0 +1,69 @@
+import { promises as fs } from 'fs';
+import chalk from 'chalk';
+import { ProjectScanner } from '../core/projectScanner';
+import { StringExtractor } from '../core/stringExtractor';
+
+export async function scanCommand(): Promise<void> {
+  console.log(chalk.blue('🔍 Scanning project for UI text strings...'));
+
+  try {
+    // Load config
+    const config = await loadConfig();
+    
+    // Initialize scanner and extractor
+    const scanner = new ProjectScanner();
+    const extractor = new StringExtractor();
+
+    // Scan project
+    const files = await scanner.scanProject();
+    console.log(chalk.gray(`📁 Found ${files.length} files to scan`));
+
+    // Extract strings
+    const strings = await extractor.extractStrings(files);
+    
+    // Save results
+    await fs.writeFile(
+      '.transcripto/extracted-strings.json', 
+      JSON.stringify(strings, null, 2), 
+      'utf-8'
+    );
+
+    console.log(chalk.green(`✅ Extracted ${strings.length} UI text strings`));
+    
+    if (strings.length > 0) {
+      console.log(chalk.yellow('\n📝 Sample extracted strings:'));
+      strings.slice(0, 5).forEach((str, index) => {
+        console.log(chalk.white(`  ${index + 1}. "${str.text}" → ${str.key}`));
+        console.log(chalk.gray(`     from ${str.filePath}:${str.line}`));
+      });
+      
+      if (strings.length > 5) {
+        console.log(chalk.gray(`  ... and ${strings.length - 5} more`));
+      }
+    }
+
+    console.log(chalk.yellow('\n🎯 Next steps:'));
+    console.log(chalk.white('  transcripto generate - Generate i18n files from extracted strings'));
+    console.log(chalk.white('  transcripto replace  - Replace inline text with constants'));
+
+  } catch (error) {
+    console.error(chalk.red('❌ Scan failed:'), error);
+    process.exit(1);
+  }
+}
+
+async function loadConfig() {
+  try {
+    const configContent = await fs.readFile('.transcripto/config.json', 'utf-8');
+    return JSON.parse(configContent);
+  } catch (error) {
+    console.warn(chalk.yellow('⚠️  No .transcripto/config.json found, using defaults'));
+    return {
+      scan: {
+        extensions: ['.ts', '.tsx', '.js', '.jsx', '.html'],
+        exclude: ['node_modules', 'dist', 'build', '.git', 'coverage'],
+        minStringLength: 2
+      }
+    };
+  }
+}

package/src/cli/watch-i18n.ts

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+import { promises as fs } from 'fs';
+import chokidar from 'chokidar';
+import { ProjectScanner } from '../core/projectScanner';
+import { StringExtractor } from '../core/stringExtractor';
+import { I18nGenerator } from '../core/i18nGenerator';
+
+export async function watchI18nCommand(): Promise<void> {
+  console.log(chalk.cyan('👁️  Starting i18n file watcher...'));
+  console.log(chalk.gray('📁 Monitoring: ./i18n/en.json'));
+  console.log(chalk.gray('🔄 Auto-translating on changes...\n'));
+
+  // Ensure i18n directory exists
+  try {
+    await fs.mkdir('./i18n', { recursive: true });
+  } catch {
+    // Directory already exists
+  }
+
+  // Initial translation if en.json exists
+  try {
+    const enContent = await fs.readFile('./i18n/en.json', 'utf-8');
+    const translations = JSON.parse(enContent);
+    const keys = Object.keys(translations);
+    
+    if (keys.length > 0) {
+      console.log(chalk.yellow('📝 Found existing translations, running initial translation...'));
+      await runTranslation();
+    }
+  } catch {
+    console.log(chalk.yellow('📝 No existing en.json found, waiting for file creation...'));
+  }
+
+  // Watch for changes in en.json
+  const watcher = chokidar.watch('./i18n/en.json', {
+    persistent: true,
+    ignoreInitial: true
+  });
+
+  watcher.on('change', async () => {
+    console.log(chalk.cyan('\n🔄 File changed: ./i18n/en.json'));
+    console.log(chalk.yellow('🌐 Running auto-translation...'));
+    
+    try {
+      await runTranslation();
+      console.log(chalk.green('✅ Auto-translation completed!'));
+    } catch (error) {
+      console.error(chalk.red('❌ Auto-translation failed:'), error);
+    }
+  });
+
+  watcher.on('add', async () => {
+    console.log(chalk.cyan('\n📁 File created: ./i18n/en.json'));
+    console.log(chalk.yellow('🌐 Running initial translation...'));
+    
+    try {
+      await runTranslation();
+      console.log(chalk.green('✅ Initial translation completed!'));
+    } catch (error) {
+      console.error(chalk.red('❌ Initial translation failed:'), error);
+    }
+  });
+
+  console.log(chalk.green('🎉 Watcher started successfully!'));
+  console.log(chalk.gray('💡 Add new keys to ./i18n/en.json and they will be auto-translated'));
+  console.log(chalk.gray('⏹️  Press Ctrl+C to stop watching\n'));
+}
+
+async function runTranslation() {
+  const generator = new I18nGenerator();
+  
+  // Generate lingo.dev config for root/i18n
+  await generator.generateLingoDevConfig();
+  
+  // Run lingo.dev translation
+  await generator.runLingoDev();
+}

package/src/cli/watch.ts

@@ -0,0 +1,129 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import * as chokidar from 'chokidar';
+import { I18nGenerator } from '../core/i18nGenerator';
+import { ProjectScanner } from '../core/projectScanner';
+import { StringExtractor } from '../core/stringExtractor';
+import { ExtractedString } from '../core/stringExtractor';
+
+export async function watchCommand(options: any): Promise<void> {
+  console.log(chalk.blue('👁️  Starting Transcripto file watcher...'));
+  
+  const yes = options.yes || false;
+  
+  if (yes) {
+    console.log(chalk.yellow('🤖 Running in non-interactive mode (--yes)'));
+  }
+
+  // Initial setup
+  await setupProject(yes);
+
+  // Watch for file changes
+  const watcher = chokidar.watch([
+    'src/**/*.{ts,tsx,js,jsx}',
+    '!src/i18n/**/*',
+    '!dist/**/*',
+    '!node_modules/**/*'
+  ], {
+    ignored: /node_modules/,
+    persistent: true,
+    ignoreInitial: true
+  });
+
+  console.log(chalk.green('📁 Watching for changes in src/ directory...'));
+  console.log(chalk.gray('💡 Press Ctrl+C to stop watching'));
+
+  watcher.on('change', async (filePath: string) => {
+    console.log(chalk.yellow(`\n📝 File changed: ${filePath}`));
+    await handleFileChange(filePath, yes);
+  });
+
+  watcher.on('add', async (filePath: string) => {
+    console.log(chalk.yellow(`\n➕ File added: ${filePath}`));
+    await handleFileChange(filePath, yes);
+  });
+
+  // Handle process termination
+  process.on('SIGINT', () => {
+    console.log(chalk.cyan('\n👋 Stopping Transcripto watcher...'));
+    watcher.close();
+    process.exit(0);
+  });
+}
+
+async function setupProject(yes: boolean): Promise<void> {
+  try {
+    // Check if project is initialized
+    try {
+      await fs.access('.transcripto');
+      console.log(chalk.green('✅ Transcripto project already initialized'));
+    } catch {
+      console.log(chalk.yellow('🔧 Initializing Transcripto project...'));
+      const { initCommand } = await import('./init');
+      await initCommand();
+    }
+
+    // Initial scan and generation
+    console.log(chalk.blue('🔍 Performing initial scan...'));
+    await performFullWorkflow(yes);
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Setup failed:'), error);
+    process.exit(1);
+  }
+}
+
+async function handleFileChange(filePath: string, yes: boolean): Promise<void> {
+  try {
+    console.log(chalk.cyan('🔄 Updating translations...'));
+    
+    // Perform full workflow
+    await performFullWorkflow(yes);
+    
+    console.log(chalk.green('✅ Translations updated successfully!'));
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Update failed:'), error);
+  }
+}
+
+async function performFullWorkflow(yes: boolean): Promise<void> {
+  // Scan for strings
+  const scanner = new ProjectScanner();
+  const files = await scanner.scanProject('./src');
+  
+  const extractor = new StringExtractor();
+  const strings = await extractor.extractStrings(files);
+  
+  if (strings.length === 0) {
+    console.log(chalk.yellow('⚠️  No strings found'));
+    return;
+  }
+
+  // Generate i18n files using same config as generate command
+  const generator = new I18nGenerator();
+  const config = {
+    outputDir: './i18n', // Changed to root folder
+    languages: ['en'], // Start with just English, lingo.dev will add more
+    constantsFile: '', // No constants file needed
+    keyPrefix: ''
+  };
+  
+  await generator.generateI18nFiles(strings, config);
+  await generator.generateLingoDevConfig(); // Let lingo.dev decide target languages
+
+  // Run lingo.dev automatically
+  try {
+    await generator.runLingoDev();
+    console.log(chalk.green('🌐 lingo.dev translations completed!'));
+  } catch (error) {
+    console.log(chalk.yellow('⚠️  lingo.dev failed, continuing...'));
+  }
+
+  // Replace strings with constants
+  // const replacer = new TextReplacer();
+  // await replacer.replaceInFiles(strings);
+  
+  console.log(chalk.green(`✅ Processed ${strings.length} strings`));
+}

package/src/core/i18nGenerator.ts

@@ -0,0 +1,127 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { ExtractedString } from './stringExtractor';
+
+export interface I18nConfig {
+  outputDir: string;
+  languages: string[];
+  constantsFile: string;
+  keyPrefix: string;
+}
+
+export class I18nGenerator {
+  private readonly defaultConfig: I18nConfig = {
+    outputDir: './i18n',  // Changed to root folder
+    languages: ['en', 'hi', 'kn'],
+    constantsFile: './src/i18n/constants.ts',
+    keyPrefix: ''
+  };
+
+  async generateI18nFiles(
+    strings: ExtractedString[], 
+    config: Partial<I18nConfig> = {}
+  ): Promise<void> {
+    const finalConfig = { ...this.defaultConfig, ...config };
+
+    // Create output directory
+    await fs.mkdir(finalConfig.outputDir, { recursive: true });
+
+    // Generate translation files only (no constants file)
+    for (const language of finalConfig.languages) {
+      await this.generateTranslationFile(strings, language, finalConfig);
+    }
+  }
+
+  private async generateTranslationFile(
+    strings: ExtractedString[], 
+    language: string, 
+    config: I18nConfig
+  ): Promise<void> {
+    const translations: Record<string, string> = {};
+
+    for (const str of strings) {
+      translations[str.key] = str.text;
+    }
+
+    const filePath = path.join(config.outputDir, `${language}.json`);
+    const content = JSON.stringify(translations, null, 2);
+
+    await fs.writeFile(filePath, content, 'utf-8');
+  }
+
+  async generateLingoDevConfig(): Promise<void> {
+    // First, delete any existing lingo.dev config to ensure clean setup
+    try {
+      await fs.unlink('.lingodev.json');
+      console.log('🗑️  Removed existing lingo.dev config');
+    } catch {
+      // Config doesn't exist, that's fine
+    }
+
+    // Let lingo.dev handle target languages automatically - don't specify any
+    const config = {
+      source: './i18n/en.json',  // Changed to root folder
+      // target: [] - Let lingo.dev decide automatically
+      output: './i18n',        // Changed to root folder
+      format: 'json'
+    };
+
+    const content = JSON.stringify(config, null, 2);
+    await fs.writeFile('.lingodev.json', content, 'utf-8');
+    console.log('📁 Created lingo.dev config with automatic language selection');
+  }
+
+  async runLingoDev(): Promise<void> {
+    const { spawn } = await import('child_process');
+    
+    // First, initialize lingo.dev if not already done
+    try {
+      await fs.access('i18n.json');
+      console.log('📁 lingo.dev already initialized');
+    } catch {
+      console.log('🔧 Initializing lingo.dev...');
+      await this.initializeLingoDev();
+    }
+    
+    // Then run lingo.dev
+    return new Promise((resolve, reject) => {
+      const process = spawn('npx', ['lingo.dev@latest', 'run'], {
+        stdio: 'inherit',
+        shell: true
+      });
+
+      process.on('close', (code) => {
+        if (code === 0) {
+          console.log('✅ lingo.dev translations completed successfully!');
+          resolve();
+        } else {
+          reject(new Error(`lingo.dev process exited with code ${code}`));
+        }
+      });
+
+      process.on('error', reject);
+    });
+  }
+
+  private async initializeLingoDev(): Promise<void> {
+    const { spawn } = await import('child_process');
+    
+    return new Promise((resolve, reject) => {
+      const process = spawn('npx', ['lingo.dev@latest', 'init'], {
+        stdio: 'inherit',
+        shell: true
+      });
+
+      process.on('close', (code) => {
+        if (code === 0) {
+          console.log('✅ lingo.dev initialized successfully');
+          resolve();
+        } else {
+          reject(new Error(`lingo.dev init failed with code ${code}`));
+        }
+      });
+
+      process.on('error', reject);
+    });
+  }
+}

package/src/core/projectScanner.ts

@@ -0,0 +1,62 @@
+import { glob } from 'glob';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+export interface FileInfo {
+  path: string;
+  content: string;
+  size: number;
+}
+
+export class ProjectScanner {
+  private readonly extensions = ['.ts', '.tsx', '.js', '.jsx', '.html'];
+  private readonly excludePatterns = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.git/**',
+    '**/coverage/**'
+  ];
+
+  async scanProject(rootPath: string = process.cwd()): Promise<FileInfo[]> {
+    const pattern = `**/*.{${this.extensions.map(ext => ext.slice(1)).join(',')}}`;
+    
+    const files = await glob(pattern, {
+      cwd: rootPath,
+      ignore: this.excludePatterns,
+      absolute: true
+    });
+
+    const fileInfos: FileInfo[] = [];
+
+    for (const filePath of files) {
+      try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const stats = await fs.stat(filePath);
+        
+        fileInfos.push({
+          path: filePath,
+          content,
+          size: stats.size
+        });
+      } catch (error) {
+        console.warn(`Warning: Could not read file ${filePath}:`, error);
+      }
+    }
+
+    return fileInfos;
+  }
+
+  async getProjectStructure(rootPath: string = process.cwd()): Promise<string[]> {
+    const pattern = '**/*';
+    
+    const files = await glob(pattern, {
+      cwd: rootPath,
+      ignore: this.excludePatterns,
+      absolute: false,
+      nodir: true
+    });
+
+    return files.sort();
+  }
+}