locai 2.1.2 → 2.2.0

package/dist/utils/rate-limiter.d.ts

@@ -0,0 +1,73 @@
+export interface RateLimiterConfig {
+    queueStrategy?: "fifo" | "priority";
+    queueTimeout?: number;
+    adaptiveThrottling?: boolean;
+    providerLimits?: Record<string, {
+        rpm?: number;
+        concurrency?: number;
+    }>;
+}
+/**
+ * Handles API rate limiting and request throttling.
+ * Supports provider-specific limits and adaptive throttling.
+ */
+declare class RateLimiter {
+    private queues;
+    private processing;
+    private config;
+    private metrics;
+    private providers;
+    private _processingLocks;
+    /**
+     * Create a new RateLimiter.
+     * @param config - Rate limiter configuration.
+     */
+    constructor(config?: RateLimiterConfig);
+    /**
+     * Update rate limiter configuration.
+     * @param config - Configuration updates.
+     */
+    updateConfig(config: RateLimiterConfig): void;
+    /**
+     * Enqueue a task for execution with rate limiting.
+     * @param provider - Provider name.
+     * @param task - Async task to execute.
+     * @param priority - Task priority (higher is better).
+     * @returns Task result.
+     */
+    enqueue<T>(provider: string, task: () => Promise<T>, priority?: number): Promise<T>;
+    /**
+     * Process the queue for a specific provider.
+     * @param provider - Provider name.
+     */
+    private _processQueue;
+    private _trackResponseTime;
+    private _trackErrorRate;
+    private _adjustThrottling;
+    private _shouldThrottle;
+    private _calculateWaitTime;
+    private _resetCounters;
+    /**
+     * Get current queue size for a provider.
+     * @param provider - Provider name.
+     * @returns Queue size.
+     */
+    getQueueSize(provider: string): number;
+    /**
+     * Get complete rate limiter status.
+     * @returns Status object including active metrics.
+     */
+    getStatus(): Record<string, any>;
+    /**
+     * Get current configuration.
+     * @returns Configuration object.
+     */
+    getConfig(): RateLimiterConfig;
+    /**
+     * Clear all pending queues.
+     */
+    clearAllQueues(): void;
+    private _cleanupMetrics;
+}
+declare const _default: RateLimiter;
+export default _default;

package/dist/utils/rate-limiter.js

@@ -59,6 +59,12 @@ class RateLimiter {
                 lastReset: performance.now(),
                 maxConcurrent: 8,
             },
+            anthropic: {
+                requestsPerMinute: 50,
+                currentRequests: 0,
+                lastReset: performance.now(),
+                maxConcurrent: 5,
+            },
         };
         this._processingLocks = {};
         Object.keys(this.providers).forEach((provider) => {

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

@@ -0,0 +1,49 @@
+/**
+ * Retry helper for API operations with exponential backoff
+ */
+export interface RetryOptions {
+    provider?: string;
+    perProviderRetry?: Record<string, Partial<RetryConfig>>;
+    retryableErrors?: string[];
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    context?: string;
+    logContext?: Record<string, any>;
+    retryCondition?: (error: any, attempts: number, maxRetries: number) => boolean | Promise<boolean>;
+}
+export interface RetryConfig {
+    maxRetries: number;
+    initialDelay: number;
+    maxDelay: number;
+}
+export interface RetryStats {
+    attempts: number;
+    totalTime: number;
+    provider?: string;
+    success?: boolean;
+}
+/**
+ * Retry helper for API operations with exponential backoff.
+ */
+declare class RetryHelper {
+    /**
+     * Retry an operation with configurable backoff strategy.
+     * Supports per-provider retry configuration.
+     */
+    static withRetry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;
+    /**
+     * Calculate exponential backoff with jitter.
+     */
+    static calculateBackoff(attempt: number, initialDelay: number, maxDelay: number): number;
+    /**
+     * Default retry condition based on error type.
+     * Checks against retryableErrors list.
+     */
+    static defaultRetryCondition(error: any, retryableErrors?: string[]): boolean;
+    /**
+     * Promise-based delay.
+     */
+    static delay(ms: number): Promise<void>;
+}
+export default RetryHelper;

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

@@ -0,0 +1,62 @@
+export interface StateOptions {
+    enabled?: boolean;
+    stateFileName?: string;
+    stateDir?: string;
+    [key: string]: any;
+}
+export interface StateComparison {
+    deletedKeys: string[];
+    modifiedKeys: string[];
+    newKeys: string[];
+    hasChanges: boolean;
+}
+export interface StateComparisonStats {
+    totalChanges: number;
+    deletedCount: number;
+    modifiedCount: number;
+    newCount: number;
+    hasChanges: boolean;
+}
+/**
+ * StateManager - Tracks changes in source locale files using hash-based state management
+ * This enables detection of deleted/modified keys to synchronize target locale files
+ */
+declare class StateManager {
+    private options;
+    constructor(options?: StateOptions | {
+        stateTracking: StateOptions;
+    });
+    /**
+     * Generate a SHA-256 hash for given text content
+     */
+    _generateHash(text: string | object): string;
+    /**
+     * Get the full path to the state file
+     */
+    _getStateFilePath(projectRoot: string): string;
+    /**
+     * Load previous state from state file
+     */
+    loadState(projectRoot: string): Promise<Record<string, string>>;
+    /**
+     * Save current state to state file
+     */
+    saveState(projectRoot: string, state: Record<string, string>): Promise<boolean>;
+    /**
+     * Generate state object from source content by creating hashes for each key
+     */
+    generateStateFromSource(sourceContent: Record<string, string>): Record<string, string>;
+    /**
+     * Compare two states and identify changes
+     */
+    compareStates(previousState: Record<string, string>, currentState: Record<string, string>): StateComparison;
+    /**
+     * Get statistics about the state comparison
+     */
+    getComparisonStats(comparison: StateComparison): StateComparisonStats;
+    /**
+     * Clean up old state files (maintenance utility)
+     */
+    cleanupState(projectRoot: string): Promise<boolean>;
+}
+export default StateManager;

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

@@ -0,0 +1,47 @@
+/**
+ * Statistics manager to track translation progress and metrics
+ */
+export interface GlobalStats {
+    total: number;
+    byCategory: Record<string, number>;
+    details: Record<string, {
+        samples: number;
+        totalConfidence: number;
+    }>;
+    totalTime: number;
+    success: number;
+    failed: number;
+    skipped: number;
+    languages: Record<string, LanguageStats>;
+    startTime: string;
+    orchestrators: any[];
+}
+export interface LanguageStats {
+    processed: number;
+    added: number;
+    skipped: number;
+    failed: number;
+    timeMs: number;
+}
+export declare class StatisticsManager {
+    private stats;
+    constructor();
+    /**
+     * Initialize global statistics structure
+     */
+    initializeGlobalStats(): GlobalStats;
+    /**
+     * Reset statistics
+     */
+    reset(): void;
+    /**
+     * Get current stats
+     */
+    getStats(): GlobalStats;
+    /**
+     * Initialize language stats
+     */
+    initLanguageStats(langCode: string): void;
+}
+declare const _default: StatisticsManager;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { GlobalStats } from "./statistics-manager.js";
+/**
+ * UI Manager for handling CLI output and user interaction
+ */
+export declare class UIManager {
+    private consoleLock;
+    constructor();
+    /**
+     * Log a message safely preventing overlap
+     */
+    log(message: string): Promise<void>;
+    /**
+     * Display global summary of translation
+     */
+    displayGlobalSummary(stats: GlobalStats & {
+        totalDuration?: number;
+    }, totalLanguages: number): Promise<void>;
+    logBatchResults(batchResults: any[]): Promise<void>;
+}
+declare const _default: UIManager;
+export default _default;

package/package.json

@@ -1,8 +1,9 @@
 {
 	"name": "locai",
-	"version": "2.1.2",
+	"version": "2.2.0",
 	"type": "module",
 	"main": "dist/core/orchestrator.js",
+	"types": "dist/core/orchestrator.d.ts",
 	"directories": {
 		"src": "src",
 		"dist": "dist"
@@ -30,7 +31,14 @@
 		"localization",
 		"i18n",
 		"nextjs",
-		"ai-translation"
+		"ai-translation",
+		"cli",
+		"automation",
+		"llm",
+		"openai",
+		"gemini",
+		"deepseek",
+		"developer-tools"
 	],
 	"author": {
 		"name": "Ahmet Enes Dur",
@@ -41,12 +49,12 @@
 	"description": "Global, AI-Powered Translation CLI for every project.",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/ahmetenesdur/localization-tool.git"
+		"url": "git+https://github.com/ahmetenesdur/locai.git"
 	},
 	"bugs": {
-		"url": "https://github.com/ahmetenesdur/localization-tool/issues"
+		"url": "https://github.com/ahmetenesdur/locai/issues"
 	},
-	"homepage": "https://github.com/ahmetenesdur/localization-tool#readme",
+	"homepage": "https://github.com/ahmetenesdur/locai#readme",
 	"engines": {
 		"node": ">=14.13.0"
 	},