locai 2.3.0 → 2.4.0

package/dist/services/translation-service.js

@@ -8,26 +8,13 @@ import InputValidator from "../utils/input-validator.js";
 import gracefulShutdown from "../utils/graceful-shutdown.js";
 import uiManager from "../utils/ui-manager.js";
 import statisticsManager from "../utils/statistics-manager.js";
+import { LanguageProcessor } from "./language-processor.js";
 /**
  * Service for handling file translation operations.
  * Orchestrates the translation process including state management,
  * verification, and statistics collection.
  */
 class TranslationService {
-    /**
-     * Check if text only contains placeholders and whitespace.
-     * @param {string} text - Text to check.
-     * @returns {boolean} - True if text only contains placeholders.
-     */
-    isPlaceholderOnlyText(text) {
-        if (!text || typeof text !== "string") {
-            return false;
-        }
-        // Remove all placeholders from the text
-        const placeholderRegex = /\{[^}]+\}|\$\{[^}]+\}|%[sd]/g;
-        const textWithoutPlaceholders = text.replace(placeholderRegex, "").trim();
-        return textWithoutPlaceholders.length === 0;
-    }
     /**
      * Main translator function to process source file and create translations.
      * @param {string} file - Path to source file.
@@ -201,207 +188,7 @@ class TranslationService {
      * @returns {Promise<LanguageProcessResult>} - Status and messages for this language.
      */
     async processLanguage(targetLang, sourceFile, flattenedSource, orchestrator, options, globalStats, comparison) {
-        const langStartTime = Date.now();
-        try {
-            if (!targetLang || typeof targetLang !== "string") {
-                throw new Error("Invalid target language provided");
-            }
-            if (!sourceFile || typeof sourceFile !== "string") {
-                throw new Error("Invalid source file path provided");
-            }
-            if (!flattenedSource || typeof flattenedSource !== "object") {
-                throw new Error("Invalid flattened source data provided");
-            }
-            if (!orchestrator || typeof orchestrator.processTranslations !== "function") {
-                throw new Error("Invalid orchestrator instance provided");
-            }
-            if (!globalStats || typeof globalStats !== "object") {
-                throw new Error("Invalid global stats object provided");
-            }
-            const safeTargetLang = InputValidator.validateLanguageCode(targetLang, "target language");
-            await uiManager.log(`Starting translations for ${safeTargetLang}`);
-            let finalStatus = null;
-            let savedMessage = undefined;
-            statisticsManager.initLanguageStats(safeTargetLang);
-            const sourceDir = path.dirname(sourceFile);
-            const safeTargetFilename = `${safeTargetLang}.json`;
-            const targetPath = InputValidator.createSafeFilePath(sourceDir, safeTargetFilename);
-            let targetContent = {};
-            try {
-                targetContent = await FileManager.readJSON(targetPath);
-                if (!targetContent || typeof targetContent !== "object") {
-                    console.warn(`Invalid content in ${targetPath}, using empty object`);
-                    targetContent = {};
-                }
-            }
-            catch (err) {
-                if (err.code === "ENOENT") {
-                    await uiManager.log(`\ud83c\udd95 Creating new translation file for ${safeTargetLang}`);
-                }
-                else {
-                    if (options.debug) {
-                        console.warn(`Error reading ${targetPath}: ${err.message}, using empty object`);
-                    }
-                }
-                targetContent = {};
-            }
-            let flattenedTarget = {};
-            try {
-                flattenedTarget = ObjectTransformer.flatten(targetContent);
-                if (!flattenedTarget || typeof flattenedTarget !== "object") {
-                    flattenedTarget = {};
-                }
-            }
-            catch (err) {
-                console.warn(`Error flattening target content: ${err.message}, using empty object`);
-                flattenedTarget = {};
-            }
-            const missingKeys = [];
-            let hasPlaceholderOnlyChanges = false;
-            for (const [key, sourceText] of Object.entries(flattenedSource)) {
-                try {
-                    InputValidator.validateKey(key, "translation key");
-                    InputValidator.validateText(sourceText, "source text");
-                }
-                catch (keyError) {
-                    await uiManager.log(`\u26a0\ufe0f Skipping invalid key/text: ${keyError.message}`);
-                    globalStats.languages[safeTargetLang].failed++;
-                    globalStats.failed++;
-                    continue;
-                }
-                globalStats.languages[safeTargetLang].processed++;
-                if (this.isPlaceholderOnlyText(sourceText)) {
-                    const existingValue = flattenedTarget[key];
-                    if (existingValue !== sourceText) {
-                        flattenedTarget[key] = sourceText;
-                        hasPlaceholderOnlyChanges = true;
-                        if (options.debug) {
-                            await uiManager.log(`   Copying placeholder-only text: "${sourceText}"`);
-                        }
-                    }
-                    globalStats.languages[safeTargetLang].skipped++;
-                    globalStats.skipped++;
-                    continue;
-                }
-                const isNewKey = comparison.newKeys.includes(key);
-                const isModifiedKey = comparison.modifiedKeys.includes(key);
-                const keyExistsInTarget = key in flattenedTarget;
-                if (keyExistsInTarget && !options.forceUpdate && !isModifiedKey) {
-                    globalStats.languages[safeTargetLang].skipped++;
-                    globalStats.skipped++;
-                    continue;
-                }
-                missingKeys.push({
-                    key,
-                    text: sourceText,
-                    targetLang: safeTargetLang,
-                    existingTranslation: flattenedTarget[key],
-                    isModified: isModifiedKey,
-                    isNew: isNewKey,
-                });
-            }
-            if (missingKeys.length === 0 && !hasPlaceholderOnlyChanges) {
-                await uiManager.log(`All translations exist for ${safeTargetLang}`);
-                globalStats.languages[safeTargetLang].timeMs = Date.now() - langStartTime;
-                return { status: { completed: 0, total: 0, language: safeTargetLang } };
-            }
-            if (missingKeys.length > 0) {
-                await uiManager.log(`Found ${missingKeys.length} missing translations for ${safeTargetLang}`);
-            }
-            let results = [];
-            if (missingKeys.length > 0) {
-                try {
-                    results = await orchestrator.processTranslations(missingKeys);
-                    if (!Array.isArray(results)) {
-                        console.warn("Invalid results from orchestrator, using empty array");
-                        results = [];
-                    }
-                }
-                catch (err) {
-                    console.error(`Error processing translations for ${safeTargetLang}: ${err.message}`);
-                    results = [];
-                    if (globalStats.languages[safeTargetLang]) {
-                        globalStats.languages[safeTargetLang].failed += missingKeys.length;
-                        globalStats.failed += missingKeys.length;
-                    }
-                }
-            }
-            else {
-                if (hasPlaceholderOnlyChanges) {
-                    await uiManager.log(`Found placeholder-only changes for ${safeTargetLang}`);
-                }
-            }
-            try {
-                if (orchestrator?.progress &&
-                    typeof orchestrator.progress.getStatus === "function") {
-                    finalStatus = orchestrator.progress.getStatus();
-                }
-            }
-            catch (err) {
-                console.warn(`Error getting orchestrator status: ${err.message}`);
-            }
-            let validResults = [];
-            try {
-                validResults = results.filter((result) => result && result.success === true);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                validResults = validResults.filter((result) => result.key &&
-                    typeof result.key === "string" &&
-                    result.translated &&
-                    typeof result.translated === "string");
-            }
-            catch (err) {
-                console.warn(`Error filtering results: ${err.message}`);
-                validResults = [];
-            }
-            if (validResults.length > 0) {
-                validResults.forEach(({ key, translated }) => {
-                    if (translated) {
-                        flattenedTarget[key] = translated;
-                    }
-                });
-            }
-            const hasChangesToSave = validResults.length > 0 || hasPlaceholderOnlyChanges;
-            if (hasChangesToSave) {
-                const unflattened = ObjectTransformer.unflatten(flattenedTarget);
-                await FileManager.writeJSON(targetPath, unflattened);
-                globalStats.total += validResults.length;
-                globalStats.success += validResults.length;
-                globalStats.failed += results.length - validResults.length;
-                globalStats.languages[safeTargetLang].added += validResults.length;
-                globalStats.languages[safeTargetLang].failed +=
-                    results.length - validResults.length;
-                validResults.forEach((result) => {
-                    if (result.context) {
-                        const category = result.context.category || "general";
-                        globalStats.byCategory[category] =
-                            (globalStats.byCategory[category] || 0) + 1;
-                        if (!globalStats.details[category]) {
-                            globalStats.details[category] = {
-                                totalConfidence: 0,
-                                samples: 0,
-                            };
-                        }
-                        globalStats.details[category].totalConfidence +=
-                            result.context.confidence || 0;
-                        globalStats.details[category].samples++;
-                    }
-                });
-                savedMessage = `Translations saved: ${safeTargetLang}.json`;
-            }
-            globalStats.languages[safeTargetLang].timeMs = Date.now() - langStartTime;
-            return { status: finalStatus, savedMessage };
-        }
-        catch (error) {
-            const safeError = error.message.includes("outside working directory")
-                ? "Invalid file path detected"
-                : error.message;
-            await uiManager.log(`\n\u274c Error processing ${targetLang}: ${safeError}`);
-            if (globalStats.languages[targetLang]) {
-                globalStats.languages[targetLang].error = safeError;
-                globalStats.languages[targetLang].timeMs = Date.now() - langStartTime;
-            }
-            return { status: null, error: safeError };
-        }
+        return await LanguageProcessor.processLanguage(targetLang, sourceFile, flattenedSource, orchestrator, options, globalStats, comparison);
     }
     /**
      * Finalize translation process and save state.
@@ -415,6 +202,7 @@ class TranslationService {
     async finalizeTranslation(stateManager, projectRoot, currentState, globalStats, startTime, options) {
         globalStats.endTime = new Date().toISOString();
         globalStats.totalDuration = (Date.now() - startTime) / 1000;
+        globalStats.totalTime = globalStats.totalDuration;
         await uiManager.displayGlobalSummary(globalStats, (options.targets || []).length);
         // Save review queue if confidence scoring was enabled
         if (options.saveReviewQueue || options.minConfidence !== undefined) {

package/dist/types/index.d.ts

@@ -0,0 +1,58 @@
+import { OrchestratorOptions } from "../core/orchestrator.js";
+import { ContextConfig } from "../core/context-processor.js";
+export interface TranslationOptions extends Omit<OrchestratorOptions, "context"> {
+    source: string;
+    targets?: string[];
+    localesDir?: string;
+    debug?: boolean;
+    forceUpdate?: boolean;
+    syncOptions?: {
+        enabled?: boolean;
+        removeDeletedKeys?: boolean;
+    };
+    concurrencyLimit?: number;
+    saveReviewQueue?: boolean;
+    minConfidence?: number;
+    fileExtensions?: string[];
+    progressOptions?: any;
+    qualityChecks?: any;
+    styleGuide?: any;
+    context?: ContextConfig;
+    lengthControl?: any;
+}
+export interface GlobalStats {
+    total: number;
+    success: number;
+    failed: number;
+    skipped: number;
+    languages: Record<string, any>;
+    byCategory: Record<string, number>;
+    details: Record<string, {
+        totalConfidence: number;
+        samples: number;
+    }>;
+    error?: {
+        message: string;
+        time: string;
+        stack?: string;
+    };
+    orchestrators: any[];
+    endTime?: string;
+    totalDuration?: number;
+    totalTime: number;
+    startTime: string;
+}
+export interface MissingKey {
+    key: string;
+    text: string;
+    targetLang: string;
+    existingTranslation?: string;
+    isModified: boolean;
+    isNew: boolean;
+    issueDetails?: any;
+}
+export interface LanguageProcessResult {
+    status: any;
+    savedMessage?: string;
+    error?: string;
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ui-manager.js

@@ -74,10 +74,10 @@ export class UIManager {
                 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)`);
+                    await this.log(`${category}: ${count} items (${confidenceStr} avg confidence)`);
                 }
                 else {
-                    await this.log(`  ${category}: ${count} items`);
+                    await this.log(`${category}: ${count} items`);
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "locai",
-	"version": "2.3.0",
+	"version": "2.4.0",
 	"type": "module",
 	"main": "dist/core/orchestrator.js",
 	"types": "dist/core/orchestrator.d.ts",
@@ -27,18 +27,26 @@
 		"prepublishOnly": "pnpm build"
 	},
 	"keywords": [
-		"translation",
-		"localization",
 		"i18n",
-		"nextjs",
-		"ai-translation",
-		"cli",
+		"localization",
+		"translation",
+		"l10n",
+		"internationalization",
 		"automation",
+		"cli",
 		"llm",
+		"ai",
+		"artificial-intelligence",
 		"openai",
+		"anthropic",
+		"claude",
 		"gemini",
 		"deepseek",
-		"developer-tools"
+		"xai",
+		"vector-database",
+		"semantic-search",
+		"developer-tools",
+		"typescript"
 	],
 	"author": {
 		"name": "Ahmet Enes Dur",