locai 2.1.1 → 2.1.3

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/commands/review.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Interactive Review Command.
+ * Allows manual review of low-confidence translations.
+ */
+interface ReviewItem {
+    key: string;
+    language: string;
+    source: string;
+    translation: string;
+    confidence: {
+        score: number;
+        level: string;
+        issues: Array<{
+            severity: string;
+            message: string;
+        }>;
+    };
+    category?: string;
+    sourceLang?: string;
+    edited?: boolean;
+    editedAt?: string;
+}
+interface ReviewCommandConfig {
+    localesDir: string;
+    source: string;
+    [key: string]: any;
+}
+declare class ReviewCommand {
+    private config;
+    private reviewQueue;
+    private currentIndex;
+    private decisions;
+    /**
+     * Initialize ReviewCommand.
+     * @param {ReviewCommandConfig} config - Configuration object.
+     */
+    constructor(config: ReviewCommandConfig);
+    /**
+     * Load review queue from cache file.
+     * @returns {boolean} - True if loaded successfully, else false.
+     */
+    loadReviewQueue(): boolean;
+    /**
+     * Start interactive review session.
+     */
+    startReview(): Promise<void>;
+    /**
+     * Review a single translation item.
+     * @param {ReviewItem} item - Translation item to review.
+     * @param {number} current - Current item index (1-based).
+     * @param {number} total - Total items.
+     * @returns {Promise<string>} - Decision result.
+     */
+    reviewItem(item: ReviewItem, current: number, total: number): Promise<string>;
+    /**
+     * Handle user action input.
+     * @param {string} action - User action code.
+     * @param {ReviewItem} item - Current item.
+     * @returns {Promise<string>} - Result status.
+     */
+    handleAction(action: string, item: ReviewItem): Promise<string>;
+    /**
+     * Edit translation interactively.
+     * @param {ReviewItem} item - Item to edit.
+     * @returns {Promise<ReviewItem>} - Edited item.
+     */
+    editTranslation(item: ReviewItem): Promise<ReviewItem>;
+    /**
+     * Show help information to the user.
+     */
+    showHelp(): void;
+    /**
+     * Show summary of review session.
+     */
+    showSummary(): void;
+    /**
+     * Save review decisions to disk and apply them.
+     */
+    saveDecisions(): void;
+    /**
+     * Apply accepted and edited translations to locale files.
+     */
+    applyDecisions(): void;
+    /**
+     * Set nested value in object using dot notation.
+     * @param {any} obj - Object to modify.
+     * @param {string} path - Dot notation path.
+     * @param {any} value - Value to set.
+     */
+    setNestedValue(obj: any, path: string, value: any): void;
+    /**
+     * Get user input from terminal.
+     * @param {string} prompt - Prompt to display.
+     * @returns {Promise<string>} - User input.
+     */
+    getUserInput(prompt: string): Promise<string>;
+    /**
+     * Export review queue to JSON.
+     * @param {string} format - Export format (json or csv).
+     */
+    exportReviewQueue(format?: string): void;
+    /**
+     * Convert review queue to CSV format.
+     * @param {ReviewItem[]} items - Items to convert.
+     * @returns {string} - CSV content.
+     */
+    convertToCSV(items: ReviewItem[]): string;
+}
+export default ReviewCommand;

package/dist/commands/translator.d.ts

@@ -0,0 +1,23 @@
+import { TranslationOptions, GlobalStats } from "../services/translation-service.js";
+/**
+ * Main translator function to process source file and create translations.
+ * @param {string} file - Source file path.
+ * @param {TranslationOptions} options - Translation options.
+ * @returns {Promise<GlobalStats>} - Translation result.
+ */
+declare function translateFile(file: string, options: TranslationOptions): Promise<GlobalStats>;
+/**
+ * Find locale files based on source language.
+ * @param {string} localesDir - Locales directory.
+ * @param {string} sourceLang - Source language code.
+ * @returns {Promise<Array<string>>} - Array of locale file paths.
+ */
+declare function findLocaleFiles(localesDir: string, sourceLang: string): Promise<string[]>;
+/**
+ * Validate and fix existing translations that have length issues.
+ * @param {string} file - File path to validate.
+ * @param {TranslationOptions} options - Validation options.
+ * @returns {Promise<void>}
+ */
+declare function validateAndFixExistingTranslations(file: string, options: TranslationOptions): Promise<void>;
+export { translateFile, findLocaleFiles, validateAndFixExistingTranslations };

package/dist/config/index.d.ts

@@ -0,0 +1,145 @@
+import { ConfigLayer } from "c12";
+import { OrchestratorOptions } from "../core/orchestrator.js";
+export interface LocalizeConfig extends Omit<Partial<OrchestratorOptions>, "context"> {
+    /**
+     * Source language code (e.g. 'en')
+     */
+    source?: string;
+    /**
+     * Target language codes (e.g. ['tr', 'es'])
+     */
+    targets?: string[];
+    /**
+     * Filter by file extensions (e.g. ['.json', '.arb'])
+     */
+    fileExtensions?: string[];
+    /**
+     * Directory where localization files are stored
+     * @default "./locales"
+     */
+    localesDir?: string;
+    /**
+     * API Provider to use for translations
+     * @default "openai"
+     */
+    apiProvider?: string;
+    /**
+     * Enable debug mode with verbose logging
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Force update of existing translations
+     * @default false
+     */
+    forceUpdate?: boolean;
+    /**
+     * Synchronization options
+     */
+    syncOptions?: {
+        enabled?: boolean;
+        removeDeletedKeys?: boolean;
+        retranslateModified?: boolean;
+        stateTracking?: {
+            enabled?: boolean;
+            stateFileName?: string;
+            stateDir?: string;
+        };
+    };
+    /**
+     * Concurrency limit for parallel translations
+     * @default 5
+     */
+    concurrencyLimit?: number;
+    /**
+     * Save low-confidence items for manual review
+     * @default false
+     */
+    saveReviewQueue?: boolean;
+    /**
+     * Minimum confidence threshold (0-1)
+     */
+    minConfidence?: number;
+    fileOperations?: {
+        /**
+         * File format to use (json, yaml, po, properties, etc.)
+         * @default "json"
+         */
+        format?: "json" | "yaml" | "po" | "properties" | "arb" | "auto";
+        /**
+         * File structure (flat, nested, namespaced)
+         * @default "flat"
+         */
+        fileStructure?: "flat" | "nested" | "namespaced" | "auto";
+        backupFiles?: boolean;
+        backupDir?: string;
+        atomic?: boolean;
+        createMissingDirs?: boolean;
+    };
+    useAi?: boolean;
+    contextProvider?: string;
+    contextThreshold?: number;
+    contextConfidence?: number;
+    length?: string;
+    autoOptimize?: boolean;
+    stats?: boolean;
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    contextDebug?: boolean;
+    minTextLength?: number;
+    allowNewCategories?: boolean;
+    provider?: string;
+    concurrency?: number | string;
+    noCache?: boolean;
+    force?: boolean;
+    verbose?: boolean;
+    version?: string;
+    rateLimiter?: {
+        enabled?: boolean;
+        queueStrategy?: string;
+        queueTimeout?: number;
+        adaptiveThrottling?: boolean;
+        providerLimits?: any;
+    };
+    context?: {
+        enabled?: boolean;
+        useAI?: boolean;
+        aiProvider?: string;
+        minTextLength?: number;
+        allowNewCategories?: boolean;
+        debug?: boolean;
+        analysisOptions?: {
+            model?: string;
+            temperature?: number;
+            maxTokens?: number;
+            cacheAnalysis?: boolean;
+        };
+        detection?: {
+            threshold?: number;
+            minConfidence?: number;
+        };
+        categories?: any;
+        fallback?: any;
+    };
+    qualityChecks?: {
+        enabled?: boolean;
+        rules?: any;
+        autoFix?: boolean;
+    };
+    command?: string;
+    fixLength?: boolean;
+    showDetailedStats?: boolean;
+}
+/**
+ * Type-safe configuration helper
+ */
+export declare function defineConfig(config: LocalizeConfig): LocalizeConfig;
+/**
+ * Load configuration using c12
+ */
+export declare function loadConfig(cwd?: string): Promise<{
+    config: LocalizeConfig;
+    configFile: string | undefined;
+    layers: ConfigLayer<LocalizeConfig, import("c12").ConfigLayerMeta>[] | undefined;
+}>;

package/dist/core/adapters/base-adapter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Interface for file format adapters
+ */
+export interface FileFormatAdapter {
+    /**
+     * File extensions supported by this adapter (including dot, e.g. ".json")
+     */
+    extensions: string[];
+    /**
+     * Parse file content into a key-value object
+     * @param content - Raw string content
+     */
+    parse(content: string): Promise<Record<string, any>>;
+    /**
+     * Serialize data object into string format
+     * @param data - Key-value object
+     * @param options - Serialization options
+     */
+    serialize(data: Record<string, any>, options?: any): Promise<string>;
+}

package/dist/core/adapters/factory.d.ts

@@ -0,0 +1,16 @@
+import { FileFormatAdapter } from "./base-adapter.js";
+/**
+ * Factory class to manage file format adapters
+ */
+export declare class FormatFactory {
+    private static adapters;
+    /**
+     * Get adapter for a specific file path
+     * @param filePath - Path to file
+     */
+    static getAdapter(filePath: string): FileFormatAdapter;
+    /**
+     * Get adapter by format name (json, yaml, etc.)
+     */
+    static getAdapterByFormat(format: string): FileFormatAdapter;
+}

package/dist/core/adapters/json-adapter.d.ts

@@ -0,0 +1,9 @@
+import { FileFormatAdapter } from "./base-adapter.js";
+/**
+ * Adapter for JSON files
+ */
+export declare class JsonAdapter implements FileFormatAdapter {
+    extensions: string[];
+    parse(content: string): Promise<Record<string, any>>;
+    serialize(data: Record<string, any>, options?: any): Promise<string>;
+}

package/dist/core/adapters/po-adapter.d.ts

@@ -0,0 +1,9 @@
+import { FileFormatAdapter } from "./base-adapter.js";
+/**
+ * Adapter for Gettext PO files
+ */
+export declare class PoAdapter implements FileFormatAdapter {
+    extensions: string[];
+    parse(content: string): Promise<Record<string, any>>;
+    serialize(data: Record<string, any>, options?: any): Promise<string>;
+}

package/dist/core/adapters/properties-adapter.d.ts

@@ -0,0 +1,9 @@
+import { FileFormatAdapter } from "./base-adapter.js";
+/**
+ * Adapter for Java .properties files
+ */
+export declare class PropertiesAdapter implements FileFormatAdapter {
+    extensions: string[];
+    parse(content: string): Promise<Record<string, any>>;
+    serialize(data: Record<string, any>, options?: any): Promise<string>;
+}

package/dist/core/adapters/yaml-adapter.d.ts

@@ -0,0 +1,9 @@
+import { FileFormatAdapter } from "./base-adapter.js";
+/**
+ * Adapter for YAML files
+ */
+export declare class YamlAdapter implements FileFormatAdapter {
+    extensions: string[];
+    parse(content: string): Promise<Record<string, any>>;
+    serialize(data: Record<string, any>, options?: any): Promise<string>;
+}

package/dist/core/context-processor.d.ts

@@ -0,0 +1,81 @@
+interface CategoryConfig {
+    keywords: string[];
+    weight?: number;
+    prompt?: string;
+}
+export interface ContextConfig {
+    enabled?: boolean;
+    useAI?: boolean;
+    aiProvider?: string;
+    minTextLength?: number;
+    analysisOptions?: {
+        cacheAnalysis?: boolean;
+    };
+    categories: Record<string, CategoryConfig>;
+    detection: {
+        threshold: number;
+        minConfidence: number;
+    };
+    fallback: {
+        category: string;
+        prompt: string;
+    };
+}
+interface AnalysisResult {
+    category: string;
+    confidence: number;
+    prompt?: string;
+    matches: number;
+    aiAnalyzed?: boolean;
+    keywords?: string[];
+}
+/**
+ * Handles context analysis for translation keys.
+ * Uses keyword matching and optional AI analysis to determine the best context category.
+ */
+declare class ContextProcessor {
+    private config;
+    private keywordCache;
+    private aiAnalyzer;
+    private resultCache;
+    /**
+     * Create a new ContextProcessor instance.
+     * @param config - Configuration object.
+     */
+    constructor(config: any);
+    /**
+     * Initialize keyword matching patterns from configuration.
+     */
+    initializeKeywords(): void;
+    /**
+     * Perform context analysis on a batch of texts.
+     * @param texts - Array of texts to analyze.
+     * @returns - Array of context analysis results.
+     */
+    analyzeBatch(texts: string[]): Promise<AnalysisResult[]>;
+    /**
+     * Perform context analysis on a single text.
+     * @param text - Text to analyze.
+     * @returns - Context analysis result.
+     */
+    analyze(text: string): Promise<AnalysisResult>;
+    /**
+     * Perform keyword-based analysis on text.
+     * @param text - Text to analyze.
+     * @returns - Keyword analysis result.
+     */
+    private _performKeywordAnalysis;
+    /**
+     * Determine the best category match from analysis results.
+     */
+    private getBestMatch;
+    /**
+     * Get fallback analysis result.
+     */
+    private getFallback;
+    /**
+     * Generate a collision-resistant cache key for text and context.
+     */
+    private getCacheKey;
+}
+export default ContextProcessor;

package/dist/core/detection/framework-detector.d.ts

@@ -0,0 +1,9 @@
+export interface DetectedConfig {
+    framework: "next" | "vue" | "react" | "flutter" | "unknown";
+    localesDir?: string;
+    fileFormat?: "json" | "yaml" | "po" | "arb" | "properties";
+    source?: string;
+}
+export declare class FrameworkDetector {
+    static detect(projectRoot: string): Promise<DetectedConfig | null>;
+}

package/dist/core/detection/structure-detector.d.ts

@@ -0,0 +1,9 @@
+export declare enum LocaleStructure {
+    FLAT = "flat",// en.json, tr.json
+    NESTED = "nested",// en/common.json, tr/common.json
+    NAMESPACED = "namespaced",// common.en.json (less common)
+    UNKNOWN = "unknown"
+}
+export declare class StructureDetector {
+    static detect(localesDir: string): Promise<LocaleStructure>;
+}

package/dist/core/fallback-provider.d.ts

@@ -0,0 +1,54 @@
+import { TranslateOptions, ProviderConfig } from "../providers/base-provider.js";
+export interface ProviderModule {
+    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>;
+    [key: string]: any;
+}
+export interface ProviderWrapper {
+    name: string;
+    implementation: ProviderModule;
+}
+interface ProviderStats {
+    success: number;
+    failure: number;
+    avgResponseTime: number;
+    totalTime: number;
+    lastSuccess: Date | null;
+    consecutiveFailures: number;
+    lastError: {
+        time: Date;
+        message: string;
+    } | null;
+    disabled: boolean;
+    disabledUntil: number | null;
+    successRate?: number;
+    totalCalls?: number;
+    avgResponseTimeMs?: number;
+    isDisabled?: boolean;
+    enablesInMs?: number;
+}
+declare class FallbackProvider {
+    private providers;
+    private currentIndex;
+    private providerStats;
+    private maxRetries;
+    private reRankInterval;
+    private operationCount;
+    private lastErrorTime;
+    private consecutiveErrors;
+    constructor(providers: ProviderWrapper[]);
+    _calculatePriority(text: string): number;
+    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>;
+    getStats(): Record<string, ProviderStats>;
+    reset(): void;
+    resetStats(): void;
+    _checkAndReRankProviders(): void;
+    _disableProvider(provider: ProviderWrapper, timeoutMs?: number): void;
+    _isProviderDisabled(provider?: ProviderWrapper): boolean;
+    _resetDisabledProviders(): void;
+    _getProviderName(provider: ProviderWrapper): string;
+}
+export default FallbackProvider;

package/dist/core/orchestrator.d.ts

@@ -0,0 +1,101 @@
+import ProgressTracker from "../utils/progress-tracker.js";
+import QualityChecker from "../utils/quality/index.js";
+import { ContextConfig } from "./context-processor.js";
+import { LRUCache } from "lru-cache";
+import GlossaryManager from "../utils/glossary-manager.js";
+import { TranslationResult } from "./pipeline/context.js";
+import { CacheStats } from "./pipeline/steps/CacheReadStep.js";
+import { ConfidenceSettings } from "./pipeline/steps/TranslationStep.js";
+export interface OrchestratorOptions {
+    context: ContextConfig;
+    progressOptions?: any;
+    styleGuide?: any;
+    lengthControl?: any;
+    qualityChecks?: {
+        enabled?: boolean;
+        rules?: any;
+    };
+    advanced?: {
+        timeoutMs?: number;
+        maxKeyLength?: number;
+        maxBatchSize?: number;
+        autoOptimize?: boolean;
+        debug?: boolean;
+    };
+    glossary?: any;
+    rateLimiter?: {
+        queueStrategy?: string;
+        queueTimeout?: number;
+        adaptiveThrottling?: boolean;
+        providerLimits?: any;
+    };
+    cacheSize?: number;
+    cacheTTL?: number;
+    updateAgeOnGet?: boolean;
+    allowStaleCache?: boolean;
+    staleWhileRevalidate?: boolean;
+    minConfidence?: number;
+    saveReviewQueue?: boolean;
+    confidenceScoring?: {
+        enabled?: boolean;
+        minConfidence?: number;
+        saveReviewQueue?: boolean;
+        autoApproveThreshold?: number;
+        reviewThreshold?: number;
+        rejectThreshold?: number;
+    };
+    concurrencyLimit?: number;
+    cacheEnabled?: boolean;
+    source: string;
+    [key: string]: any;
+}
+import { VectorStore } from "../services/vector-store.js";
+import { EmbeddingProvider } from "../services/embedding-provider.js";
+import { VectorMemoryStats } from "./pipeline/steps/VectorCacheReadStep.js";
+interface AdvancedSettings {
+    timeoutMs: number;
+    maxKeyLength: number;
+    maxBatchSize: number;
+    autoOptimize: boolean;
+    debug: boolean;
+}
+interface TranslationItem {
+    key: string;
+    text: string;
+    targetLang: string;
+    existingTranslation?: any;
+    [key: string]: any;
+}
+declare class Orchestrator {
+    private options;
+    private contextProcessor;
+    progress: ProgressTracker;
+    qualityChecker: QualityChecker | any;
+    advanced: AdvancedSettings;
+    glossaryManager: GlossaryManager;
+    translationCache: LRUCache<string, any> | null;
+    cacheStats: CacheStats;
+    vectorStore: VectorStore;
+    embeddingProvider: EmbeddingProvider;
+    vectorStats: VectorMemoryStats;
+    confidenceSettings: ConfidenceSettings;
+    private concurrencyLimit;
+    private pipeline;
+    private _shutdownCallback;
+    constructor(options: OrchestratorOptions);
+    private _buildPipeline;
+    processTranslation(key: string, text: string, targetLang: string, contextData: any, existingTranslation: any): Promise<TranslationResult>;
+    processTranslations(items: TranslationItem[]): Promise<TranslationResult[]>;
+    private _chunkArray;
+    private _applyAutoOptimizations;
+    clearCache(): void;
+    resetCacheStats(): void;
+    getCacheStats(): any;
+    _refreshCacheEntry(key: string, context: any): Promise<void>;
+    getStatus(): any;
+    saveReviewQueue(): void;
+    private _groupByLanguage;
+    private _groupByConfidenceLevel;
+    destroy(): void;
+}
+export default Orchestrator;

package/dist/core/orchestrator.js

@@ -222,7 +222,6 @@ class Orchestrator {
         if (this.advanced.debug) {
             log(`Processing ${items.length} items with concurrency limit ${this.concurrencyLimit}`, true);
         }
-        console.log(""); // Empty line for progress bar
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const allPromises = [];
         for (const chunk of chunks) {

package/dist/core/pipeline/Pipeline.d.ts

@@ -0,0 +1,23 @@
+import PipelineStep from "./PipelineStep.js";
+import { TranslationContext } from "./context.js";
+/**
+ * Generic Pipeline class implementing the middleware pattern.
+ * Allows composing a sequence of steps that can process a context object.
+ */
+declare class Pipeline {
+    steps: any[];
+    constructor();
+    /**
+     * Add a step to the pipeline.
+     * @param step - A step instance with an execute(context, next) method.
+     * @returns - Returns self for chaining.
+     */
+    use(step: PipelineStep | any): Pipeline;
+    /**
+     * Execute the pipeline with the given context.
+     * @param context - The context object to be processed.
+     * @returns - The processed context.
+     */
+    execute(context: TranslationContext): Promise<TranslationContext>;
+}
+export default Pipeline;

package/dist/core/pipeline/PipelineStep.d.ts

@@ -0,0 +1,18 @@
+import { TranslationContext } from "./context.js";
+/**
+ * Base class for pipeline steps.
+ * All steps should extend this or implement the execute method.
+ */
+declare abstract class PipelineStep {
+    /**
+     * Name of the step for debugging/logging purposes.
+     */
+    get name(): string;
+    /**
+     * Execute the step logic.
+     * @param context - Translation context.
+     * @param next - Next step callback.
+     */
+    abstract execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}
+export default PipelineStep;