locai 2.1.0

package/dist/utils/state-manager.js

@@ -0,0 +1,162 @@
+import crypto from "crypto";
+import { FileManager } from "./file-manager.js"; // Note: Changed named import to default import based on file-manager migration
+import path from "path";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * StateManager - Tracks changes in source locale files using hash-based state management
+ * This enables detection of deleted/modified keys to synchronize target locale files
+ */
+class StateManager {
+    options;
+    constructor(options = {}) {
+        // Support both direct options and nested stateTracking config
+        const stateTracking = "stateTracking" in options ? options.stateTracking : options;
+        this.options = {
+            enabled: stateTracking.enabled !== false,
+            stateFileName: stateTracking.stateFileName || "localization.state.json",
+            stateDir: stateTracking.stateDir || ".localize-cache",
+            ...stateTracking,
+        };
+    }
+    /**
+     * Generate a SHA-256 hash for given text content
+     */
+    _generateHash(text) {
+        if (typeof text !== "string") {
+            text = JSON.stringify(text);
+        }
+        return crypto.createHash("sha256").update(text, "utf8").digest("hex");
+    }
+    /**
+     * Get the full path to the state file
+     */
+    _getStateFilePath(projectRoot) {
+        const stateDir = path.join(projectRoot, this.options.stateDir);
+        return path.join(stateDir, this.options.stateFileName);
+    }
+    /**
+     * Load previous state from state file
+     */
+    async loadState(projectRoot) {
+        try {
+            const stateFilePath = this._getStateFilePath(projectRoot);
+            const state = await FileManager.readJSON(stateFilePath);
+            return state || {};
+        }
+        catch (error) {
+            // State file doesn't exist or is corrupted - return empty state
+            if (error.message.includes("File read error") || error.code === "ENOENT") {
+                return {};
+            }
+            throw new Error(`Failed to load state: ${error.message}`);
+        }
+    }
+    /**
+     * Save current state to state file
+     */
+    async saveState(projectRoot, state) {
+        try {
+            const stateFilePath = this._getStateFilePath(projectRoot);
+            // Ensure state directory exists
+            const stateDir = path.dirname(stateFilePath);
+            await FileManager.ensureDir(stateDir);
+            // Save state with metadata
+            const stateWithMetadata = {
+                ...state,
+                _metadata: {
+                    lastUpdated: new Date().toISOString(),
+                    version: "1.0.0",
+                    toolVersion: JSON.parse(readFileSync(path.join(__dirname, "../../package.json"), "utf8")).version,
+                },
+            };
+            await FileManager.writeJSON(stateFilePath, stateWithMetadata);
+            return true;
+        }
+        catch (error) {
+            throw new Error(`Failed to save state: ${error.message}`);
+        }
+    }
+    /**
+     * Generate state object from source content by creating hashes for each key
+     */
+    generateStateFromSource(sourceContent) {
+        const state = {};
+        for (const [key, value] of Object.entries(sourceContent)) {
+            // Generate hash for the value content
+            state[key] = this._generateHash(value);
+        }
+        return state;
+    }
+    /**
+     * Compare two states and identify changes
+     */
+    compareStates(previousState, currentState) {
+        const deletedKeys = [];
+        const modifiedKeys = [];
+        const newKeys = [];
+        // Remove metadata from comparison if it exists
+        const cleanPreviousState = { ...previousState };
+        const cleanCurrentState = { ...currentState };
+        delete cleanPreviousState["_metadata"];
+        delete cleanCurrentState["_metadata"];
+        // Find deleted keys (exist in previous but not in current)
+        for (const key of Object.keys(cleanPreviousState)) {
+            if (!(key in cleanCurrentState)) {
+                deletedKeys.push(key);
+            }
+        }
+        // Find modified and new keys
+        for (const [key, currentHash] of Object.entries(cleanCurrentState)) {
+            if (!(key in cleanPreviousState)) {
+                // New key
+                newKeys.push(key);
+            }
+            else if (cleanPreviousState[key] !== currentHash) {
+                // Modified key (hash changed)
+                modifiedKeys.push(key);
+            }
+        }
+        return {
+            deletedKeys,
+            modifiedKeys,
+            newKeys,
+            hasChanges: deletedKeys.length > 0 || modifiedKeys.length > 0 || newKeys.length > 0,
+        };
+    }
+    /**
+     * Get statistics about the state comparison
+     */
+    getComparisonStats(comparison) {
+        return {
+            totalChanges: comparison.deletedKeys.length +
+                comparison.modifiedKeys.length +
+                comparison.newKeys.length,
+            deletedCount: comparison.deletedKeys.length,
+            modifiedCount: comparison.modifiedKeys.length,
+            newCount: comparison.newKeys.length,
+            hasChanges: comparison.hasChanges,
+        };
+    }
+    /**
+     * Clean up old state files (maintenance utility)
+     */
+    async cleanupState(projectRoot) {
+        try {
+            const stateFilePath = this._getStateFilePath(projectRoot);
+            await FileManager.deleteFile(stateFilePath);
+            return true;
+        }
+        catch (error) {
+            // File doesn't exist - that's fine
+            if (error.message.includes("ENOENT")) {
+                return true;
+            }
+            throw new Error(`Failed to cleanup state: ${error.message}`);
+        }
+    }
+}
+export default StateManager;

package/dist/utils/statistics-manager.js

@@ -0,0 +1,51 @@
+/**
+ * Statistics manager to track translation progress and metrics
+ */
+export class StatisticsManager {
+    stats;
+    constructor() {
+        this.stats = this.initializeGlobalStats();
+    }
+    /**
+     * Initialize global statistics structure
+     */
+    initializeGlobalStats() {
+        return {
+            total: 0,
+            byCategory: {},
+            details: {},
+            totalTime: 0,
+            success: 0,
+            failed: 0,
+            skipped: 0,
+            languages: {},
+            startTime: new Date().toISOString(),
+            orchestrators: [],
+        };
+    }
+    /**
+     * Reset statistics
+     */
+    reset() {
+        this.stats = this.initializeGlobalStats();
+    }
+    /**
+     * Get current stats
+     */
+    getStats() {
+        return this.stats;
+    }
+    /**
+     * Initialize language stats
+     */
+    initLanguageStats(langCode) {
+        this.stats.languages[langCode] = {
+            processed: 0,
+            added: 0,
+            skipped: 0,
+            failed: 0,
+            timeMs: 0,
+        };
+    }
+}
+export default new StatisticsManager();

package/dist/utils/ui-manager.js

@@ -0,0 +1,98 @@
+/**
+ * UI Manager for handling CLI output and user interaction
+ */
+export class UIManager {
+    consoleLock;
+    constructor() {
+        this.consoleLock = {
+            queue: [],
+            isLocked: false,
+            async log(message) {
+                return new Promise((resolve) => {
+                    const executeLog = () => {
+                        console.log(message);
+                        this.isLocked = false;
+                        resolve();
+                        this._processQueue();
+                    };
+                    if (this.isLocked) {
+                        this.queue.push(executeLog);
+                    }
+                    else {
+                        this.isLocked = true;
+                        executeLog();
+                    }
+                });
+            },
+            _processQueue() {
+                if (this.queue.length > 0 && !this.isLocked) {
+                    this.isLocked = true;
+                    const nextLog = this.queue.shift();
+                    if (nextLog)
+                        nextLog();
+                }
+            },
+        };
+    }
+    /**
+     * Log a message safely preventing overlap
+     */
+    async log(message) {
+        await this.consoleLock.log(message);
+    }
+    /**
+     * Display global summary of translation
+     */
+    async displayGlobalSummary(stats, totalLanguages) {
+        await this.log("\n" + "=".repeat(60));
+        await this.log("Global Translation Summary");
+        await this.log("=".repeat(60));
+        await this.log(`\nLanguages Processed: ${totalLanguages}`);
+        await this.log(`Total Translations: ${stats.total}`);
+        await this.log(`Success: ${stats.success}`);
+        await this.log(`Failed: ${stats.failed}`);
+        await this.log(`Skipped: ${stats.skipped}`);
+        await this.log(`Total Time: ${stats.totalTime?.toFixed(1) || 0}s`);
+        await this.log(`Average per language: ${(stats.totalTime / (totalLanguages || 1)).toFixed(1)}s`);
+        // Display detailed language stats
+        if (Object.keys(stats.languages).length > 0) {
+            await this.log("\n" + "-".repeat(60));
+            await this.log("Per-language Performance:");
+            await this.log("-".repeat(60));
+            for (const [lang, langStats] of Object.entries(stats.languages)) {
+                const timeSeconds = langStats.timeMs / 1000;
+                await this.log(`  ${lang.padEnd(4)} | ${String(langStats.added).padStart(3)} added | ${String(langStats.skipped).padStart(3)} skipped | ${String(langStats.failed).padStart(2)} failed | ${timeSeconds.toFixed(1)}s`);
+            }
+        }
+        // Only show categories if we have them
+        if (Object.keys(stats.byCategory).length > 0) {
+            await this.log("\n" + "-".repeat(60));
+            await this.log("Context Analysis by Category:");
+            await this.log("-".repeat(60));
+            for (const [category, count] of Object.entries(stats.byCategory)) {
+                const details = stats.details[category];
+                if (details && details.samples > 0) {
+                    const avgConfidence = details.totalConfidence / details.samples;
+                    const confidenceStr = `${(avgConfidence * 100).toFixed(1)}%`;
+                    await this.log(`  ${category}: ${count} items (${confidenceStr} avg confidence)`);
+                }
+                else {
+                    await this.log(`  ${category}: ${count} items`);
+                }
+            }
+        }
+        // Clear completion message - only once
+        await this.log("\n" + "=".repeat(60));
+        const duration = stats.totalDuration || 0;
+        await this.log(`All operations completed successfully in ${duration.toFixed(1)}s`);
+        await this.log("=".repeat(60) + "\n");
+    }
+    async logBatchResults(batchResults) {
+        for (const result of batchResults) {
+            if (result && result.savedMessage) {
+                await this.log(result.savedMessage);
+            }
+        }
+    }
+}
+export default new UIManager();

package/package.json

@@ -0,0 +1,80 @@
+{
+	"name": "locai",
+	"version": "2.1.0",
+	"type": "module",
+	"main": "dist/core/orchestrator.js",
+	"directories": {
+		"src": "src",
+		"dist": "dist"
+	},
+	"bin": {
+		"locai": "./dist/cli.js",
+		"localize": "./dist/cli.js"
+	},
+	"scripts": {
+		"start": "node dist/core/orchestrator.js",
+		"dev": "tsx src/core/orchestrator.js",
+		"build": "tsc",
+		"type-check": "tsc --noEmit",
+		"lint": "eslint .",
+		"lint:fix": "eslint . --fix",
+		"format": "prettier --write \"**/*.{js,json,md,jsx,ts,tsx,css}\"",
+		"format:check": "prettier --check \"**/*.{js,json,md,jsx,ts,tsx,css}\"",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:coverage": "vitest run --coverage",
+		"prepublishOnly": "pnpm build"
+	},
+	"keywords": [
+		"translation",
+		"localization",
+		"i18n",
+		"nextjs",
+		"ai-translation"
+	],
+	"author": {
+		"name": "Ahmet Enes Dur",
+		"email": "ahmetenesdur@gmail.com",
+		"url": "https://github.com/ahmetenesdur"
+	},
+	"license": "ISC",
+	"description": "CLI tool for translating Next.js locale files with advanced settings and multiple AI providers",
+	"engines": {
+		"node": ">=14.13.0"
+	},
+	"exports": {
+		".": "./dist/core/orchestrator.js",
+		"./orchestrator": "./dist/core/orchestrator.js",
+		"./translator": "./dist/commands/translator.js"
+	},
+	"dependencies": {
+		"axios": "1.13.1",
+		"c12": "^3.3.2",
+		"commander": "^14.0.2",
+		"dot-properties": "^1.1.0",
+		"dotenv": "^17.2.3",
+		"gettext-parser": "^8.0.0",
+		"jiti": "^2.6.1",
+		"js-yaml": "^4.1.1",
+		"lru-cache": "^11.2.2",
+		"p-limit": "^7.2.0",
+		"vectra": "^0.11.1"
+	},
+	"devDependencies": {
+		"@eslint/js": "^9.39.1",
+		"@types/js-yaml": "^4.0.9",
+		"@types/node": "^25.0.1",
+		"@vitest/coverage-v8": "^4.0.15",
+		"eslint": "^9.39.1",
+		"eslint-config-prettier": "^10.1.8",
+		"globals": "^16.5.0",
+		"prettier": "^3.6.2",
+		"std-mocks": "^2.0.0",
+		"tsx": "^4.21.0",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.15"
+	},
+	"files": [
+		"dist/"
+	]
+}