locai 2.6.1 → 2.7.0

package/dist/utils/confidence-scorer.d.ts

@@ -1,14 +1,17 @@
 /**
- * Quality Confidence Scoring System
- * Calculates confidence scores for translations based on AI response and quality checks
+ * Confidence scoring for translations.
+ *
+ * The score is computed from the translation itself: checks for problems a model commonly
+ * introduces (lost placeholders or HTML tags, untranslated text, leftover commentary, unusual
+ * length or ending punctuation), scaled by fixed factors for the content category, the language
+ * pair and the provider. The model's own confidence (e.g. logprobs) is not used.
  */
 export interface ConfidenceIssue {
     type: string;
-    severity: "critical" | "warning" | "error";
+    severity: "warning" | "error";
     message: string;
 }
 export interface ConfidenceOptions {
-    aiConfidence?: number;
     sourceText: string;
     translation: string;
     sourceLang: string;
@@ -17,30 +20,32 @@ export interface ConfidenceOptions {
     category?: string;
 }
 export interface ConfidenceResult {
+    /** 0-1: the quality score scaled by the category, language pair and provider factors. */
     score: number;
     level: "high" | "medium" | "low" | "very_low";
-    aiConfidence: number;
+    /** 0-1: 1 minus the penalties of the failed checks. */
     qualityScore: number;
     details: {
         categoryAdjustment: number;
         languageFactor: number;
         providerReliability: number;
     };
+    /** One entry per failed check. */
     issues: ConfidenceIssue[];
-    needsReview: boolean;
-    autoApprove: boolean;
 }
 declare class ConfidenceScorer {
     /**
-     * Calculate final confidence score
+     * Score a translation against its source text.
      * @param {ConfidenceOptions} options
-     * @returns {ConfidenceResult} { score, details, issues }
+     * @returns {ConfidenceResult} { score, level, qualityScore, details, issues }
      */
     static calculateConfidence(options: ConfidenceOptions): ConfidenceResult;
     /**
-     * Calculate quality score based on internal checks
+     * Check the translation against its source. Each failed check adds an issue and lowers the
+     * quality score from 1: by 0.4 for a problem that breaks or invalidates the translation, by
+     * 0.2 for an unusual length and by 0.1 for different ending punctuation.
      */
-    private static _calculateQualityScore;
+    private static _checkTranslation;
     /**
      * Get category-specific adjustment
      */
@@ -57,10 +62,6 @@ declare class ConfidenceScorer {
      * Determine confidence level from score
      */
     private static _getConfidenceLevel;
-    /**
-     * Detect specific issues with translation
-     */
-    private static _detectIssues;
     /**
      * Get confidence color for terminal display
      */
@@ -69,9 +70,5 @@ declare class ConfidenceScorer {
      * Format confidence for display
      */
     static formatConfidence(score: number): string;
-    /**
-     * Extract AI confidence from provider response
-     */
-    static extractAIConfidence(response: any, provider: string): number;
 }
 export default ConfidenceScorer;

package/dist/utils/confidence-scorer.js

@@ -1,39 +1,29 @@
 /**
- * Quality Confidence Scoring System
- * Calculates confidence scores for translations based on AI response and quality checks
+ * Confidence scoring for translations.
+ *
+ * The score is computed from the translation itself: checks for problems a model commonly
+ * introduces (lost placeholders or HTML tags, untranslated text, leftover commentary, unusual
+ * length or ending punctuation), scaled by fixed factors for the content category, the language
+ * pair and the provider. The model's own confidence (e.g. logprobs) is not used.
  */
 class ConfidenceScorer {
     /**
-     * Calculate final confidence score
+     * Score a translation against its source text.
      * @param {ConfidenceOptions} options
-     * @returns {ConfidenceResult} { score, details, issues }
+     * @returns {ConfidenceResult} { score, level, qualityScore, details, issues }
      */
     static calculateConfidence(options) {
-        const { aiConfidence = 0.8, sourceText, translation, sourceLang, targetLang, provider, category = "general", } = options;
-        // Quality checks
-        const qualityScore = this._calculateQualityScore(sourceText, translation);
-        // Category-specific adjustments
+        const { sourceText, translation, sourceLang, targetLang, provider, category = "general", } = options;
+        const { qualityScore, issues } = this._checkTranslation(sourceText, translation);
         const categoryAdjustment = this._getCategoryAdjustment(category, provider);
-        // Language pair complexity
         const languageFactor = this._getLanguagePairFactor(sourceLang, targetLang);
-        // Provider-specific reliability
         const providerReliability = this._getProviderReliability(provider, category);
-        // Calculate weighted final score
-        const finalScore = aiConfidence * 0.4 + // AI's own confidence
-            qualityScore * 0.3 + // Our quality checks
-            categoryAdjustment * 0.15 + // Category-specific adjustment
-            languageFactor * 0.1 + // Language pair complexity
-            providerReliability * 0.05; // Provider reliability
-        // Clamp to 0-1 range
-        const score = Math.max(0, Math.min(1, finalScore));
-        // Determine confidence level
-        const level = this._getConfidenceLevel(score);
-        // Collect issues
-        const issues = this._detectIssues(sourceText, translation, score);
+        // Harder categories, language pairs and providers lower the score (weighted 3:2:1)
+        const contextFactor = (categoryAdjustment * 3 + languageFactor * 2 + providerReliability) / 6;
+        const score = parseFloat((qualityScore * contextFactor).toFixed(3));
         return {
-            score: parseFloat(score.toFixed(3)),
-            level,
-            aiConfidence,
+            score,
+            level: this._getConfidenceLevel(score),
             qualityScore,
             details: {
                 categoryAdjustment,
@@ -41,55 +31,45 @@ class ConfidenceScorer {
                 providerReliability,
             },
             issues,
-            needsReview: score < 0.7,
-            autoApprove: score >= 0.9,
         };
     }
     /**
-     * Calculate quality score based on internal checks
+     * Check the translation against its source. Each failed check adds an issue and lowers the
+     * quality score from 1: by 0.4 for a problem that breaks or invalidates the translation, by
+     * 0.2 for an unusual length and by 0.1 for different ending punctuation.
      */
-    static _calculateQualityScore(sourceText, translation) {
-        let score = 1.0;
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static _checkTranslation(sourceText, translation) {
         const issues = [];
-        // Check 1: Placeholder preservation
+        let penalty = 0;
+        const fail = (type, severity, cost, message) => {
+            issues.push({ type, severity, message });
+            penalty += cost;
+        };
         const sourcePlaceholders = (sourceText.match(/\{[^}]+\}/g) || []).length;
         const translationPlaceholders = (translation.match(/\{[^}]+\}/g) || []).length;
         if (sourcePlaceholders !== translationPlaceholders) {
-            score -= 0.3;
-            issues.push("placeholder_mismatch");
+            fail("placeholder", "error", 0.4, `Placeholder count mismatch: ${sourcePlaceholders} → ${translationPlaceholders}`);
         }
-        // Check 2: HTML tag preservation
         const sourceTags = (sourceText.match(/<[^>]+>/g) || []).length;
         const translationTags = (translation.match(/<[^>]+>/g) || []).length;
         if (sourceTags !== translationTags) {
-            score -= 0.2;
-            issues.push("html_tag_mismatch");
+            fail("html_tag", "error", 0.4, `HTML tag count mismatch: ${sourceTags} → ${translationTags}`);
         }
-        // Check 3: Length appropriateness
         const lengthRatio = translation.length / sourceText.length;
         if (lengthRatio < 0.3 || lengthRatio > 3.0) {
-            score -= 0.2;
-            issues.push("extreme_length_difference");
+            fail("length", "warning", 0.2, `Translation is ${Math.round(lengthRatio * 100)}% of source length`);
         }
-        // Check 4: Punctuation consistency
         const sourceEndsWithPunctuation = /[.!?;:]$/.test(sourceText.trim());
         const translationEndsWithPunctuation = /[.!?;:]$/.test(translation.trim());
         if (sourceEndsWithPunctuation !== translationEndsWithPunctuation) {
-            score -= 0.1;
-            issues.push("punctuation_inconsistency");
+            fail("punctuation", "warning", 0.1, "Ending punctuation differs from the source");
         }
-        // Check 5: Empty or too short translation
         if (translation.trim().length < 2) {
-            score -= 0.4;
-            issues.push("translation_too_short");
+            fail("too_short", "error", 0.4, "Translation is empty or a single character");
         }
-        // Check 6: Same as source (no translation occurred)
         if (sourceText.toLowerCase().trim() === translation.toLowerCase().trim()) {
-            score -= 0.3;
-            issues.push("identical_to_source");
+            fail("untranslated", "error", 0.4, "Translation is identical to the source");
         }
-        // Check 7: Contains AI artifacts
         const artifacts = [
             /^translation:/i,
             /^translated text:/i,
@@ -97,10 +77,9 @@ class ConfidenceScorer {
             /^the translation is/i,
         ];
         if (artifacts.some((pattern) => pattern.test(translation))) {
-            score -= 0.2;
-            issues.push("contains_ai_artifacts");
+            fail("ai_artifact", "error", 0.4, "Translation starts with model commentary");
         }
-        return Math.max(0, score);
+        return { qualityScore: parseFloat(Math.max(0, 1 - penalty).toFixed(3)), issues };
     }
     /**
      * Get category-specific adjustment
@@ -129,7 +108,10 @@ class ConfidenceScorer {
     /**
      * Get language pair complexity factor
      */
-    static _getLanguagePairFactor(sourceLang, targetLang) {
+    static _getLanguagePairFactor(sourceTag, targetTag) {
+        // Compare on the primary language subtag so "zh-Hant" or "pt-BR" behave like "zh" / "pt"
+        const sourceLang = sourceTag.split("-")[0].toLowerCase();
+        const targetLang = targetTag.split("-")[0].toLowerCase();
         // Similar language pairs get higher confidence
         const similarPairs = {
             en: ["es", "fr", "de", "pl"],
@@ -182,45 +164,6 @@ class ConfidenceScorer {
             return "low";
         return "very_low";
     }
-    /**
-     * Detect specific issues with translation
-     */
-    static _detectIssues(sourceText, translation, score) {
-        const issues = [];
-        if (score < 0.5) {
-            issues.push({
-                type: "quality",
-                severity: "critical",
-                message: "Translation quality is very low, manual review required",
-            });
-        }
-        else if (score < 0.7) {
-            issues.push({
-                type: "quality",
-                severity: "warning",
-                message: "Translation quality is below threshold, review recommended",
-            });
-        }
-        // Check for specific patterns
-        const sourcePlaceholders = (sourceText.match(/\{[^}]+\}/g) || []).length;
-        const translationPlaceholders = (translation.match(/\{[^}]+\}/g) || []).length;
-        if (sourcePlaceholders !== translationPlaceholders) {
-            issues.push({
-                type: "placeholder",
-                severity: "error",
-                message: `Placeholder count mismatch: ${sourcePlaceholders} → ${translationPlaceholders}`,
-            });
-        }
-        const lengthRatio = translation.length / sourceText.length;
-        if (lengthRatio > 2.5) {
-            issues.push({
-                type: "length",
-                severity: "warning",
-                message: `Translation is ${Math.round(lengthRatio * 100)}% of source length`,
-            });
-        }
-        return issues;
-    }
     /**
      * Get confidence color for terminal display
      */
@@ -241,37 +184,5 @@ class ConfidenceScorer {
         const percentage = (score * 100).toFixed(1);
         return `${color} ${percentage}%`;
     }
-    /**
-     * Extract AI confidence from provider response
-     */
-    static extractAIConfidence(response, provider) {
-        // OpenAI logprobs-based confidence
-        if (provider === "openai" && response.choices?.[0]?.logprobs) {
-            const logprobs = response.choices[0].logprobs.token_logprobs || [];
-            if (logprobs.length > 0) {
-                // Convert log probabilities to confidence
-                const avgLogProb = logprobs.reduce((sum, lp) => sum + (lp || -1), 0) /
-                    logprobs.length;
-                return Math.exp(avgLogProb); // Convert back to probability
-            }
-        }
-        // Gemini confidence scores
-        if (provider === "gemini" && response.candidates?.[0]) {
-            const finishReason = response.candidates[0].finishReason;
-            if (finishReason === "STOP")
-                return 0.9; // Normal completion
-            if (finishReason === "MAX_TOKENS")
-                return 0.75; // Incomplete
-            return 0.8; // Default
-        }
-        // Default confidence based on finish reason
-        const finishReason = response.choices?.[0]?.finish_reason || response.finishReason;
-        if (finishReason === "stop" || finishReason === "STOP")
-            return 0.85;
-        if (finishReason === "length")
-            return 0.7;
-        // Fallback
-        return 0.8;
-    }
 }
 export default ConfidenceScorer;

package/dist/utils/error-helper.d.ts

@@ -2,16 +2,37 @@
  * Centralized Error Handling System
  * Provides detailed, actionable error messages with context and solutions
  */
+/**
+ * Context attached to a helper error. The named fields are the ones the
+ * message templates read; callers may attach any extra debug fields.
+ */
+export interface ErrorDetails {
+    provider?: string;
+    statusCode?: number | string;
+    apiMessage?: string | null;
+    retryAfter?: number | string;
+    limit?: number | string;
+    current?: number | string | null;
+    currentConcurrency?: number;
+    timeout?: number;
+    validationErrors?: string[];
+    filePath?: string;
+    expectedSource?: string;
+    key?: string;
+    language?: string;
+    reason?: string;
+    langCode?: string;
+    field?: string;
+    message?: string;
+    [key: string]: unknown;
+}
 export interface HelperError extends Error {
     code?: string;
     type?: string;
-    details?: Record<string, any>;
+    details?: ErrorDetails;
     solutions?: string[];
     context?: string[];
 }
-export interface ErrorDetails {
-    [key: string]: any;
-}
 declare class ErrorHelper {
     static ErrorCodes: {
         API_RATE_LIMIT: string;
@@ -74,8 +95,8 @@ declare class ErrorHelper {
      * Quick error creators for common cases
      */
     static rateLimitError(provider: string, details?: ErrorDetails): HelperError;
-    static authError(provider: string, statusCode?: number | string, apiMessage?: string): HelperError;
-    static serverError(provider: string, statusCode?: number | string, apiMessage?: string): HelperError;
+    static authError(provider: string, statusCode?: number | string, apiMessage?: string | null): HelperError;
+    static serverError(provider: string, statusCode?: number | string, apiMessage?: string | null): HelperError;
     static networkError(provider: string): HelperError;
     static timeoutError(provider: string, timeout?: number): HelperError;
     static configNotFoundError(): HelperError;

package/dist/utils/error-helper.js

@@ -270,14 +270,15 @@ class ErrorHelper {
                 code: this.ErrorCodes.VALIDATION_LANGUAGE,
                 message: `Invalid language code: ${details.langCode || "unknown"}`,
                 context: [
-                    "Language code must be ISO 639-1 format (e.g., 'en', 'tr', 'de')",
-                    "Only lowercase 2-letter codes are supported",
-                    "Regional codes like 'en-US' are not yet supported",
+                    "Language codes must be BCP 47 language tags",
+                    "Format: 2-3 letter language, optional 4-letter script, optional 2-letter or 3-digit region",
+                    "Examples: 'en', 'fil', 'pt-BR', 'zh-Hant', 'zh-Hant-TW', 'es-419'",
                 ],
                 solutions: [
-                    "Use ISO 639-1 two-letter codes (e.g., 'en' instead of 'english')",
-                    "Check supported languages: https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes",
-                    `Update your config: ${details.field || "targets"} = ["en", "tr", "de"]`,
+                    "Use a language tag instead of a language name (e.g., 'en' instead of 'english')",
+                    "Separate subtags with '-' (e.g., 'pt-BR', not 'pt_BR')",
+                    "Look up tags in the IANA Language Subtag Registry: https://www.iana.org/assignments/language-subtag-registry",
+                    `Update your config: ${details.field || "targets"} = ["en", "pt-BR", "zh-Hant"]`,
                 ],
             },
         };
@@ -323,7 +324,7 @@ class ErrorHelper {
             xai: "XAI_API_KEY",
             anthropic: "ANTHROPIC_API_KEY",
         };
-        return envMap[provider?.toLowerCase()] || `${provider?.toUpperCase()}_API_KEY`;
+        return envMap[provider?.toLowerCase() ?? ""] || `${provider?.toUpperCase()}_API_KEY`;
     }
     /**
      * Get provider console URL
@@ -337,7 +338,7 @@ class ErrorHelper {
             xai: "https://console.x.ai/",
             anthropic: "https://console.anthropic.com/settings/keys",
         };
-        return urlMap[provider?.toLowerCase()] || "provider console";
+        return urlMap[provider?.toLowerCase() ?? ""] || "provider console";
     }
     /**
      * Suggest fallback provider
@@ -345,7 +346,7 @@ class ErrorHelper {
     static _suggestFallbackProvider(currentProvider) {
         const fallbackOrder = ["openai", "anthropic", "gemini", "deepseek", "dashscope", "xai"];
         const current = currentProvider?.toLowerCase();
-        const index = fallbackOrder.indexOf(current);
+        const index = current ? fallbackOrder.indexOf(current) : -1;
         if (index === -1 || index === fallbackOrder.length - 1) {
             return fallbackOrder[0];
         }

package/dist/utils/file-manager.d.ts

@@ -1,3 +1,4 @@
+import type { TranslationObject } from "./object-transformer.js";
 export interface FileOptions {
     atomic?: boolean;
     createMissingDirs?: boolean;
@@ -18,7 +19,7 @@ export interface ValidationResult {
         line: number | null;
     } | null;
     key?: string;
-    value?: any;
+    value?: unknown;
 }
 /**
  * FileManager - Modern asynchronous file operations
@@ -59,7 +60,7 @@ declare class FileManager {
      * @param options - Options for reading
      * @returns Parsed data
      */
-    static readFile(filePath: string, options?: FileOptions): Promise<any>;
+    static readFile(filePath: string, options?: FileOptions): Promise<TranslationObject>;
     /**
      * Write data to file asynchronously
      * @param filePath - Path to write the file
@@ -67,9 +68,9 @@ declare class FileManager {
      * @param options - Options for writing
      * @returns Success status
      */
-    static writeFile(filePath: string, data: any, options?: FileOptions): Promise<boolean>;
-    static readJSON(filePath: string, options?: FileOptions): Promise<any>;
-    static writeJSON(filePath: string, data: any, options?: FileOptions): Promise<boolean>;
+    static writeFile(filePath: string, data: TranslationObject, options?: FileOptions): Promise<boolean>;
+    static readJSON(filePath: string, options?: FileOptions): Promise<TranslationObject>;
+    static writeJSON(filePath: string, data: TranslationObject, options?: FileOptions): Promise<boolean>;
     /**
      * Generate a unique temporary file path
      */
@@ -108,7 +109,7 @@ declare class FileManager {
      * @param error - JSON parse error
      * @returns Error position details
      */
-    static _extractErrorPosition(error: any): {
+    static _extractErrorPosition(error: unknown): {
         position: number | null;
         line: number | null;
     } | null;
@@ -118,7 +119,7 @@ declare class FileManager {
      * @param value - Translation value
      * @returns Validation result
      */
-    static validateTranslationValue(key: string, value: any): ValidationResult;
+    static validateTranslationValue(key: string, value: unknown): ValidationResult;
     /**
      * List files in a directory
      * @param dirPath - Directory path

package/dist/utils/file-manager.js

@@ -1,6 +1,11 @@
 import { promises as fs } from "fs";
 import path from "path";
 import { FormatFactory } from "../core/adapters/factory.js";
+/**
+ * Read `code` (e.g. "ENOENT") from a caught Node.js system error.
+ */
+const errorCode = (error) => error instanceof Error && "code" in error ? error.code : undefined;
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
 /**
  * FileManager - Modern asynchronous file operations
  * Handles multiple file formats via Adapter pattern.
@@ -92,10 +97,10 @@ class FileManager {
             throw new Error(`Source language file not found for '${sourceLang}' in ${localesDir}`);
         }
         catch (err) {
-            if (err.code === "ENOENT") {
+            if (errorCode(err) === "ENOENT") {
                 throw new Error(`Locales directory not found: ${localesDir}`);
             }
-            throw new Error(`Source language file search error: ${err.message}`);
+            throw new Error(`Source language file search error: ${errorMessage(err)}`);
         }
     }
     /**
@@ -104,7 +109,6 @@ class FileManager {
      * @param options - Options for reading
      * @returns Parsed data
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static async readFile(filePath, options = {}) {
         const config = { ...this.getConfig(), ...options };
         try {
@@ -115,7 +119,7 @@ class FileManager {
             return await adapter.parse(content);
         }
         catch (err) {
-            throw new Error(`File read error (${filePath}): ${err.message}`);
+            throw new Error(`File read error (${filePath}): ${errorMessage(err)}`);
         }
     }
     /**
@@ -125,7 +129,6 @@ class FileManager {
      * @param options - Options for writing
      * @returns Success status
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static async writeFile(filePath, data, options = {}) {
         const config = { ...this.getConfig(), ...options };
         try {
@@ -147,8 +150,8 @@ class FileManager {
                 }
                 catch (err) {
                     // Ignore if file doesn't exist
-                    if (err.code !== "ENOENT") {
-                        console.error(`Backup failed (${filePath}): ${err.message}`);
+                    if (errorCode(err) !== "ENOENT") {
+                        console.error(`Backup failed (${filePath}): ${errorMessage(err)}`);
                     }
                 }
             }
@@ -179,7 +182,7 @@ class FileManager {
                             /* ignore cleanup error */
                         }
                     }
-                    throw new Error(`Atomic write failed (${filePath}): ${renameError.message}`);
+                    throw new Error(`Atomic write failed (${filePath}): ${errorMessage(renameError)}`);
                 }
             }
             else {
@@ -188,15 +191,13 @@ class FileManager {
             return true;
         }
         catch (err) {
-            throw new Error(`File write error (${filePath}): ${err.message}`);
+            throw new Error(`File write error (${filePath}): ${errorMessage(err)}`);
         }
     }
     // Legacy method aliases for backward compatibility
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static async readJSON(filePath, options = {}) {
         return this.readFile(filePath, { ...options, format: "json" });
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static async writeJSON(filePath, data, options = {}) {
         return this.writeFile(filePath, data, { ...options, format: "json" });
     }
@@ -216,7 +217,7 @@ class FileManager {
             await fs.mkdir(dir, { recursive: true });
         }
         catch (err) {
-            if (err.code !== "EEXIST") {
+            if (errorCode(err) !== "EEXIST") {
                 throw err;
             }
         }
@@ -232,7 +233,7 @@ class FileManager {
                 .map((file) => path.join(localesDir, file));
         }
         catch (err) {
-            throw new Error(`Error scanning locale directory: ${err.message}`);
+            throw new Error(`Error scanning locale directory: ${errorMessage(err)}`);
         }
     }
     /**
@@ -244,7 +245,7 @@ class FileManager {
             return stats.mtime;
         }
         catch (err) {
-            throw new Error(`Error getting file stats: ${err.message}`);
+            throw new Error(`Error getting file stats: ${errorMessage(err)}`);
         }
     }
     /**
@@ -277,14 +278,14 @@ class FileManager {
                     await fs.copyFile(filePath, backupPath);
                 }
                 catch (err) {
-                    console.error(`Backup failed (${filePath}): ${err.message}`);
+                    console.error(`Backup failed (${filePath}): ${errorMessage(err)}`);
                 }
             }
             await fs.unlink(filePath);
             return true;
         }
         catch (err) {
-            throw new Error(`File deletion error (${filePath}): ${err.message}`);
+            throw new Error(`File deletion error (${filePath}): ${errorMessage(err)}`);
         }
     }
     /**
@@ -305,7 +306,7 @@ class FileManager {
             return {
                 valid: false,
                 filePath,
-                error: error.message,
+                error: errorMessage(error),
                 position: this._extractErrorPosition(error),
             };
         }
@@ -315,9 +316,8 @@ class FileManager {
      * @param error - JSON parse error
      * @returns Error position details
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static _extractErrorPosition(error) {
-        const message = error.message;
+        const message = errorMessage(error);
         const positionMatch = message.match(/position (\d+)/);
         const lineMatch = message.match(/line (\d+)/);
         if (positionMatch || lineMatch) {
@@ -334,7 +334,6 @@ class FileManager {
      * @param value - Translation value
      * @returns Validation result
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static validateTranslationValue(key, value) {
         try {
             // Test if value can be part of valid JSON
@@ -352,7 +351,7 @@ class FileManager {
                 valid: false,
                 key,
                 value,
-                error: `JSON validation failed: ${error.message}`,
+                error: `JSON validation failed: ${errorMessage(error)}`,
             };
         }
     }
@@ -370,7 +369,7 @@ class FileManager {
             return files;
         }
         catch (err) {
-            throw new Error(`Directory read error (${dirPath}): ${err.message}`);
+            throw new Error(`Directory read error (${dirPath}): ${errorMessage(err)}`);
         }
     }
     /**
@@ -384,7 +383,7 @@ class FileManager {
             return true;
         }
         catch (err) {
-            throw new Error(`Failed to create directory (${dirPath}): ${err.message}`);
+            throw new Error(`Failed to create directory (${dirPath}): ${errorMessage(err)}`);
         }
     }
 }