locai 2.1.2 → 2.2.0

package/dist/utils/quality/base-checker.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Base Quality Checker.
+ * Common infrastructure for all quality checkers.
+ */
+export interface CheckerOptions {
+    placeholderConsistency?: boolean;
+    htmlTagsConsistency?: boolean;
+    punctuationCheck?: boolean;
+    lengthValidation?: boolean;
+    sanitizeOutput?: boolean;
+    rules?: Record<string, any>;
+    styleGuide?: {
+        formality?: string;
+        toneOfVoice?: string;
+    };
+    context?: Record<string, any>;
+    [key: string]: any;
+}
+export interface Issue {
+    type: string;
+    message: string;
+    timestamp: string;
+    [key: string]: any;
+}
+export interface Fix {
+    type: string;
+    message: string;
+    timestamp: string;
+    [key: string]: any;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    issues: Issue[];
+    source?: string;
+    translated?: string;
+    context?: Record<string, any>;
+}
+export interface FixResult {
+    originalText: string;
+    fixedText: string;
+    isModified: boolean;
+    issues: Issue[];
+    fixes: Fix[];
+    metadata?: {
+        sourceLength: number;
+        originalLength: number;
+        fixedLength: number;
+        timestamp: string;
+    };
+}
+declare class BaseChecker {
+    protected rules: Record<string, boolean | any>;
+    protected styleGuide: {
+        formality: string;
+        toneOfVoice: string;
+    };
+    /**
+     * Create a new BaseChecker.
+     * @param {CheckerOptions} [options={}] - Configuration options.
+     */
+    constructor(options?: CheckerOptions);
+    /**
+     * Create an issue object.
+     */
+    createIssue(type: string, message: string, details?: Record<string, any>): Issue;
+    /**
+     * Create a fix object.
+     */
+    createFix(type: string, message: string, details?: Record<string, any>): Fix;
+    /**
+     * Validate translation.
+     */
+    validate(_sourceText: string, _translatedText: string, _options?: any): ValidationResult;
+    /**
+     * Validate and fix translation.
+     */
+    validateAndFix(sourceText: string, translatedText: string): FixResult;
+}
+export default BaseChecker;

package/dist/utils/quality/code-block-checker.d.ts

@@ -0,0 +1,64 @@
+export interface CodeBlockIssue {
+    type: "code-block-count" | "code-block-modified" | "code-block-restore";
+    severity: "error" | "critical";
+    message: string;
+    details?: any;
+}
+export interface CodeBlockFixResult {
+    text: string;
+    foundIssues: CodeBlockIssue[];
+    appliedFixes: {
+        type: "code-block-restore";
+        message: string;
+    }[];
+}
+export interface CodeBlock {
+    type: "fenced" | "inline" | "html-code" | "html-pre";
+    full: string;
+    code: string;
+    position: number;
+}
+/**
+ * Code Block Preservation Checker.
+ * Ensures code blocks are preserved exactly during translation.
+ */
+declare class CodeBlockChecker {
+    private codePatterns;
+    constructor();
+    /**
+     * Check if code blocks are preserved.
+     */
+    checkCodeBlockPreservation(sourceText: string, translatedText: string): CodeBlockIssue[];
+    /**
+     * Extract all code blocks from text.
+     */
+    extractCodeBlocks(text: string): CodeBlock[];
+    /**
+     * Fix code block preservation issues.
+     */
+    fixCodeBlockPreservation(sourceText: string, translatedText: string): CodeBlockFixResult;
+    /**
+     * Restore missing code blocks from source.
+     */
+    restoreCodeBlocks(sourceText: string, translatedText: string, sourceCodeBlocks: CodeBlock[]): {
+        text: string;
+        appliedFixes: any[];
+    };
+    /**
+     * Protect code blocks before translation.
+     * Replaces code blocks with tokens to prevent translation.
+     */
+    protectCodeBlocks(text: string): {
+        protectedText: string;
+        tokenMap: Map<string, string>;
+    };
+    /**
+     * Restore code blocks after translation.
+     */
+    restoreCodeBlocksFromTokens(text: string, tokenMap: Map<string, string>): string;
+    /**
+     * Check if text contains code blocks.
+     */
+    hasCodeBlocks(text: string): boolean;
+}
+export default CodeBlockChecker;

package/dist/utils/quality/html-tag-checker.d.ts

@@ -0,0 +1,33 @@
+export interface HtmlTagIssue {
+    type: "htmlTag";
+    message: string;
+    source?: string[];
+    translated?: string[];
+}
+export interface HtmlTagFixResult {
+    text: string;
+    foundIssues: HtmlTagIssue[];
+    appliedFixes: {
+        type: "htmlTag";
+        message: string;
+    }[];
+}
+/**
+ * HTML Tag Consistency Checker.
+ * Ensures HTML tags are preserved and correctly nested in translations.
+ */
+declare class HtmlTagChecker {
+    /**
+     * Check for HTML tag mismatches between source and translation.
+     */
+    checkHtmlTags(source: string, translated: string): HtmlTagIssue[];
+    /**
+     * Fix missing HTML tags in translated text.
+     */
+    fixHtmlTags(source: string, translated: string): HtmlTagFixResult;
+    /**
+     * Insert HTML tag into text.
+     */
+    insertHtmlTag(text: string, tag: string): string;
+}
+export default HtmlTagChecker;

package/dist/utils/quality/index.d.ts

@@ -0,0 +1,39 @@
+import BaseChecker, { CheckerOptions, FixResult, ValidationResult } from "./base-checker.js";
+/**
+ * Main Quality Checker Class.
+ * Orchestrates various quality checks and fixes for translated text.
+ */
+declare class QualityChecker extends BaseChecker {
+    private placeholderChecker;
+    private htmlTagChecker;
+    private punctuationChecker;
+    private lengthChecker;
+    private textSanitizer;
+    private quoteBalanceChecker;
+    private styleGuideChecker;
+    private markdownChecker;
+    private codeBlockChecker;
+    private specialCharactersChecker;
+    private context;
+    /**
+     * Initialize QualityChecker with options.
+     */
+    constructor(options?: CheckerOptions);
+    /**
+     * Initialize all individual checkers.
+     */
+    initializeCheckers(): void;
+    /**
+     * Validate translated text against source text.
+     */
+    validate(sourceText: string, translatedText: string, options?: Record<string, any>): ValidationResult;
+    /**
+     * Validate and attempt to fix translated text.
+     */
+    validateAndFix(sourceText: string, translatedText: string): FixResult;
+    /**
+     * Sanitize translated text using multiple passes.
+     */
+    sanitizeTranslation(text: string): string;
+}
+export default QualityChecker;

package/dist/utils/quality/length-checker.d.ts

@@ -0,0 +1,70 @@
+export interface LengthConfig {
+    mode: "strict" | "flexible" | "exact" | "relaxed" | "smart";
+    maxDeviation: number;
+    minDeviation: number;
+    targetLang?: string;
+    context?: string;
+}
+export interface LengthIssue {
+    type: "length";
+    severity: "critical" | "warning" | "error";
+    message: string;
+    details: {
+        mode?: string;
+        context?: string;
+        targetLang?: string;
+        sourceLength?: number;
+        translatedLength?: number;
+        ratio?: number;
+        allowedRange?: {
+            min: number;
+            max: number;
+        };
+        deviation?: number;
+        error?: string;
+    };
+}
+/**
+ * Length Validation Checker.
+ * Checks if translated text length is within acceptable bounds relative to source text.
+ */
+declare class LengthChecker {
+    private defaultConfig;
+    constructor();
+    /**
+     * Check if translated text length is acceptable.
+     */
+    checkLength(source: string, translated: string, options?: any): LengthIssue[];
+    /**
+     * Calculate length of text ignoring whitespace.
+     */
+    calculateLength(text: string): number;
+    /**
+     * Get configuration for length check.
+     */
+    getConfig(options: any): LengthConfig;
+    /**
+     * Get configuration for smart mode.
+     */
+    getSmartModeConfig(lengthControl: any, targetLang: string, context: string): LengthConfig;
+    /**
+     * Get configuration for standard mode.
+     */
+    getStandardModeConfig(lengthControl: any, mode: any, targetLang: string, context: string): LengthConfig;
+    /**
+     * Calculate allowed length ratio range.
+     */
+    calculateAllowedRange(config: LengthConfig): {
+        minRatio: number;
+        maxRatio: number;
+    };
+    /**
+     * Determine severity of length mismatch.
+     */
+    determineSeverity(ratio: number, minRatio: number, maxRatio: number): "critical" | "warning";
+    /**
+     * Generate error message for length mismatch.
+     */
+    generateErrorMessage(ratio: number, config: LengthConfig): string;
+}
+export default LengthChecker;

package/dist/utils/quality/markdown-checker.d.ts

@@ -0,0 +1,63 @@
+export interface MarkdownIssue {
+    type: "markdown-preservation" | "markdown-link" | "markdown-missing";
+    severity: "error" | "warning" | "critical";
+    message: string;
+    pattern?: string;
+    details?: any;
+}
+export interface MarkdownFixResult {
+    text: string;
+    foundIssues: MarkdownIssue[];
+    appliedFixes: {
+        type: "markdown-link";
+        message: string;
+    }[];
+}
+/**
+ * Markdown Preservation Checker.
+ * Ensures markdown formatting is preserved during translation.
+ */
+declare class MarkdownChecker {
+    private markdownPatterns;
+    constructor();
+    /**
+     * Check if markdown is preserved between source and translation.
+     */
+    checkMarkdownPreservation(sourceText: string, translatedText: string): MarkdownIssue[];
+    /**
+     * Check for broken markdown links.
+     */
+    checkBrokenMarkdownLinks(text: string): MarkdownIssue[];
+    /**
+     * Fix markdown preservation issues.
+     */
+    fixMarkdownPreservation(sourceText: string, translatedText: string): MarkdownFixResult;
+    /**
+     * Extract markdown elements from text.
+     */
+    extractMarkdownElements(text: string): Record<string, any[]>;
+    /**
+     * Restore markdown elements that were lost in translation.
+     */
+    restoreMarkdownElements(text: string, elements: any[], type: string): {
+        text: string;
+        foundIssues: MarkdownIssue[];
+        appliedFixes: any[];
+    };
+    /**
+     * Fix broken markdown links.
+     */
+    fixBrokenLinks(text: string): {
+        text: string;
+        foundIssues: MarkdownIssue[];
+        appliedFixes: {
+            type: "markdown-link";
+            message: string;
+        }[];
+    };
+    /**
+     * Check if text contains markdown.
+     */
+    hasMarkdown(text: string): boolean;
+}
+export default MarkdownChecker;

package/dist/utils/quality/placeholder-checker.d.ts

@@ -0,0 +1,42 @@
+export interface PlaceholderIssue {
+    type: "placeholder";
+    message: string;
+    source?: string[] | string;
+    translated?: string[] | string;
+    corrupted?: string;
+}
+export interface PlaceholderFixResult {
+    text: string;
+    foundIssues: PlaceholderIssue[];
+    appliedFixes: {
+        type: "placeholder";
+        message: string;
+    }[];
+}
+/**
+ * Placeholder Consistency Checker.
+ * Ensures placeholders like {name}, ${value}, %s are preserved correctly.
+ */
+declare class PlaceholderChecker {
+    /**
+     * Check for placeholder mismatches or corruptions.
+     */
+    checkPlaceholders(source: string, translated: string): PlaceholderIssue[];
+    /**
+     * Fix corrupted or missing placeholders in translated text.
+     */
+    fixPlaceholders(source: string, translated: string): PlaceholderFixResult;
+    /**
+     * Find a corrupted version of a placeholder in translated text.
+     */
+    findCorruptedPlaceholder(translated: string, sourcePlaceholder: string): string | null;
+    /**
+     * Find best position to insert a missing placeholder.
+     */
+    findBestPlaceholderPosition(translated: string, source: string, placeholder: string): number;
+    /**
+     * Insert placeholder into text at specified position.
+     */
+    insertPlaceholder(text: string, placeholder: string, position: number): string;
+}
+export default PlaceholderChecker;

package/dist/utils/quality/punctuation-checker.d.ts

@@ -0,0 +1,31 @@
+export interface PunctuationIssue {
+    type: "punctuation";
+    message: string;
+}
+export interface PunctuationFixResult {
+    text: string;
+    foundIssues: PunctuationIssue[];
+    appliedFixes: {
+        type: "punctuation";
+        message: string;
+    }[];
+}
+/**
+ * Punctuation Consistency Checker.
+ * Ensures end punctuation marks are preserved in translation.
+ */
+declare class PunctuationChecker {
+    /**
+     * Check for punctuation mismatches.
+     */
+    checkPunctuation(source: string, translated: string): PunctuationIssue[];
+    /**
+     * Fix missing punctuation marks.
+     */
+    fixPunctuation(source: string, translated: string): PunctuationFixResult;
+    /**
+     * Add punctuation to the end of text.
+     */
+    addPunctuation(text: string, punctuation: string): string;
+}
+export default PunctuationChecker;

package/dist/utils/quality/quote-balance-checker.d.ts

@@ -0,0 +1,37 @@
+export interface QuoteIssue {
+    type: "unbalanced-quotes" | "quote-consistency" | "quote-balance";
+    severity: "error" | "warning";
+    message: string;
+    char?: string;
+}
+export interface QuoteFixResult {
+    text: string;
+    foundIssues: QuoteIssue[];
+    appliedFixes: {
+        type: "quote-balance";
+        message: string;
+    }[];
+}
+/**
+ * Quote Balance Checker.
+ * Ensures quotes (single, double, guillemets, etc.) are balanced in translation.
+ */
+declare class QuoteBalanceChecker {
+    /**
+     * Check for unbalanced quotes.
+     */
+    checkQuoteBalance(text: string): QuoteIssue[];
+    /**
+     * Count occurrences of a quote character.
+     */
+    private _countQuotes;
+    /**
+     * Fix unbalanced quotes.
+     */
+    fixQuoteBalance(text: string): QuoteFixResult;
+    /**
+     * Validate that quotes in source and translation match in pattern.
+     */
+    validateQuoteConsistency(source: string, translated: string): QuoteIssue[];
+}
+export default QuoteBalanceChecker;

package/dist/utils/quality/special-characters-checker.d.ts

@@ -0,0 +1,66 @@
+export interface SpecialCharIssue {
+    type: "special-characters" | "special-character-substitution" | "emoji-preservation" | "missing-special-chars" | "character-substitution";
+    category?: string;
+    severity: "error" | "warning";
+    message: string;
+    details?: any;
+}
+export interface SpecialCharFixResult {
+    text: string;
+    foundIssues: SpecialCharIssue[];
+    appliedFixes: {
+        type: "critical-char-restore" | "character-substitution";
+        message: string;
+    }[];
+}
+/**
+ * Special Characters Preservation Checker.
+ * Ensures special characters, symbols, and formatting are preserved.
+ */
+declare class SpecialCharactersChecker {
+    private specialCharacterSets;
+    private criticalCharacters;
+    constructor();
+    /**
+     * Check if special characters are preserved.
+     */
+    checkSpecialCharacters(sourceText: string, translatedText: string): SpecialCharIssue[];
+    /**
+     * Check emoji preservation.
+     */
+    checkEmojiPreservation(sourceText: string, translatedText: string): SpecialCharIssue[];
+    /**
+     * Fix special character issues.
+     */
+    fixSpecialCharacters(sourceText: string, translatedText: string): SpecialCharFixResult;
+    /**
+     * Extract special characters by category.
+     */
+    extractSpecialCharacters(text: string): Record<string, string[]>;
+    /**
+     * Restore critical characters that were lost.
+     */
+    restoreCriticalCharacters(sourceText: string, translatedText: string, missingChars: string[]): {
+        text: string;
+        appliedFixes: {
+            type: "critical-char-restore";
+            message: string;
+        }[];
+    };
+    /**
+     * Fix common character substitutions.
+     */
+    fixCommonSubstitutions(sourceText: string, translatedText: string): {
+        text: string;
+        foundIssues: SpecialCharIssue[];
+        appliedFixes: {
+            type: "character-substitution";
+            message: string;
+        }[];
+    };
+    /**
+     * Check if text has special characters.
+     */
+    hasSpecialCharacters(text: string): boolean;
+}
+export default SpecialCharactersChecker;

package/dist/utils/quality/style-guide-checker.d.ts

@@ -0,0 +1,71 @@
+import { ProviderConfig } from "../../providers/base-provider.js";
+export interface StyleGuideConfig {
+    formality?: string;
+    toneOfVoice?: string;
+    toneProvider?: string;
+    analysisOptions?: ProviderConfig;
+    enforceTone?: boolean;
+    conventions?: {
+        useOxfordComma?: boolean;
+        useSentenceCase?: boolean;
+        [key: string]: any;
+    };
+}
+export interface StyleIssue {
+    type: "oxford-comma" | "sentence-case";
+    severity: "warning" | "info";
+    message: string;
+    suggestion?: string;
+}
+export interface StyleFixResult {
+    text: string;
+    foundIssues: StyleIssue[];
+    appliedFixes: {
+        type: "oxford-comma" | "sentence-case";
+        message: string;
+    }[];
+}
+/**
+ * Style Guide Checker.
+ * Enforces style guide conventions like Oxford comma and sentence case.
+ */
+declare class StyleGuideChecker {
+    private styleGuide;
+    constructor(styleGuide?: StyleGuideConfig);
+    /**
+     * Check if text follows style guide conventions.
+     */
+    checkStyleGuide(_sourceText: string, translatedText: string): StyleIssue[];
+    /**
+     * Check for Oxford comma usage in lists.
+     */
+    checkOxfordComma(text: string): StyleIssue[];
+    /**
+     * Check sentence case for headings/titles.
+     */
+    checkSentenceCase(text: string): StyleIssue[];
+    /**
+     * Fix style guide issues.
+     */
+    fixStyleGuide(sourceText: string, translatedText: string): StyleFixResult;
+    /**
+     * Fix missing Oxford commas.
+     */
+    fixOxfordComma(text: string): StyleFixResult;
+    /**
+     * Fix sentence case issues.
+     */
+    fixSentenceCase(text: string): {
+        text: string;
+        foundIssues: StyleIssue[];
+        appliedFixes: {
+            type: "sentence-case";
+            message: string;
+        }[];
+    };
+    /**
+     * Convert text to sentence case.
+     */
+    convertToSentenceCase(text: string): string;
+}
+export default StyleGuideChecker;

package/dist/utils/quality/text-sanitizer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Text Sanitizer.
+ * Cleans up translated text by removing AI artifacts, think tags, and unwanted formatting.
+ */
+declare class TextSanitizer {
+    /**
+     * Sanitize text by applying a sequence of cleaning rules.
+     */
+    sanitize(text: string): string;
+    /**
+     * Apply a list of rules to text.
+     */
+    applyRules(text: string, rules: ((text: string) => string)[]): string;
+    /**
+     * Remove <think> tags and their content.
+     */
+    removeThinkTags: (text: string) => string;
+    /**
+     * Remove bold/italic markdown formatting.
+     */
+    removeMarkdownFormatting: (text: string) => string;
+    /**
+     * Remove leading/trailing quotes.
+     */
+    removeQuotes: (text: string) => string;
+    /**
+     * Remove bullet points at the start.
+     */
+    removeBulletPoints: (text: string) => string;
+    /**
+     * Remove explanatory text and metadata.
+     */
+    removeExplanations: (text: string) => string;
+    /**
+     * Remove common AI conversational artifacts.
+     */
+    removeAIArtifacts: (text: string) => string;
+    /**
+     * Trim special characters from ends.
+     */
+    trimSpecialChars: (text: string) => string;
+    /**
+     * Normalize whitespace and remove duplicate lines.
+     */
+    normalizeWhitespace: (text: string) => string;
+    /**
+     * Aggressive cleanup of all artifacts.
+     */
+    removeAllArtifacts: (text: string) => string;
+}
+export default TextSanitizer;

package/dist/utils/quality/tone-verifier.d.ts

@@ -0,0 +1,14 @@
+import { ProviderConfig } from "../../providers/base-provider.js";
+export interface ToneVerificationResult {
+    passed: boolean;
+    score: number;
+    reasoning: string;
+    suggestions?: string;
+}
+export declare class ToneVerifier {
+    private provider;
+    private initialized;
+    constructor();
+    private initProvider;
+    verify(sourceText: string, translatedText: string, sourceLang: string, targetLang: string, targetTone: string, providerName?: string, options?: ProviderConfig): Promise<ToneVerificationResult>;
+}