analyze-codebase 1.2.2 → 1.3.1

package/dist/analyze/i18n/index.js

@@ -0,0 +1,477 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeAndRemoveUnusedKeys = exports.findUnusedKeys = exports.flattenKeys = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const readline = __importStar(require("readline"));
+const progress_1 = require("../../utils/progress");
+const spinner_1 = require("../../utils/spinner");
+const cancellation_1 = require("../../utils/cancellation");
+/**
+ * Flattens a nested JSON object into dot-notation paths
+ */
+const flattenKeys = (obj, prefix = "", originalPath = []) => {
+    const keys = [];
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            const currentPath = prefix ? `${prefix}.${key}` : key;
+            const currentOriginalPath = [...originalPath, key];
+            const value = obj[key];
+            if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                // Recursively flatten nested objects
+                keys.push(...(0, exports.flattenKeys)(value, currentPath, currentOriginalPath));
+            }
+            else {
+                // Leaf node - this is a translation key
+                keys.push({
+                    path: currentPath,
+                    value,
+                    originalPath: currentOriginalPath,
+                });
+            }
+        }
+    }
+    return keys;
+};
+exports.flattenKeys = flattenKeys;
+/**
+ * Checks if a key is a parent of another key
+ * e.g., "a.b" is a parent of "a.b.c"
+ */
+const isParentKey = (parentKey, childKey) => {
+    if (!childKey.startsWith(parentKey))
+        return false;
+    // Check if the next character is a dot (to ensure it's a proper parent)
+    return childKey.length === parentKey.length || childKey[parentKey.length] === '.';
+};
+/**
+ * Searches for a translation key in file content
+ * Handles various i18n usage patterns:
+ * - t('key')
+ * - t("key")
+ * - t(`key`)
+ * - t(`a.b.${variable}`) - Dynamic keys with template literals
+ * - t('a.b.' + variable) - Dynamic keys with string concatenation
+ * - i18n.t('key')
+ * - $t('key')
+ * - {t('key')}
+ * - translate('key')
+ */
+const searchKeyInContent = (content, key, allKeys) => {
+    // Escape special regex characters in the key
+    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Patterns to match static i18n usage:
+    // - t('key'), t("key"), t(`key`)
+    // - i18n.t('key')
+    // - $t('key')
+    // - translate('key')
+    // - ['key'], ["key"], [`key`] (for array access)
+    // - .key (for object access)
+    const staticPatterns = [
+        // Function calls: t('key'), i18n.t('key'), $t('key'), translate('key')
+        new RegExp(`(?:t|i18n\\.t|\\$t|translate)\\s*\\(\\s*['"\`]${escapedKey}['"\`]`, "g"),
+        // Array access: ['key'], ["key"], [`key`]
+        new RegExp(`\\[\\s*['"\`]${escapedKey}['"\`]\\s*\\]`, "g"),
+        // Object access: .key (but not as part of another key)
+        new RegExp(`\\.${escapedKey}(?:\\s|;|,|\\)|\\]|\\}|\\n|$)`, "g"),
+        // String contains the full key path
+        new RegExp(`['"\`]${escapedKey}['"\`]`, "g"),
+    ];
+    // Check for static matches first
+    if (staticPatterns.some((pattern) => pattern.test(content))) {
+        return { found: true, isDynamic: false };
+    }
+    // Check for dynamic patterns (template literals with interpolation)
+    // Pattern: t(`a.b.${variable}`) or t(`a.b.${var1}.${var2}`)
+    // We need to check if the key is a parent of any dynamically constructed key
+    const keyParts = key.split('.');
+    // Build patterns for dynamic key construction
+    // Match: t(`prefix.${variable}`) where prefix matches our key or is a parent
+    for (let i = 0; i < keyParts.length; i++) {
+        const partialKey = keyParts.slice(0, i + 1).join('.');
+        const escapedPartialKey = partialKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        // Pattern for template literals: t(`a.b.${...}`)
+        // Escape backticks properly in regex
+        const templateLiteralPattern = new RegExp("(?:t|i18n\\.t|\\$t|translate)\\s*\\(\\s*`[^`]*" + escapedPartialKey + "[^`]*\\$\\{[^}]+\\}[^`]*`", "g");
+        // Pattern for string concatenation: t('a.b.' + variable) or t("a.b." + variable)
+        const concatPattern1 = new RegExp(`(?:t|i18n\\.t|\\$t|translate)\\s*\\(\\s*['"\`]${escapedPartialKey}\\.?['"\`]\\s*\\+`, "g");
+        // Pattern for reverse concatenation: t(variable + '.a.b')
+        const concatPattern2 = new RegExp(`(?:t|i18n\\.t|\\$t|translate)\\s*\\([^)]*\\+\\s*['"\`]\\.?${escapedPartialKey}['"\`]`, "g");
+        if (templateLiteralPattern.test(content) ||
+            concatPattern1.test(content) ||
+            concatPattern2.test(content)) {
+            // If we found a dynamic pattern that matches this key or its parent,
+            // mark this key and all its children as potentially used
+            return { found: true, isDynamic: true };
+        }
+    }
+    // Check if this key is a child of any dynamically used parent key
+    // This handles cases where we have t(`a.b.${var}`) and need to mark a.b.c, a.b.d, etc. as used
+    // Check all possible parent keys of the current key
+    const currentKeyParts = key.split('.');
+    for (let i = 1; i < currentKeyParts.length; i++) {
+        const parentKey = currentKeyParts.slice(0, i).join('.');
+        const escapedParentKey = parentKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        // Check if parent key is used in dynamic patterns
+        const dynamicPattern = new RegExp("(?:t|i18n\\.t|\\$t|translate)\\s*\\(\\s*`[^`]*" + escapedParentKey + "[^`]*\\$\\{[^}]+\\}", "g");
+        const concatPattern = new RegExp("(?:t|i18n\\.t|\\$t|translate)\\s*\\(\\s*['\"`]" + escapedParentKey + "\\.?['\"`]\\s*\\+", "g");
+        if (dynamicPattern.test(content) || concatPattern.test(content)) {
+            return { found: true, isDynamic: true };
+        }
+    }
+    return { found: false, isDynamic: false };
+};
+/**
+ * Collects all files to analyze
+ */
+const collectFiles = async (directory, extensions, exclude) => {
+    const patterns = [];
+    const ignorePatterns = [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/coverage/**",
+        "**/.git/**",
+        "**/.next/**",
+        "**/public/**",
+        "**/test/**",
+        "**/tests/**",
+        "**/mocks/**",
+    ];
+    if (exclude) {
+        ignorePatterns.push(...exclude.map((ex) => `**/${ex}/**`));
+    }
+    const fileExtensions = extensions || [".ts", ".tsx", ".js", ".jsx", ".vue"];
+    patterns.push(...fileExtensions.map((ext) => `**/*${ext}`));
+    const files = await (0, fast_glob_1.default)(patterns, {
+        cwd: directory,
+        ignore: ignorePatterns,
+        absolute: true,
+        onlyFiles: true,
+        dot: false,
+    });
+    return files;
+};
+/**
+ * Searches the codebase for usage of translation keys
+ */
+const findUnusedKeys = async (options) => {
+    const { directory, i18nFile, extensions, exclude, maxConcurrency: providedConcurrency } = options;
+    const cancellationToken = new cancellation_1.CancellationToken();
+    // Read and parse the i18n file
+    const i18nFilePath = path.isAbsolute(i18nFile)
+        ? i18nFile
+        : path.join(directory, i18nFile);
+    const spinner = (0, spinner_1.createSpinner)("📖 Loading translation file...");
+    // Cleanup on cancellation
+    cancellationToken.onCancel(() => {
+        spinner.stop();
+    });
+    let i18nContent;
+    try {
+        const fileContent = await fs.readFile(i18nFilePath, "utf-8");
+        i18nContent = JSON.parse(fileContent);
+        spinner.succeed("✅ Translation file loaded");
+    }
+    catch (error) {
+        spinner.fail(`❌ Failed to read translation file`);
+        throw new Error(`Failed to read or parse i18n file: ${i18nFilePath}. ${error}`);
+    }
+    // Flatten all keys
+    const allKeys = (0, exports.flattenKeys)(i18nContent);
+    // Show key count with animation
+    const keySpinner = (0, spinner_1.createSpinner)(`🔍 Found ${chalk_1.default.cyan(allKeys.length)} translation keys to check...`);
+    await new Promise((resolve) => setTimeout(resolve, 500)); // Brief animation
+    keySpinner.succeed(`✅ Found ${chalk_1.default.cyan(allKeys.length)} translation keys to check`);
+    // Collect files
+    const fileSpinner = (0, spinner_1.createSpinner)("📁 Discovering files...");
+    const files = await collectFiles(directory, extensions, exclude);
+    fileSpinner.succeed(`✅ Found ${chalk_1.default.cyan(files.length)} files to analyze`);
+    // Track which keys are used
+    const usedKeys = new Set();
+    const dynamicKeys = new Set(); // Keys that are used dynamically
+    const keyUsageMap = new Map(); // key -> array of file paths where it's used
+    // Progress bar for file processing (primary indicator)
+    const fileProgressBar = new progress_1.ProgressBar({
+        total: files.length,
+        format: `${chalk_1.default.blue("{bar}")} | ${chalk_1.default.yellow("{percentage}%")} | ${chalk_1.default.white("Processing files: {value}/{total}")}`,
+    });
+    // Cleanup progress bar on cancellation
+    cancellationToken.onCancel(() => {
+        fileProgressBar.stop();
+        console.log(chalk_1.default.yellow("\n\n⚠️  Cancellation requested. Cleaning up...\n"));
+    });
+    // Track progress
+    let processedFiles = 0;
+    let totalKeyChecks = 0;
+    const keysCheckedPerFile = new Map();
+    // Process files in parallel batches with optimized concurrency
+    // For file I/O operations, optimal concurrency is lower to avoid I/O contention
+    // Too high concurrency can actually slow things down due to disk I/O bottlenecks
+    const fileCount = files.length;
+    // Optimal concurrency for file I/O: 20-30 is usually the sweet spot
+    // Higher concurrency doesn't help much with disk I/O and can cause contention
+    const defaultConcurrency = fileCount > 500 ? 30 : fileCount > 100 ? 25 : 20;
+    const maxConcurrency = providedConcurrency || defaultConcurrency;
+    // Show key checking progress as we process files
+    console.log(chalk_1.default.cyan(`\n🔍 Checking ${chalk_1.default.bold(allKeys.length)} translation keys across ${chalk_1.default.bold(files.length)} files...\n` +
+        chalk_1.default.gray(`   Using ${maxConcurrency} concurrent file readers (optimal for I/O performance)\n`)));
+    // Pre-compile regex patterns for all keys to avoid recompiling
+    const keyPatterns = new Map();
+    const dynamicPatterns = new Map();
+    for (const keyData of allKeys) {
+        const escapedKey = keyData.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const keyParts = keyData.path.split('.');
+        // Static patterns
+        const staticPatterns = [
+            new RegExp(`(?:t|i18n\\.t|\\$t|translate)\\s*\\(\\s*['"\`]${escapedKey}['"\`]`, "g"),
+            new RegExp(`\\[\\s*['"\`]${escapedKey}['"\`]\\s*\\]`, "g"),
+            new RegExp(`\\.${escapedKey}(?:\\s|;|,|\\)|\\]|\\}|\\n|$)`, "g"),
+            new RegExp(`['"\`]${escapedKey}['"\`]`, "g"),
+        ];
+        keyPatterns.set(keyData.path, staticPatterns);
+        // Dynamic patterns for parent keys
+        const dynPatterns = [];
+        for (let i = 0; i < keyParts.length; i++) {
+            const partialKey = keyParts.slice(0, i + 1).join('.');
+            const escapedPartialKey = partialKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            dynPatterns.push(new RegExp("(?:t|i18n\\.t|\\$t|translate)\\s*\\(\\s*`[^`]*" + escapedPartialKey + "[^`]*\\$\\{[^}]+\\}[^`]*`", "g"), new RegExp("(?:t|i18n\\.t|\\$t|translate)\\s*\\(\\s*['\"`]" + escapedPartialKey + "\\.?['\"`]\\s*\\+", "g"), new RegExp("(?:t|i18n\\.t|\\$t|translate)\\s*\\([^)]*\\+\\s*['\"`]\\.?" + escapedPartialKey + "['\"`]", "g"));
+        }
+        dynamicPatterns.set(keyData.path, dynPatterns);
+    }
+    // Optimized: Process files in large batches with optimal concurrency
+    const processFile = async (filePath) => {
+        // Check cancellation before processing
+        if (cancellationToken.isCancelled()) {
+            throw new Error("Operation cancelled by user");
+        }
+        try {
+            const content = await fs.readFile(filePath, "utf-8");
+            // Optimized: Check all unused keys in a single pass
+            // Only check keys that haven't been marked as used yet
+            const keysToCheck = allKeys.filter((key) => !usedKeys.has(key.path));
+            // Check cancellation periodically
+            if (cancellationToken.isCancelled()) {
+                throw new Error("Operation cancelled by user");
+            }
+            // Process keys in smaller batches to allow cancellation checks
+            const keyBatchSize = 100; // Check 100 keys at a time
+            for (let i = 0; i < keysToCheck.length; i += keyBatchSize) {
+                if (cancellationToken.isCancelled()) {
+                    throw new Error("Operation cancelled by user");
+                }
+                const keyBatch = keysToCheck.slice(i, i + keyBatchSize);
+                for (const keyData of keyBatch) {
+                    totalKeyChecks++;
+                    // Check static patterns first (faster)
+                    const staticPats = keyPatterns.get(keyData.path);
+                    if (staticPats.some((pattern) => pattern.test(content))) {
+                        usedKeys.add(keyData.path);
+                        if (!keyUsageMap.has(keyData.path)) {
+                            keyUsageMap.set(keyData.path, []);
+                        }
+                        keyUsageMap.get(keyData.path).push(filePath);
+                        continue;
+                    }
+                    // Check dynamic patterns
+                    const dynPats = dynamicPatterns.get(keyData.path);
+                    if (dynPats.some((pattern) => pattern.test(content))) {
+                        usedKeys.add(keyData.path);
+                        dynamicKeys.add(keyData.path);
+                        // If this is a parent key used dynamically, mark all children as potentially used
+                        for (const otherKey of allKeys) {
+                            if (isParentKey(keyData.path, otherKey.path)) {
+                                usedKeys.add(otherKey.path);
+                                dynamicKeys.add(otherKey.path);
+                            }
+                        }
+                        if (!keyUsageMap.has(keyData.path)) {
+                            keyUsageMap.set(keyData.path, []);
+                        }
+                        keyUsageMap.get(keyData.path).push(filePath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Re-throw cancellation errors
+            if ((error === null || error === void 0 ? void 0 : error.message) === "Operation cancelled by user") {
+                throw error;
+            }
+            // Skip files that can't be read
+            // Silently skip to avoid cluttering output
+        }
+        if (!cancellationToken.isCancelled()) {
+            processedFiles++;
+            fileProgressBar.update(1);
+        }
+    };
+    // Process files in parallel batches
+    const batches = [];
+    for (let i = 0; i < files.length; i += maxConcurrency) {
+        batches.push(files.slice(i, i + maxConcurrency));
+    }
+    // Process all batches with cancellation support
+    try {
+        for (const batch of batches) {
+            // Check cancellation before each batch
+            if (cancellationToken.isCancelled()) {
+                fileProgressBar.stop();
+                throw new Error("Operation cancelled by user");
+            }
+            // Use Promise.allSettled to handle cancellation better
+            const results = await Promise.allSettled(batch.map(async (filePath) => {
+                if (cancellationToken.isCancelled()) {
+                    throw new Error("Operation cancelled by user");
+                }
+                return processFile(filePath);
+            }));
+            // Check if any promise was cancelled
+            const cancelled = results.some((result) => {
+                var _a;
+                return result.status === "rejected" &&
+                    ((_a = result.reason) === null || _a === void 0 ? void 0 : _a.message) === "Operation cancelled by user";
+            });
+            if (cancelled || cancellationToken.isCancelled()) {
+                fileProgressBar.stop();
+                throw new Error("Operation cancelled by user");
+            }
+        }
+    }
+    catch (error) {
+        fileProgressBar.stop();
+        if ((error === null || error === void 0 ? void 0 : error.message) === "Operation cancelled by user" || cancellationToken.isCancelled()) {
+            throw new Error("Operation cancelled by user");
+        }
+        throw error;
+    }
+    cancellationToken.throwIfCancelled();
+    fileProgressBar.complete();
+    // Show summary with dynamic key information
+    if (dynamicKeys.size > 0) {
+        console.log(chalk_1.default.yellow(`\n⚠️  Note: Found ${chalk_1.default.bold(dynamicKeys.size)} keys used dynamically (e.g., t(\`a.b.\${var}\`))\n` +
+            chalk_1.default.gray(`   These keys and their children are marked as used to prevent false positives.\n`)));
+    }
+    console.log(chalk_1.default.green(`\n✅ Completed: Checked ${chalk_1.default.cyan(allKeys.length)} translation keys across ${chalk_1.default.cyan(processedFiles)} files\n`));
+    // Find unused keys
+    const unusedKeys = allKeys.filter((key) => !usedKeys.has(key.path));
+    return unusedKeys;
+};
+exports.findUnusedKeys = findUnusedKeys;
+/**
+ * Removes a key from a nested object using the original path
+ */
+const removeKeyFromObject = (obj, path) => {
+    if (path.length === 0)
+        return;
+    const [currentKey, ...remainingPath] = path;
+    if (remainingPath.length === 0) {
+        // This is the final key, delete it
+        delete obj[currentKey];
+    }
+    else {
+        // Navigate deeper
+        if (obj[currentKey] && typeof obj[currentKey] === "object") {
+            removeKeyFromObject(obj[currentKey], remainingPath);
+            // Clean up empty objects
+            if (Object.keys(obj[currentKey]).length === 0) {
+                delete obj[currentKey];
+            }
+        }
+    }
+};
+/**
+ * Prompts user for confirmation
+ */
+const askConfirmation = (question) => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        });
+    });
+};
+/**
+ * Analyzes and removes unused i18n keys
+ */
+const analyzeAndRemoveUnusedKeys = async (options) => {
+    const { directory, i18nFile } = options;
+    const i18nFilePath = path.isAbsolute(i18nFile)
+        ? i18nFile
+        : path.join(directory, i18nFile);
+    console.log(chalk_1.default.bold(`\nAnalyzing unused translation keys in ${chalk_1.default.cyan(i18nFilePath)}\n`));
+    try {
+        // Find unused keys
+        const unusedKeys = await (0, exports.findUnusedKeys)(options);
+        // Check if cancelled
+        if (unusedKeys.length === 0 && !options.maxConcurrency) {
+            // This might be a cancellation, but we'll let it through for now
+        }
+        if (unusedKeys.length === 0) {
+            console.log(chalk_1.default.green("\n✓ No unused translation keys found!\n"));
+            return;
+        }
+        // Display unused keys
+        console.log(chalk_1.default.yellow(`\nFound ${chalk_1.default.bold(unusedKeys.length)} unused translation key(s):\n`));
+        unusedKeys.forEach((key, index) => {
+            console.log(chalk_1.default.gray(`${index + 1}. `) + chalk_1.default.white(key.path) + chalk_1.default.gray(` (${JSON.stringify(key.value)})`));
+        });
+        // Ask for confirmation
+        const confirmed = await askConfirmation(chalk_1.default.yellow(`\nDo you want to remove these ${unusedKeys.length} unused key(s)? (y/n): `));
+        if (!confirmed) {
+            console.log(chalk_1.default.gray("\nOperation cancelled.\n"));
+            return;
+        }
+        // Read the original file
+        const fileContent = await fs.readFile(i18nFilePath, "utf-8");
+        const i18nContent = JSON.parse(fileContent);
+        // Remove unused keys
+        for (const key of unusedKeys) {
+            removeKeyFromObject(i18nContent, key.originalPath);
+        }
+        // Write back to file
+        await fs.writeFile(i18nFilePath, JSON.stringify(i18nContent, null, 2) + "\n", "utf-8");
+        console.log(chalk_1.default.green(`\n✓ Successfully removed ${unusedKeys.length} unused translation key(s) from ${i18nFilePath}\n`));
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.message) === "Operation cancelled by user") {
+            console.log(chalk_1.default.yellow("\n\n✅ Analysis cancelled by user\n"));
+            process.exit(130); // Standard exit code for SIGINT
+        }
+        console.error(chalk_1.default.red(`\nError: ${error}\n`));
+        process.exit(1);
+    }
+};
+exports.analyzeAndRemoveUnusedKeys = analyzeAndRemoveUnusedKeys;