ctxman 3.0.0 → 3.1.0

package/lib/utils/messages.js

@@ -0,0 +1,355 @@
+/**
+ * Bilingual Messages Utility
+ * v3.0.0 - Internationalization support for CLI messages
+ *
+ * Supports English (en) and Turkish (tr) messages.
+ * Language is detected from LANG environment variable or can be set explicitly.
+ */
+
+// Message codes and their translations
+const messages = {
+  // CLI Help Messages
+  'cli.help.usage': {
+    en: 'Usage',
+    tr: 'Kullanım',
+  },
+  'cli.help.options': {
+    en: 'Options',
+    tr: 'Seçenekler',
+  },
+  'cli.help.examples': {
+    en: 'Examples',
+    tr: 'Örnekler',
+  },
+  'cli.help.description': {
+    en: 'Description',
+    tr: 'Açıklama',
+  },
+
+  // Analysis Messages
+  'analysis.start': {
+    en: 'Starting analysis...',
+    tr: 'Analiz başlatılıyor...',
+  },
+  'analysis.complete': {
+    en: 'Analysis complete',
+    tr: 'Analiz tamamlandı',
+  },
+  'analysis.files_found': {
+    en: 'Files found',
+    tr: 'Dosya bulundu',
+  },
+  'analysis.total_tokens': {
+    en: 'Total tokens',
+    tr: 'Toplam token',
+  },
+  'analysis.method_count': {
+    en: 'Methods found',
+    tr: 'Method bulundu',
+  },
+  'analysis.no_files': {
+    en: 'No files found to analyze',
+    tr: 'Analiz edilecek dosya bulunamadı',
+  },
+
+  // Export Messages
+  'export.success': {
+    en: 'Export successful',
+    tr: 'Dışa aktarma başarılı',
+  },
+  'export.copied': {
+    en: 'Copied to clipboard',
+    tr: 'Panoya kopyalandı',
+  },
+  'export.saved': {
+    en: 'Saved to file',
+    tr: 'Dosyaya kaydedildi',
+  },
+  'export.failed': {
+    en: 'Export failed',
+    tr: 'Dışa aktarma başarısız',
+  },
+
+  // Error Messages
+  'error.file_not_found': {
+    en: 'File not found',
+    tr: 'Dosya bulunamadı',
+  },
+  'error.permission_denied': {
+    en: 'Permission denied',
+    tr: 'İzin reddedildi',
+  },
+  'error.invalid_format': {
+    en: 'Invalid format',
+    tr: 'Geçersiz format',
+  },
+  'error.missing_param': {
+    en: 'Missing required parameter',
+    tr: 'Gerekli parametre eksik',
+  },
+  'error.unsupported_lang': {
+    en: 'Unsupported language',
+    tr: 'Desteklenmeyen dil',
+  },
+  'error.git_not_found': {
+    en: 'Git repository not found',
+    tr: 'Git deposu bulunamadı',
+  },
+  'error.tiktoken_unavailable': {
+    en: 'tiktoken not available, using estimation mode',
+    tr: 'tiktoken mevcut değil, tahmin modu kullanılıyor',
+  },
+
+  // Success Messages
+  'success.server_started': {
+    en: 'API server started',
+    tr: 'API sunucusu başlatıldı',
+  },
+  'success.server_stopped': {
+    en: 'API server stopped',
+    tr: 'API sunucusu durduruldu',
+  },
+  'success.cache_cleared': {
+    en: 'Cache cleared successfully',
+    tr: 'Önbellek başarıyla temizlendi',
+  },
+  'success.config_saved': {
+    en: 'Configuration saved',
+    tr: 'Yapılandırma kaydedildi',
+  },
+
+  // Warning Messages
+  'warning.large_project': {
+    en: 'Large project detected, analysis may take longer',
+    tr: 'Büyük proje tespit edildi, analiz daha uzun sürebilir',
+  },
+  'warning.token_limit': {
+    en: 'Token limit exceeded, some files may be excluded',
+    tr: 'Token limiti aşıldı, bazı dosyalar hariç tutulabilir',
+  },
+  'warning.no_methods': {
+    en: 'No methods found in the specified files',
+    tr: 'Belirtilen dosyalarda method bulunamadı',
+  },
+
+  // Info Messages
+  'info.watch_mode': {
+    en: 'Watching for file changes...',
+    tr: 'Dosya değişiklikleri izleniyor...',
+  },
+  'info.press_exit': {
+    en: 'Press Ctrl+C to exit',
+    tr: 'Çıkmak için Ctrl+C tuşlarına basın',
+  },
+  'info.using_cache': {
+    en: 'Using cached results',
+    tr: 'Önbelleğe alınmış sonuçlar kullanılıyor',
+  },
+  'info.checking_updates': {
+    en: 'Checking for updates...',
+    tr: 'Güncellemeler kontrol ediliyor...',
+  },
+
+  // Git Integration Messages
+  'git.no_changes': {
+    en: 'No changes detected',
+    tr: 'Değişiklik tespit edilmedi',
+  },
+  'git.changes_found': {
+    en: 'Changes found in {count} files',
+    tr: '{count} dosyada değişiklik bulundu',
+  },
+  'git.branch_switch': {
+    en: 'Switched to branch',
+    tr: 'Branch değiştirildi',
+  },
+
+  // API Messages
+  'api.listening': {
+    en: 'Listening on',
+    tr: 'Dinleniyor',
+  },
+  'api.docs_available': {
+    en: 'API documentation available at',
+    tr: 'API dokümantasyonu şu adreste mevcut',
+  },
+  'api.auth_required': {
+    en: 'Authentication required',
+    tr: 'Kimlik doğrulama gerekli',
+  },
+
+  // Progress Messages
+  'progress.scanning': {
+    en: 'Scanning files...',
+    tr: 'Dosyalar taranıyor...',
+  },
+  'progress.analyzing': {
+    en: 'Analyzing tokens...',
+    tr: "Token'lar analiz ediliyor...",
+  },
+  'progress.generating': {
+    en: 'Generating report...',
+    tr: 'Rapor oluşturuluyor...',
+  },
+  'progress.uploading': {
+    en: 'Uploading...',
+    tr: 'Yükleniyor...',
+  },
+
+  // Configuration Messages
+  'config.created': {
+    en: 'Configuration file created',
+    tr: 'Yapılandırma dosyası oluşturuldu',
+  },
+  'config.updated': {
+    en: 'Configuration updated',
+    tr: 'Yapılandırma güncellendi',
+  },
+  'config.not_found': {
+    en: 'Configuration file not found, using defaults',
+    tr: 'Yapılandırma dosyası bulunamadı, varsayılanlar kullanılıyor',
+  },
+
+  // Plugin Messages
+  'plugin.loaded': {
+    en: 'Plugin loaded',
+    tr: 'Plugin yüklendi',
+  },
+  'plugin.not_found': {
+    en: 'Plugin not found',
+    tr: 'Plugin bulunamadı',
+  },
+  'plugin.error': {
+    en: 'Plugin error',
+    tr: 'Plugin hatası',
+  },
+};
+
+// Default language (can be overridden)
+let currentLanguage = 'en';
+
+/**
+ * Detect language from environment
+ * @returns {string} Language code ('en' or 'tr')
+ */
+function detectLanguage() {
+  const lang = process.env.LANG || process.env.LANGUAGE || process.env.LC_ALL || '';
+
+  // Check for Turkish
+  if (lang.toLowerCase().includes('tr') || lang.toLowerCase().includes('tur')) {
+    return 'tr';
+  }
+
+  // Default to English
+  return 'en';
+}
+
+/**
+ * Set the current language
+ * @param {string} lang - Language code ('en' or 'tr')
+ */
+export function setLanguage(lang) {
+  if (lang === 'en' || lang === 'tr') {
+    currentLanguage = lang;
+  } else {
+    console.warn(`Unsupported language: ${lang}, defaulting to English`);
+    currentLanguage = 'en';
+  }
+}
+
+/**
+ * Get the current language
+ * @returns {string} Current language code
+ */
+export function getLanguage() {
+  return currentLanguage;
+}
+
+/**
+ * Get a message by code
+ * @param {string} code - Message code (e.g., 'cli.help.usage')
+ * @param {object} params - Optional parameters for message interpolation
+ * @returns {string} Translated message
+ */
+export function getMessage(code, params = {}) {
+  const message = messages[code];
+
+  if (!message) {
+    console.warn(`Message code not found: ${code}`);
+    return code;
+  }
+
+  let text = message[currentLanguage] || message.en;
+
+  // Interpolate parameters
+  for (const [key, value] of Object.entries(params)) {
+    text = text.replace(new RegExp(`\\{${key}\\}`, 'g'), value);
+  }
+
+  return text;
+}
+
+/**
+ * Get all messages for a language
+ * @param {string} lang - Language code
+ * @returns {object} All messages in the specified language
+ */
+export function getAllMessages(lang = currentLanguage) {
+  const result = {};
+
+  for (const [code, translations] of Object.entries(messages)) {
+    result[code] = translations[lang] || translations.en;
+  }
+
+  return result;
+}
+
+/**
+ * Check if a message code exists
+ * @param {string} code - Message code
+ * @returns {boolean} True if code exists
+ */
+export function hasMessage(code) {
+  return code in messages;
+}
+
+/**
+ * Get message codes by prefix
+ * @param {string} prefix - Message code prefix (e.g., 'error')
+ * @returns {string[]} Array of matching message codes
+ */
+export function getMessagesByPrefix(prefix) {
+  return Object.keys(messages).filter((code) => code.startsWith(prefix));
+}
+
+/**
+ * Format a message with emoji prefix
+ * @param {string} code - Message code
+ * @param {string} emoji - Emoji to prepend
+ * @param {object} params - Optional parameters
+ * @returns {string} Formatted message
+ */
+export function formatMessage(code, emoji = '', params = {}) {
+  const message = getMessage(code, params);
+  return emoji ? `${emoji} ${message}` : message;
+}
+
+// Initialize language on module load
+currentLanguage = detectLanguage();
+
+// Export message codes for external use
+export const MessageCodes = Object.keys(messages).reduce((acc, code) => {
+  acc[code.toUpperCase().replace(/\./g, '_')] = code;
+  return acc;
+}, {});
+
+export default {
+  getMessage,
+  getAllMessages,
+  setLanguage,
+  getLanguage,
+  hasMessage,
+  getMessagesByPrefix,
+  formatMessage,
+  MessageCodes,
+};

package/lib/utils/multi-repo-manager.js

@@ -0,0 +1,364 @@
+/**
+ * Multi-Repository Manager
+ * FEAT-006: Multi-Repository Context
+ *
+ * Manages multiple repositories for monorepo or microservices context analysis
+ */
+
+import fs from 'fs';
+import path from 'path';
+import TokenCalculator from '../analyzers/token-calculator.js';
+import { getLogger } from './logger.js';
+
+const logger = getLogger('MultiRepoManager');
+
+/**
+ * Default configuration structure for repos.json
+ */
+const DEFAULT_CONFIG = {
+  version: '1.0',
+  repos: [],
+};
+
+/**
+ * MultiRepoManager - Handles multi-repository context analysis
+ *
+ * Features:
+ * - Add/remove repositories
+ * - Per-repo token analysis
+ * - Combined context generation
+ * - Repository configuration persistence
+ */
+export class MultiRepoManager {
+  /**
+   * @param {string} projectRoot - Root directory for configuration
+   * @param {object} options - Configuration options
+   */
+  constructor(projectRoot, options = {}) {
+    this.projectRoot = projectRoot;
+    this.configPath = options.configPath || path.join(projectRoot, '.ctxman', 'repos.json');
+    this.config = null;
+    this.options = {
+      autoSave: true,
+      ...options,
+    };
+  }
+
+  /**
+   * Load repository configuration from file
+   * @returns {object} Configuration object
+   */
+  load() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const content = fs.readFileSync(this.configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Deep clone to avoid reference issues
+        this.config = {
+          version: parsed.version || '1.0',
+          repos: Array.isArray(parsed.repos) ? [...parsed.repos] : [],
+        };
+        logger.info(`Loaded ${this.config.repos.length} repositories from config`);
+        return this.config;
+      }
+    } catch (error) {
+      logger.warn(`Failed to load config: ${error.message}`);
+    }
+
+    // Return default config if file doesn't exist
+    this.config = { ...DEFAULT_CONFIG, repos: [] };
+    return this.config;
+  }
+
+  /**
+   * Save repository configuration to file
+   */
+  save() {
+    // Ensure directory exists
+    const configDir = path.dirname(this.configPath);
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+    logger.info(`Saved configuration to ${this.configPath}`);
+  }
+
+  /**
+   * Add a repository to configuration
+   * @param {string} repoPath - Path to repository (relative or absolute)
+   * @param {object} options - Repository options
+   * @returns {object} Added repository configuration
+   */
+  addRepo(repoPath, options = {}) {
+    if (!this.config) {
+      this.load();
+    }
+
+    // Resolve path
+    const resolvedPath = this.resolvePath(repoPath);
+
+    // Check if repo already exists
+    const existingIndex = this.config.repos.findIndex(
+      (r) => this.resolvePath(r.path) === resolvedPath
+    );
+
+    if (existingIndex !== -1) {
+      logger.warn(`Repository already exists: ${repoPath}`);
+      return this.config.repos[existingIndex];
+    }
+
+    // Create repo entry
+    const repoId = options.id || this.generateRepoId(repoPath);
+    const repo = {
+      id: repoId,
+      path: repoPath,
+      alias: options.alias || path.basename(resolvedPath),
+      exclude: options.exclude || ['node_modules/**', 'dist/**', 'build/**', 'coverage/**'],
+      weight: options.weight || 1.0,
+    };
+
+    this.config.repos.push(repo);
+
+    if (this.options.autoSave) {
+      this.save();
+    }
+
+    logger.info(`Added repository: ${repo.alias} (${repoPath})`);
+    return repo;
+  }
+
+  /**
+   * Remove a repository from configuration
+   * @param {string} repoPath - Path to repository
+   * @returns {boolean} True if removed, false if not found
+   */
+  removeRepo(repoPath) {
+    if (!this.config) {
+      this.load();
+    }
+
+    const resolvedPath = this.resolvePath(repoPath);
+    const initialLength = this.config.repos.length;
+
+    this.config.repos = this.config.repos.filter((r) => this.resolvePath(r.path) !== resolvedPath);
+
+    if (this.config.repos.length < initialLength) {
+      if (this.options.autoSave) {
+        this.save();
+      }
+      logger.info(`Removed repository: ${repoPath}`);
+      return true;
+    }
+
+    logger.warn(`Repository not found: ${repoPath}`);
+    return false;
+  }
+
+  /**
+   * List all configured repositories
+   * @returns {Array} List of repository configurations
+   */
+  listRepos() {
+    if (!this.config) {
+      this.load();
+    }
+
+    return this.config.repos || [];
+  }
+
+  /**
+   * Analyze all repositories and return combined stats
+   * @param {object} options - Analysis options
+   * @returns {object} Combined analysis results
+   */
+  analyzeAll(options = {}) {
+    if (!this.config) {
+      this.load();
+    }
+
+    const results = {
+      repos: [],
+      combined: {
+        totalFiles: 0,
+        totalTokens: 0,
+        totalLines: 0,
+        totalBytes: 0,
+      },
+    };
+
+    for (const repo of this.config.repos) {
+      const repoResult = this.analyzeRepo(repo, options);
+      results.repos.push(repoResult);
+
+      results.combined.totalFiles += repoResult.files;
+      results.combined.totalTokens += repoResult.tokens;
+      results.combined.totalLines += repoResult.lines;
+      results.combined.totalBytes += repoResult.bytes;
+    }
+
+    // Calculate percentages
+    for (const repo of results.repos) {
+      repo.percentage =
+        results.combined.totalTokens > 0
+          ? ((repo.tokens / results.combined.totalTokens) * 100).toFixed(1)
+          : 0;
+    }
+
+    logger.info(`Analyzed ${results.repos.length} repositories`);
+    return results;
+  }
+
+  /**
+   * Analyze a single repository
+   * @param {object} repo - Repository configuration
+   * @param {object} options - Analysis options
+   * @returns {object} Repository analysis result
+   */
+  analyzeRepo(repo, options = {}) {
+    const resolvedPath = this.resolvePath(repo.path);
+    const repoResult = {
+      id: repo.id,
+      alias: repo.alias,
+      path: repo.path,
+      resolvedPath,
+      files: 0,
+      tokens: 0,
+      lines: 0,
+      bytes: 0,
+      byExtension: {},
+    };
+
+    try {
+      if (!fs.existsSync(resolvedPath)) {
+        logger.warn(`Repository path does not exist: ${resolvedPath}`);
+        repoResult.error = 'Path does not exist';
+        return repoResult;
+      }
+
+      // Create analyzer with repo-specific excludes
+      const analyzer = new TokenCalculator(resolvedPath, {
+        verbose: false,
+        simple: true,
+        ...options,
+      });
+
+      // Run analysis
+      const stats = analyzer.run();
+
+      if (stats) {
+        repoResult.files = stats.totalFiles || 0;
+        repoResult.tokens = stats.totalTokens || 0;
+        repoResult.lines = stats.totalLines || 0;
+        repoResult.bytes = stats.totalBytes || 0;
+        repoResult.byExtension = stats.byExtension || {};
+        repoResult.largestFiles = stats.largestFiles || [];
+      }
+    } catch (error) {
+      logger.error(`Failed to analyze repo ${repo.alias}: ${error.message}`);
+      repoResult.error = error.message;
+    }
+
+    return repoResult;
+  }
+
+  /**
+   * Resolve repository path (relative or absolute)
+   * @param {string} repoPath - Repository path
+   * @returns {string} Resolved absolute path
+   */
+  resolvePath(repoPath) {
+    if (path.isAbsolute(repoPath)) {
+      return repoPath;
+    }
+    return path.resolve(this.projectRoot, repoPath);
+  }
+
+  /**
+   * Generate a unique repository ID from path
+   * @param {string} repoPath - Repository path
+   * @returns {string} Generated ID
+   */
+  generateRepoId(repoPath) {
+    const basename = path.basename(repoPath);
+    const timestamp = Date.now().toString(36);
+    return `${basename}-${timestamp}`;
+  }
+
+  /**
+   * Format analysis results for display
+   * @param {object} results - Analysis results
+   * @returns {string} Formatted output
+   */
+  formatResults(results) {
+    const lines = [];
+
+    lines.push('🔀 Multi-Repository Context Analysis:');
+    lines.push('═'.repeat(50));
+
+    if (results.repos.length === 0) {
+      lines.push('   No repositories configured.');
+      lines.push('   Use --add-repo <path> to add repositories.');
+      return lines.join('\n');
+    }
+
+    lines.push(`   Repositories: ${results.repos.length}`);
+    lines.push('');
+
+    results.repos.forEach((repo, index) => {
+      const num = `${index + 1}.`;
+      lines.push(`   ${num} ${repo.alias} (${repo.path})`);
+
+      if (repo.error) {
+        lines.push(`      ⚠️  Error: ${repo.error}`);
+      } else {
+        lines.push(`      Files: ${repo.files.toLocaleString()}`);
+        lines.push(`      Tokens: ${repo.tokens.toLocaleString()} (${repo.percentage}%)`);
+      }
+      lines.push('');
+    });
+
+    lines.push('   ' + '─'.repeat(46));
+    lines.push(
+      `   Combined Total: ${results.combined.totalFiles.toLocaleString()} files, ${results.combined.totalTokens.toLocaleString()} tokens`
+    );
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format repository list for display
+   * @returns {string} Formatted output
+   */
+  formatList() {
+    const repos = this.listRepos();
+
+    if (repos.length === 0) {
+      return 'No repositories configured.\nUse --add-repo <path> to add a repository.';
+    }
+
+    const lines = [];
+    lines.push('📋 Configured Repositories:');
+    lines.push('═'.repeat(50));
+
+    repos.forEach((repo, index) => {
+      const resolvedPath = this.resolvePath(repo.path);
+      const exists = fs.existsSync(resolvedPath);
+      const status = exists ? '✓' : '⚠';
+
+      lines.push(`${status} ${index + 1}. ${repo.alias}`);
+      lines.push(`   Path: ${repo.path}`);
+      lines.push(`   ID: ${repo.id}`);
+
+      if (!exists) {
+        lines.push(`   ⚠️  Path does not exist`);
+      }
+      lines.push('');
+    });
+
+    lines.push(`Total: ${repos.length} repositories`);
+    return lines.join('\n');
+  }
+}
+
+export default MultiRepoManager;