locai 2.1.2 → 2.2.0

package/dist/providers/openai.d.ts

@@ -0,0 +1,28 @@
+import BaseProvider, { ProviderConfig, TranslateOptions } from "./base-provider.js";
+/**
+ * Provider implementation for OpenAI (GPT) models.
+ */
+declare class OpenAIProvider extends BaseProvider {
+    private client;
+    /**
+     * Create a new OpenAIProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config?: ProviderConfig);
+    getApiKey(): string | undefined;
+    getEndpoint(): string;
+    /**
+     * Translate text using OpenAI.
+     */
+    translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+    analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+    chat(messages: any[], options?: ProviderConfig): Promise<string>;
+    embed(text: string, options?: ProviderConfig): Promise<number[]>;
+    embedBatch(texts: string[], options?: ProviderConfig): Promise<number[][]>;
+}
+declare function translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+declare function analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+declare function chat(messages: any[], options?: ProviderConfig): Promise<string>;
+declare function embed(text: string, options?: ProviderConfig): Promise<number[]>;
+declare function embedBatch(texts: string[], options?: ProviderConfig): Promise<number[][]>;
+export { translate, analyze, chat, embed, embedBatch, OpenAIProvider };

package/dist/providers/openai.js

@@ -40,7 +40,7 @@ class OpenAIProvider extends BaseProvider {
         return RetryHelper.withRetry(async () => {
             try {
                 const response = await this.client.post(this.getEndpoint(), {
-                    model: config.model || "gpt-4o",
+                    model: config.model || "gpt-5.2-chat-latest",
                     ...promptData,
                     temperature: config.temperature,
                     max_completion_tokens: config.maxTokens || config.max_tokens,
@@ -65,7 +65,7 @@ class OpenAIProvider extends BaseProvider {
     }
     async analyze(prompt, options = {}) {
         const config = this.getConfig({
-            model: options.model || "gpt-4o",
+            model: options.model || "gpt-5.2-chat-latest",
             temperature: options.temperature || 0.2,
             maxTokens: options.maxTokens || 1000,
         });
@@ -94,7 +94,7 @@ class OpenAIProvider extends BaseProvider {
     }
     async chat(messages, options = {}) {
         const config = this.getConfig({
-            model: options.model || "gpt-4o",
+            model: options.model || "gpt-5.2-chat-latest",
             temperature: options.temperature || 0.3,
             maxTokens: options.maxTokens || 2000,
         });

package/dist/providers/xai.d.ts

@@ -0,0 +1,22 @@
+import BaseProvider, { ProviderConfig, TranslateOptions } from "./base-provider.js";
+/**
+ * Provider implementation for X.AI (Grok) models.
+ */
+declare class XAIProvider extends BaseProvider {
+    private client;
+    /**
+     * Create a new XAIProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config?: ProviderConfig);
+    getApiKey(): string | undefined;
+    getEndpoint(): string;
+    /**
+     * Translate text using X.AI.
+     */
+    translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+    analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+}
+declare function translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+declare function analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+export { translate, analyze, XAIProvider };

package/dist/services/embedding-provider.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Interface for embedding providers
+ */
+export interface IEmbeddingProvider {
+    getEmbedding(text: string): Promise<number[]>;
+    getEmbeddings(texts: string[]): Promise<number[][]>;
+}
+/**
+ * Service to generate embeddings for text
+ */
+export declare class EmbeddingProvider implements IEmbeddingProvider {
+    private provider;
+    private model;
+    constructor(config?: {
+        provider?: string;
+        model?: string;
+    });
+    /**
+     * Get embedding for a single text
+     */
+    getEmbedding(text: string): Promise<number[]>;
+    /**
+     * Get embeddings for multiple texts (batch)
+     */
+    getEmbeddings(texts: string[]): Promise<number[][]>;
+}

package/dist/services/translation-service.d.ts

@@ -0,0 +1,138 @@
+import Orchestrator from "../core/orchestrator.js";
+import { OrchestratorOptions } from "../core/orchestrator.js";
+import StateManager from "../utils/state-manager.js";
+export interface TranslationOptions extends OrchestratorOptions {
+    source: string;
+    targets?: string[];
+    localesDir?: string;
+    debug?: boolean;
+    forceUpdate?: boolean;
+    syncOptions?: {
+        enabled?: boolean;
+        removeDeletedKeys?: boolean;
+    };
+    concurrencyLimit?: number;
+    saveReviewQueue?: boolean;
+    minConfidence?: number;
+    fileExtensions?: string[];
+}
+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;
+}
+interface LanguageProcessResult {
+    status: any;
+    savedMessage?: string;
+    error?: string;
+}
+/**
+ * Service for handling file translation operations.
+ * Orchestrates the translation process including state management,
+ * verification, and statistics collection.
+ */
+declare 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: string): boolean;
+    /**
+     * Main translator function to process source file and create translations.
+     * @param {string} file - Path to source file.
+     * @param {TranslationOptions} options - Translation options.
+     * @returns {Promise<GlobalStats>} - Global statistics object.
+     * @throws {Error} If validation fails or translation process errors.
+     */
+    translateFile(file: string, options: TranslationOptions): Promise<GlobalStats>;
+    /**
+     * Validate input parameters for translation process.
+     * @param {string} file - Path to source file.
+     * @param {TranslationOptions} options - Translation options.
+     * @returns {Promise<string>} - Resolved absolute path to source file.
+     * @throws {Error} If inputs are invalid.
+     */
+    validateTranslationInputs(file: string, options: TranslationOptions): Promise<string>;
+    /**
+     * Initialize translation state and sync analysis.
+     * @param {string} resolvedFile - Path to resolved source file.
+     * @param {Record<string, any>} flattenedSource - Flattened source content.
+     * @param {TranslationOptions} options - Translation options.
+     * @returns {Promise<Object>} - Initialized state components.
+     */
+    initializeTranslationState(resolvedFile: string, flattenedSource: Record<string, any>, options: TranslationOptions): Promise<{
+        stateManager: StateManager;
+        projectRoot: string;
+        currentState: Record<string, string>;
+        comparison: import("../utils/state-manager.js").StateComparison;
+    }>;
+    /**
+     * Process all target languages with concurrency.
+     * @param {string} resolvedFile - Path to source file.
+     * @param {Record<string, any>} flattenedSource - Flattened source content.
+     * @param {TranslationOptions} options - Translation options.
+     * @param {GlobalStats} globalStats - Global statistics object to update.
+     * @param {any} comparison - State comparison result.
+     */
+    processAllLanguages(resolvedFile: string, flattenedSource: Record<string, any>, options: TranslationOptions, globalStats: GlobalStats, comparison: any): Promise<void>;
+    /**
+     * Process a single language translation.
+     * @param {string} targetLang - Target language code.
+     * @param {string} sourceFile - Path to source file.
+     * @param {Record<string, any>} flattenedSource - Flattened source content.
+     * @param {Orchestrator} orchestrator - Orchestrator instance.
+     * @param {TranslationOptions} options - Translation options.
+     * @param {GlobalStats} globalStats - Global statistics object.
+     * @param {any} comparison - State comparison result.
+     * @returns {Promise<LanguageProcessResult>} - Status and messages for this language.
+     */
+    processLanguage(targetLang: string, sourceFile: string, flattenedSource: Record<string, any>, orchestrator: Orchestrator, options: TranslationOptions, globalStats: GlobalStats, comparison: any): Promise<LanguageProcessResult>;
+    /**
+     * Finalize translation process and save state.
+     * @param {StateManager} stateManager - State manager instance.
+     * @param {string} projectRoot - Project root directory.
+     * @param {any} currentState - Current state object.
+     * @param {GlobalStats} globalStats - Global statistics object.
+     * @param {number} startTime - Process start timestamp.
+     * @param {TranslationOptions} options - Translation options.
+     */
+    finalizeTranslation(stateManager: StateManager, projectRoot: string, currentState: any, globalStats: GlobalStats, startTime: number, options: TranslationOptions): Promise<void>;
+    /**
+     * Remove deleted keys from all target language files.
+     * @param {string} sourceFile - Path to source file.
+     * @param {string[]} deletedKeys - Array of keys to delete.
+     * @param {TranslationOptions} options - Translation options.
+     */
+    removeDeletedKeysFromTargets(sourceFile: string, deletedKeys: string[], options: TranslationOptions): Promise<void>;
+    /**
+     * Validate and fix existing translations that have length issues.
+     * @param {string} file - Path to source file.
+     * @param {TranslationOptions} options - Translation options.
+     * @throws {Error} If validation process fails.
+     */
+    validateAndFixExistingTranslations(file: string, options: TranslationOptions): Promise<void>;
+    /**
+     * Find locale files
+     */
+    findLocaleFiles(localesDir: string, sourceLang: string): Promise<string[]>;
+}
+declare const _default: TranslationService;
+export default _default;

package/dist/services/vector-store.d.ts

@@ -0,0 +1,26 @@
+export interface VectorStoreConfig {
+    enabled: boolean;
+    vectorDbPath: string;
+    similarityThreshold?: number;
+    exactMatchThreshold?: number;
+}
+export interface SearchResult {
+    item: {
+        text: string;
+        translation: string;
+        sourceLang: string;
+        targetLang: string;
+        metadata?: any;
+    };
+    score: number;
+}
+export declare class VectorStore {
+    private index;
+    private config;
+    private initialized;
+    private readonly DIMENSION;
+    constructor(config: VectorStoreConfig);
+    initialize(): Promise<void>;
+    addItem(text: string, translation: string, sourceLang: string, targetLang: string, embedding: number[], metadata?: any): Promise<void>;
+    search(embedding: number[], targetLang: string, limit?: number): Promise<SearchResult[]>;
+}

package/dist/utils/ai-context-analyzer.d.ts

@@ -0,0 +1,73 @@
+export interface AnalysisResult {
+    category: string;
+    confidence: number;
+    keywords: string[];
+    explanation: string;
+    prompt: string;
+    method?: string;
+}
+export interface ContextConfig {
+    enabled?: boolean;
+    useAI?: boolean;
+    minTextLength?: number;
+    cacheSize?: number;
+    cacheTTL?: number;
+    categories?: Record<string, any>;
+    detection?: {
+        threshold?: number;
+        minConfidence?: number;
+    };
+    allowNewCategories?: boolean;
+    fallback?: {
+        category?: string;
+        prompt?: string;
+    };
+    analysisOptions?: {
+        maxTokens?: number;
+        timeout?: number;
+        retries?: number;
+    };
+    [key: string]: any;
+}
+export interface Stats {
+    totalAnalyzed: number;
+    aiCalls: number;
+    cacheHits: number;
+    keywordMatches: number;
+    newCategories: number;
+    errors: number;
+}
+declare class AIContextAnalyzer {
+    private config;
+    private cache;
+    private categoryKeywords;
+    private stats;
+    constructor(config: ContextConfig);
+    analyzeBatch(texts: (string | null)[], apiProvider?: string): Promise<(AnalysisResult | null)[]>;
+    analyzeContext(text: string, apiProvider?: string): Promise<AnalysisResult | null>;
+    _batchAIAnalysis(texts: string[], apiProvider: string): Promise<(AnalysisResult | null)[]>;
+    _createBatchAnalysisPrompt(texts: string[]): string;
+    _createAnalysisPrompt(text: string): string;
+    _createSimplifiedAnalysisPrompt(text: string): string;
+    _parseBatchAnalysisResult(result: string, expectedCount: number): (AnalysisResult | null)[];
+    _parseAnalysisResult(result: string): AnalysisResult | null;
+    _fastKeywordMatch(text: string): AnalysisResult | null;
+    _getDefaultContext(): AnalysisResult;
+    _findClosestCategory(suggestedCategory: string, keywords: string[]): string;
+    _saveNewCategory(category: string, keywords: string[]): void;
+    /**
+     * Generate a collision-resistant cache key for text
+     */
+    _getCacheKey(text: string): string;
+    getStats(): Stats & {
+        cacheSize: number;
+        cacheCapacity: number;
+        hitRate: number;
+        aiUsageRate: number;
+        keywordMatchRate: number;
+        errorRate: number;
+    };
+    resetStats(): void;
+    clearCache(): void;
+}
+export default AIContextAnalyzer;

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

@@ -0,0 +1,77 @@
+/**
+ * Quality Confidence Scoring System
+ * Calculates confidence scores for translations based on AI response and quality checks
+ */
+export interface ConfidenceIssue {
+    type: string;
+    severity: "critical" | "warning" | "error";
+    message: string;
+}
+export interface ConfidenceOptions {
+    aiConfidence?: number;
+    sourceText: string;
+    translation: string;
+    sourceLang: string;
+    targetLang: string;
+    provider: string;
+    category?: string;
+}
+export interface ConfidenceResult {
+    score: number;
+    level: "high" | "medium" | "low" | "very_low";
+    aiConfidence: number;
+    qualityScore: number;
+    details: {
+        categoryAdjustment: number;
+        languageFactor: number;
+        providerReliability: number;
+    };
+    issues: ConfidenceIssue[];
+    needsReview: boolean;
+    autoApprove: boolean;
+}
+declare class ConfidenceScorer {
+    /**
+     * Calculate final confidence score
+     * @param {ConfidenceOptions} options
+     * @returns {ConfidenceResult} { score, details, issues }
+     */
+    static calculateConfidence(options: ConfidenceOptions): ConfidenceResult;
+    /**
+     * Calculate quality score based on internal checks
+     */
+    private static _calculateQualityScore;
+    /**
+     * Get category-specific adjustment
+     */
+    private static _getCategoryAdjustment;
+    /**
+     * Get language pair complexity factor
+     */
+    private static _getLanguagePairFactor;
+    /**
+     * Get provider reliability for specific tasks
+     */
+    private static _getProviderReliability;
+    /**
+     * Determine confidence level from score
+     */
+    private static _getConfidenceLevel;
+    /**
+     * Detect specific issues with translation
+     */
+    private static _detectIssues;
+    /**
+     * Get confidence color for terminal display
+     */
+    static getConfidenceColor(score: number): string;
+    /**
+     * 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/error-helper.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Centralized Error Handling System
+ * Provides detailed, actionable error messages with context and solutions
+ */
+export interface HelperError extends Error {
+    code?: string;
+    type?: string;
+    details?: Record<string, any>;
+    solutions?: string[];
+    context?: string[];
+}
+export interface ErrorDetails {
+    [key: string]: any;
+}
+declare class ErrorHelper {
+    static ErrorCodes: {
+        API_RATE_LIMIT: string;
+        API_AUTH_FAILED: string;
+        API_SERVER_ERROR: string;
+        API_NETWORK: string;
+        API_TIMEOUT: string;
+        API_INVALID_KEY: string;
+        API_QUOTA_EXCEEDED: string;
+        API_RESPONSE_ERROR: string;
+        CONFIG_NOT_FOUND: string;
+        CONFIG_INVALID: string;
+        CONFIG_VALIDATION: string;
+        CONFIG_MISSING_FIELD: string;
+        FILE_NOT_FOUND: string;
+        FILE_READ_ERROR: string;
+        FILE_WRITE_ERROR: string;
+        FILE_PERMISSION: string;
+        VALIDATION_LANGUAGE: string;
+        VALIDATION_TEXT: string;
+        VALIDATION_PROVIDER: string;
+        VALIDATION_CONCURRENCY: string;
+        TRANSLATION_FAILED: string;
+        TRANSLATION_QUALITY: string;
+        TRANSLATION_TIMEOUT: string;
+    };
+    /**
+     * Create a detailed error with context and solutions
+     */
+    static createError(type: string, details?: ErrorDetails): HelperError;
+    /**
+     * Format error for display
+     */
+    static formatError(error: HelperError, options?: {
+        showDebug?: boolean;
+        showSolutions?: boolean;
+        showContext?: boolean;
+    }): string;
+    /**
+     * Get error information based on type
+     */
+    private static _getErrorInfo;
+    /**
+     * Build rate limit message with details
+     */
+    private static _buildRateLimitMessage;
+    /**
+     * Get environment variable name for provider
+     */
+    private static _getEnvKeyName;
+    /**
+     * Get provider console URL
+     */
+    private static _getProviderConsoleUrl;
+    /**
+     * Suggest fallback provider
+     */
+    private static _suggestFallbackProvider;
+    /**
+     * 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 networkError(provider: string): HelperError;
+    static timeoutError(provider: string, timeout?: number): HelperError;
+    static configNotFoundError(): HelperError;
+    static configValidationError(validationErrors: string[]): HelperError;
+    static fileNotFoundError(filePath: string, expectedSource?: string): HelperError;
+    static translationError(key: string, language: string, reason?: string): HelperError;
+    static languageValidationError(langCode: string, field?: string): HelperError;
+}
+export default ErrorHelper;

package/dist/utils/error-helper.js

@@ -321,6 +321,7 @@ class ErrorHelper {
             deepseek: "DEEPSEEK_API_KEY",
             dashscope: "DASHSCOPE_API_KEY",
             xai: "XAI_API_KEY",
+            anthropic: "ANTHROPIC_API_KEY",
         };
         return envMap[provider?.toLowerCase()] || `${provider?.toUpperCase()}_API_KEY`;
     }
@@ -334,6 +335,7 @@ class ErrorHelper {
             deepseek: "https://platform.deepseek.com/api-keys",
             dashscope: "https://dashscope.console.aliyun.com/",
             xai: "https://console.x.ai/",
+            anthropic: "https://console.anthropic.com/settings/keys",
         };
         return urlMap[provider?.toLowerCase()] || "provider console";
     }
@@ -341,7 +343,7 @@ class ErrorHelper {
      * Suggest fallback provider
      */
     static _suggestFallbackProvider(currentProvider) {
-        const fallbackOrder = ["openai", "gemini", "deepseek", "dashscope", "xai"];
+        const fallbackOrder = ["openai", "anthropic", "gemini", "deepseek", "dashscope", "xai"];
         const current = currentProvider?.toLowerCase();
         const index = fallbackOrder.indexOf(current);
         if (index === -1 || index === fallbackOrder.length - 1) {

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

@@ -0,0 +1,129 @@
+export interface FileOptions {
+    atomic?: boolean;
+    createMissingDirs?: boolean;
+    backupFiles?: boolean;
+    backupDir?: string;
+    encoding?: BufferEncoding;
+    jsonIndent?: number;
+    compact?: boolean;
+    indent?: number;
+    format?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    filePath?: string;
+    error?: string;
+    position?: {
+        position: number | null;
+        line: number | null;
+    } | null;
+    key?: string;
+    value?: any;
+}
+/**
+ * FileManager - Modern asynchronous file operations
+ * Handles multiple file formats via Adapter pattern.
+ */
+declare class FileManager {
+    /**
+     * Default options for file operations
+     */
+    static defaultOptions: Required<Omit<FileOptions, "compact" | "indent" | "format">>;
+    private static options;
+    /**
+     * Configure global options for file operations
+     * @param options - File operation options
+     */
+    static configure(options: FileOptions): void;
+    /**
+     * Get current configuration
+     * @returns Current configuration
+     */
+    static getConfig(): FileOptions;
+    /**
+     * Find locale files in the specified directory
+     * @param localesDir - Directory containing locale files
+     * @param sourceLang - Source language code
+     * @returns Array of file paths
+     */
+    static findLocaleFiles(localesDir: string, sourceLang: string): Promise<string[]>;
+    /**
+     * Read structured data file asynchronously (JSON, YAML, etc.)
+     * @param filePath - Path to the file
+     * @param options - Options for reading
+     * @returns Parsed data
+     */
+    static readFile(filePath: string, options?: FileOptions): Promise<any>;
+    /**
+     * Write data to file asynchronously
+     * @param filePath - Path to write the file
+     * @param data - Data to write
+     * @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>;
+    /**
+     * Generate a unique temporary file path
+     */
+    static _generateTempFilePath(filePath: string): string;
+    /**
+     * Ensure directory exists
+     */
+    static ensureDir(dir: string): Promise<void>;
+    /**
+     * Scan for locale files
+     */
+    static scanLocaleFiles(localesDir: string, pattern?: RegExp): Promise<string[]>;
+    /**
+     * Get file modification time
+     */
+    static getModifiedTime(filePath: string): Promise<Date>;
+    /**
+     * Check if file exists
+     */
+    static exists(filePath: string): Promise<boolean>;
+    /**
+     * Delete file
+     * @param filePath - Path to the file
+     * @param options - Options for deletion
+     * @returns Success status
+     */
+    static deleteFile(filePath: string, options?: FileOptions): Promise<boolean>;
+    /**
+     * Validate JSON file structure
+     * @param filePath - Path to the JSON file
+     * @returns Validation result
+     */
+    static validateJSONFile(filePath: string): Promise<ValidationResult>;
+    /**
+     * Extract error position from JSON parse error
+     * @param error - JSON parse error
+     * @returns Error position details
+     */
+    static _extractErrorPosition(error: any): {
+        position: number | null;
+        line: number | null;
+    } | null;
+    /**
+     * Validate translation value can be safely added to JSON
+     * @param key - Translation key
+     * @param value - Translation value
+     * @returns Validation result
+     */
+    static validateTranslationValue(key: string, value: any): ValidationResult;
+    /**
+     * List files in a directory
+     * @param dirPath - Directory path
+     * @returns Array of file paths
+     */
+    static listFiles(dirPath: string): Promise<string[]>;
+    /**
+     * Ensure directory exists, create if it doesn't
+     * @param dirPath - Directory path
+     * @returns True if directory exists or was created
+     */
+    static ensureDirectoryExists(dirPath: string): Promise<boolean>;
+}
+export { FileManager };