locai 2.1.0

package/dist/utils/quality/__tests__/tone-verifier.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ToneVerifier } from "../tone-verifier.js";
+import ProviderFactory from "../../../core/provider-factory.js";
+// Mock ProviderFactory
+vi.mock("../../../core/provider-factory.js", () => {
+    const mockProvider = {
+        chat: vi.fn(),
+        analyze: vi.fn(),
+        translate: vi.fn(),
+    };
+    return {
+        default: {
+            getProvider: vi.fn(() => mockProvider),
+            getAvailableProviders: vi.fn(() => ["openai"]),
+        },
+    };
+});
+describe("ToneVerifier", () => {
+    let verifier;
+    let mockProvider;
+    beforeEach(() => {
+        verifier = new ToneVerifier();
+        mockProvider = ProviderFactory.getProvider("openai");
+        vi.clearAllMocks();
+    });
+    it("should use requested provider", async () => {
+        mockProvider.chat.mockResolvedValue(JSON.stringify({ passed: true, score: 10 }));
+        const result = await verifier.verify("src", "trgt", "en", "es", "formal", "gemini");
+        expect(ProviderFactory.getProvider).toHaveBeenCalledWith("gemini", true);
+    });
+    it("should use openai as default provider", async () => {
+        mockProvider.chat.mockResolvedValue(JSON.stringify({ passed: true, score: 10 }));
+        await verifier.verify("src", "trgt", "en", "es", "formal");
+        expect(ProviderFactory.getProvider).toHaveBeenCalledWith("openai", true);
+    });
+    it("should pass options to provider", async () => {
+        mockProvider.chat.mockResolvedValue(JSON.stringify({ passed: true, score: 10 }));
+        const options = { temperature: 0.1 };
+        await verifier.verify("src", "trgt", "en", "es", "formal", "openai", options);
+        expect(mockProvider.chat).toHaveBeenCalledWith(expect.any(Array), options);
+    });
+    it("should initialize provider lazily", async () => {
+        // Mock a valid response to avoid internal error
+        mockProvider.chat.mockResolvedValue(JSON.stringify({ passed: true, score: 10 }));
+        // Create a new instance effectively
+        const newVerifier = new ToneVerifier();
+        // initialize is private but called by verify
+        await newVerifier.verify("src", "trgt", "en", "es", "formal");
+        expect(ProviderFactory.getProvider).toHaveBeenCalled();
+    });
+    it("should return perfect score when no target tone is provided", async () => {
+        const result = await verifier.verify("src", "trgt", "en", "es", "");
+        expect(result.passed).toBe(true);
+        expect(result.score).toBe(10);
+    });
+    it("should parse valid JSON response from chat", async () => {
+        const mockResponse = JSON.stringify({
+            passed: true,
+            score: 9,
+            reasoning: "Good tone",
+            suggestions: "None",
+        });
+        mockProvider.chat.mockResolvedValue(mockResponse);
+        const result = await verifier.verify("Hello", "Hola", "en", "es", "formal");
+        expect(result.passed).toBe(true);
+        expect(result.score).toBe(9);
+        expect(result.reasoning).toBe("Good tone");
+    });
+    it("should clean markdown and parse JSON response", async () => {
+        const mockResponse = "```json\n" +
+            JSON.stringify({
+                passed: false,
+                score: 4,
+                reasoning: "Too casual",
+            }) +
+            "\n```";
+        mockProvider.chat.mockResolvedValue(mockResponse);
+        const result = await verifier.verify("Hello", "Hola", "en", "es", "formal");
+        expect(result.passed).toBe(false);
+        expect(result.score).toBe(4);
+    });
+    it("should fail open (return passed) when provider throws", async () => {
+        mockProvider.chat.mockRejectedValue(new Error("API Error"));
+        const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const result = await verifier.verify("Hello", "Hola", "en", "es", "formal");
+        expect(result.passed).toBe(true);
+        expect(result.score).toBe(0);
+        expect(result.reasoning).toContain("Verification failed");
+        consoleSpy.mockRestore();
+    });
+});

package/dist/utils/quality/base-checker.js

@@ -0,0 +1,73 @@
+/**
+ * Base Quality Checker.
+ * Common infrastructure for all quality checkers.
+ */
+class BaseChecker {
+    rules;
+    styleGuide;
+    /**
+     * Create a new BaseChecker.
+     * @param {CheckerOptions} [options={}] - Configuration options.
+     */
+    constructor(options = {}) {
+        this.rules = {
+            placeholderConsistency: true,
+            htmlTagsConsistency: true,
+            punctuationCheck: true,
+            lengthValidation: true,
+            sanitizeOutput: true,
+            ...options,
+        };
+        this.styleGuide = {
+            formality: options.styleGuide?.formality || "neutral",
+            toneOfVoice: options.styleGuide?.toneOfVoice || "professional",
+        };
+    }
+    /**
+     * Create an issue object.
+     */
+    createIssue(type, message, details = {}) {
+        return {
+            type,
+            message,
+            timestamp: new Date().toISOString(),
+            ...details,
+        };
+    }
+    /**
+     * Create a fix object.
+     */
+    createFix(type, message, details = {}) {
+        return {
+            type,
+            message,
+            timestamp: new Date().toISOString(),
+            ...details,
+        };
+    }
+    /**
+     * Validate translation.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    validate(_sourceText, _translatedText, _options) {
+        const issues = [];
+        return {
+            isValid: issues.length === 0,
+            issues,
+        };
+    }
+    /**
+     * Validate and fix translation.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    validateAndFix(sourceText, translatedText) {
+        return {
+            originalText: translatedText,
+            fixedText: translatedText,
+            isModified: false,
+            issues: [],
+            fixes: [],
+        };
+    }
+}
+export default BaseChecker;

package/dist/utils/quality/code-block-checker.js

@@ -0,0 +1,214 @@
+/**
+ * Code Block Preservation Checker.
+ * Ensures code blocks are preserved exactly during translation.
+ */
+class CodeBlockChecker {
+    codePatterns;
+    constructor() {
+        this.codePatterns = {
+            // Fenced code blocks (```)
+            fencedBlocks: /```[\s\S]*?```/g,
+            // Inline code (`code`)
+            inlineCode: /`([^`]+)`/g,
+            // Indented code blocks (4 spaces)
+            indentedBlocks: /^( {4}|\t).*$/gm,
+            // HTML <code> tags
+            htmlCode: /<code>[\s\S]*?<\/code>/gi,
+            // HTML <pre> tags
+            htmlPre: /<pre>[\s\S]*?<\/pre>/gi,
+        };
+    }
+    /**
+     * Check if code blocks are preserved.
+     */
+    checkCodeBlockPreservation(sourceText, translatedText) {
+        const issues = [];
+        // Extract code blocks from source
+        const sourceCodeBlocks = this.extractCodeBlocks(sourceText);
+        const translatedCodeBlocks = this.extractCodeBlocks(translatedText);
+        // Check count matches
+        if (sourceCodeBlocks.length !== translatedCodeBlocks.length) {
+            issues.push({
+                type: "code-block-count",
+                severity: "error",
+                message: `Code block count mismatch: source has ${sourceCodeBlocks.length}, translation has ${translatedCodeBlocks.length}`,
+                details: {
+                    sourceCount: sourceCodeBlocks.length,
+                    translatedCount: translatedCodeBlocks.length,
+                },
+            });
+        }
+        // Check each code block is preserved exactly
+        for (let i = 0; i < Math.min(sourceCodeBlocks.length, translatedCodeBlocks.length); i++) {
+            const sourceBlock = sourceCodeBlocks[i];
+            const translatedBlock = translatedCodeBlocks[i];
+            if (sourceBlock.code !== translatedBlock.code) {
+                issues.push({
+                    type: "code-block-modified",
+                    severity: "critical",
+                    message: `Code block ${i + 1} was modified during translation`,
+                    details: {
+                        index: i,
+                        sourceCode: sourceBlock.code,
+                        translatedCode: translatedBlock.code,
+                    },
+                });
+            }
+        }
+        return issues;
+    }
+    /**
+     * Extract all code blocks from text.
+     */
+    extractCodeBlocks(text) {
+        const blocks = [];
+        // Extract fenced code blocks
+        const fencedMatches = text.matchAll(this.codePatterns.fencedBlocks);
+        for (const match of fencedMatches) {
+            if (match.index !== undefined) {
+                blocks.push({
+                    type: "fenced",
+                    full: match[0],
+                    code: match[0],
+                    position: match.index,
+                });
+            }
+        }
+        // Extract inline code
+        const inlineMatches = text.matchAll(this.codePatterns.inlineCode);
+        for (const match of inlineMatches) {
+            if (match.index !== undefined) {
+                blocks.push({
+                    type: "inline",
+                    full: match[0],
+                    code: match[1],
+                    position: match.index,
+                });
+            }
+        }
+        // Extract HTML code tags
+        const htmlCodeMatches = text.matchAll(this.codePatterns.htmlCode);
+        for (const match of htmlCodeMatches) {
+            if (match.index !== undefined) {
+                blocks.push({
+                    type: "html-code",
+                    full: match[0],
+                    code: match[0],
+                    position: match.index,
+                });
+            }
+        }
+        // Extract HTML pre tags
+        const htmlPreMatches = text.matchAll(this.codePatterns.htmlPre);
+        for (const match of htmlPreMatches) {
+            if (match.index !== undefined) {
+                blocks.push({
+                    type: "html-pre",
+                    full: match[0],
+                    code: match[0],
+                    position: match.index,
+                });
+            }
+        }
+        return blocks.sort((a, b) => a.position - b.position);
+    }
+    /**
+     * Fix code block preservation issues.
+     */
+    fixCodeBlockPreservation(sourceText, translatedText) {
+        const foundIssues = [];
+        const appliedFixes = [];
+        let fixedText = translatedText;
+        // Extract code blocks from both
+        const sourceCodeBlocks = this.extractCodeBlocks(sourceText);
+        const translatedCodeBlocks = this.extractCodeBlocks(translatedText);
+        // If counts don't match, try to restore from source
+        if (sourceCodeBlocks.length !== translatedCodeBlocks.length) {
+            foundIssues.push({
+                type: "code-block-count",
+                severity: "error", // Added severity
+                message: `Code block count mismatch: ${sourceCodeBlocks.length} vs ${translatedCodeBlocks.length}`,
+            });
+            // Attempt to restore missing code blocks
+            const result = this.restoreCodeBlocks(sourceText, translatedText, sourceCodeBlocks);
+            fixedText = result.text;
+            appliedFixes.push(...result.appliedFixes);
+        }
+        // Fix modified code blocks
+        for (let i = 0; i < Math.min(sourceCodeBlocks.length, translatedCodeBlocks.length); i++) {
+            const sourceBlock = sourceCodeBlocks[i];
+            const translatedBlock = translatedCodeBlocks[i];
+            if (sourceBlock.code !== translatedBlock.code) {
+                foundIssues.push({
+                    type: "code-block-modified",
+                    severity: "critical", // Added severity
+                    message: `Code block ${i + 1} was modified`,
+                });
+                // Restore original code
+                fixedText = fixedText.replace(translatedBlock.full, sourceBlock.full);
+                appliedFixes.push({
+                    type: "code-block-restore",
+                    message: `Restored original code block ${i + 1}`,
+                });
+            }
+        }
+        return { text: fixedText, foundIssues, appliedFixes };
+    }
+    /**
+     * Restore missing code blocks from source.
+     */
+    restoreCodeBlocks(sourceText, translatedText, sourceCodeBlocks) {
+        const appliedFixes = [];
+        const fixedText = translatedText;
+        // This is a simplified restoration - in reality, we'd need more context
+        // to know exactly where to place the code blocks
+        // For now, if code blocks are completely missing, append them at the end
+        const translatedCodeBlocks = this.extractCodeBlocks(translatedText);
+        if (sourceCodeBlocks.length > translatedCodeBlocks.length) {
+            const missingCount = sourceCodeBlocks.length - translatedCodeBlocks.length;
+            appliedFixes.push({
+                type: "code-block-restore",
+                message: `Attempted to restore ${missingCount} missing code blocks`,
+            });
+            // Note: Full restoration would require AI to determine proper placement
+        }
+        return { text: fixedText, appliedFixes };
+    }
+    /**
+     * Protect code blocks before translation.
+     * Replaces code blocks with tokens to prevent translation.
+     */
+    protectCodeBlocks(text) {
+        const codeBlocks = this.extractCodeBlocks(text);
+        const tokenMap = new Map();
+        let protectedText = text;
+        codeBlocks.forEach((block, index) => {
+            const token = `__CODE_BLOCK_${index}__`;
+            tokenMap.set(token, block.full);
+            protectedText = protectedText.replace(block.full, token);
+        });
+        return { protectedText, tokenMap };
+    }
+    /**
+     * Restore code blocks after translation.
+     */
+    restoreCodeBlocksFromTokens(text, tokenMap) {
+        let restoredText = text;
+        for (const [token, codeBlock] of tokenMap.entries()) {
+            restoredText = restoredText.replace(token, codeBlock);
+        }
+        return restoredText;
+    }
+    /**
+     * Check if text contains code blocks.
+     */
+    hasCodeBlocks(text) {
+        for (const pattern of Object.values(this.codePatterns)) {
+            if (pattern.test(text)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+export default CodeBlockChecker;

package/dist/utils/quality/html-tag-checker.js

@@ -0,0 +1,64 @@
+/**
+ * HTML Tag Consistency Checker.
+ * Ensures HTML tags are preserved and correctly nested in translations.
+ */
+class HtmlTagChecker {
+    /**
+     * Check for HTML tag mismatches between source and translation.
+     */
+    checkHtmlTags(source, translated) {
+        const tagRegex = /<[^>]+>/g;
+        const sourceTags = source.match(tagRegex) || [];
+        const translatedTags = translated.match(tagRegex) || [];
+        if (sourceTags.length !== translatedTags.length) {
+            return [
+                {
+                    type: "htmlTag",
+                    message: "HTML tag count mismatch",
+                    source: sourceTags,
+                    translated: translatedTags,
+                },
+            ];
+        }
+        return [];
+    }
+    /**
+     * Fix missing HTML tags in translated text.
+     */
+    fixHtmlTags(source, translated) {
+        const tagRegex = /<[^>]+>/g;
+        const sourceTags = source.match(tagRegex) || [];
+        let fixedText = translated;
+        const foundIssues = [];
+        const appliedFixes = [];
+        sourceTags.forEach((tag) => {
+            if (!fixedText.includes(tag)) {
+                foundIssues.push({
+                    type: "htmlTag",
+                    message: `Missing HTML tag: ${tag}`,
+                });
+                fixedText = this.insertHtmlTag(fixedText, tag);
+                appliedFixes.push({
+                    type: "htmlTag",
+                    message: `Added HTML tag: ${tag}`,
+                });
+            }
+        });
+        return { text: fixedText, foundIssues, appliedFixes };
+    }
+    /**
+     * Insert HTML tag into text.
+     */
+    insertHtmlTag(text, tag) {
+        const isClosingTag = tag.startsWith("</");
+        if (isClosingTag) {
+            const openingTag = tag.replace("/", "");
+            const position = text.indexOf(openingTag) + openingTag.length;
+            if (position >= openingTag.length) {
+                return text.slice(0, position) + tag + text.slice(position);
+            }
+        }
+        return tag + text;
+    }
+}
+export default HtmlTagChecker;

package/dist/utils/quality/index.js

@@ -0,0 +1,220 @@
+import BaseChecker from "./base-checker.js";
+import PlaceholderChecker from "./placeholder-checker.js";
+import HtmlTagChecker from "./html-tag-checker.js";
+import PunctuationChecker from "./punctuation-checker.js";
+import LengthChecker from "./length-checker.js";
+import TextSanitizer from "./text-sanitizer.js";
+import QuoteBalanceChecker from "./quote-balance-checker.js";
+import StyleGuideChecker from "./style-guide-checker.js";
+import MarkdownChecker from "./markdown-checker.js";
+import CodeBlockChecker from "./code-block-checker.js";
+import SpecialCharactersChecker from "./special-characters-checker.js";
+/**
+ * Main Quality Checker Class.
+ * Orchestrates various quality checks and fixes for translated text.
+ */
+class QualityChecker extends BaseChecker {
+    placeholderChecker;
+    htmlTagChecker;
+    punctuationChecker;
+    lengthChecker;
+    textSanitizer;
+    quoteBalanceChecker;
+    styleGuideChecker;
+    markdownChecker;
+    codeBlockChecker;
+    specialCharactersChecker;
+    context;
+    /**
+     * Initialize QualityChecker with options.
+     */
+    constructor(options = {}) {
+        super(options);
+        this.initializeCheckers();
+        this.context = options.context || {};
+    }
+    /**
+     * Initialize all individual checkers.
+     */
+    initializeCheckers() {
+        this.placeholderChecker = new PlaceholderChecker();
+        this.htmlTagChecker = new HtmlTagChecker();
+        this.punctuationChecker = new PunctuationChecker();
+        this.lengthChecker = new LengthChecker();
+        this.textSanitizer = new TextSanitizer();
+        this.quoteBalanceChecker = new QuoteBalanceChecker();
+        this.styleGuideChecker = new StyleGuideChecker(this.styleGuide);
+        this.markdownChecker = new MarkdownChecker();
+        this.codeBlockChecker = new CodeBlockChecker();
+        this.specialCharactersChecker = new SpecialCharactersChecker();
+    }
+    /**
+     * Validate translated text against source text.
+     */
+    validate(sourceText, translatedText, options = {}) {
+        const issues = [];
+        if (this.rules.placeholderConsistency) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...this.placeholderChecker.checkPlaceholders(sourceText, translatedText));
+        }
+        if (this.rules.htmlTagsConsistency) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...this.htmlTagChecker.checkHtmlTags(sourceText, translatedText));
+        }
+        if (this.rules.punctuationCheck) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...this.punctuationChecker.checkPunctuation(sourceText, translatedText));
+        }
+        // Quote balance validation
+        if (this.rules.quoteBalanceCheck !== false) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...this.quoteBalanceChecker.checkQuoteBalance(translatedText));
+            issues.push(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ...this.quoteBalanceChecker.validateQuoteConsistency(sourceText, translatedText));
+        }
+        if (this.rules.lengthValidation) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...this.lengthChecker.checkLength(sourceText, translatedText, options));
+        }
+        // Style guide validation
+        if (this.styleGuide && this.styleGuideChecker) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...this.styleGuideChecker.checkStyleGuide(sourceText, translatedText));
+        }
+        // Markdown preservation
+        if (this.rules.markdownPreservation) {
+            issues.push(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ...this.markdownChecker.checkMarkdownPreservation(sourceText, translatedText));
+        }
+        // Code block preservation
+        if (this.rules.codeBlockPreservation) {
+            issues.push(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ...this.codeBlockChecker.checkCodeBlockPreservation(sourceText, translatedText));
+        }
+        // Special characters preservation
+        if (this.rules.specialCharacters) {
+            issues.push(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ...this.specialCharactersChecker.checkSpecialCharacters(sourceText, translatedText));
+        }
+        if (this.rules.sanitizeOutput) {
+            translatedText = this.sanitizeTranslation(translatedText);
+        }
+        return {
+            isValid: issues.length === 0,
+            issues,
+            source: sourceText,
+            translated: translatedText,
+            context: this.context,
+        };
+    }
+    /**
+     * Validate and attempt to fix translated text.
+     */
+    validateAndFix(sourceText, translatedText) {
+        let fixedText = translatedText;
+        const issues = [];
+        const fixes = [];
+        if (this.rules.sanitizeOutput) {
+            fixedText = this.sanitizeTranslation(fixedText);
+        }
+        if (this.rules.placeholderConsistency) {
+            const result = this.placeholderChecker.fixPlaceholders(sourceText, fixedText);
+            fixedText = result.text;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...result.foundIssues);
+            fixes.push(...result.appliedFixes);
+        }
+        if (this.rules.htmlTagsConsistency) {
+            const result = this.htmlTagChecker.fixHtmlTags(sourceText, fixedText);
+            fixedText = result.text;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...result.foundIssues);
+            fixes.push(...result.appliedFixes);
+        }
+        if (this.rules.punctuationCheck) {
+            const result = this.punctuationChecker.fixPunctuation(sourceText, fixedText);
+            fixedText = result.text;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...result.foundIssues);
+            fixes.push(...result.appliedFixes);
+        }
+        // Quote balance auto-fix
+        if (this.rules.quoteBalanceCheck !== false) {
+            const result = this.quoteBalanceChecker.fixQuoteBalance(fixedText);
+            fixedText = result.text;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...result.foundIssues);
+            fixes.push(...result.appliedFixes);
+        }
+        // Style guide fixes
+        if (this.styleGuide && this.styleGuideChecker) {
+            const result = this.styleGuideChecker.fixStyleGuide(sourceText, fixedText);
+            fixedText = result.text;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...result.foundIssues);
+            fixes.push(...result.appliedFixes);
+        }
+        // Markdown preservation fixes
+        if (this.rules.markdownPreservation) {
+            const result = this.markdownChecker.fixMarkdownPreservation(sourceText, fixedText);
+            fixedText = result.text;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...result.foundIssues);
+            fixes.push(...result.appliedFixes);
+        }
+        // Code block preservation fixes
+        if (this.rules.codeBlockPreservation) {
+            const result = this.codeBlockChecker.fixCodeBlockPreservation(sourceText, fixedText);
+            fixedText = result.text;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...result.foundIssues);
+            fixes.push(...result.appliedFixes);
+        }
+        // Special characters fixes
+        if (this.rules.specialCharacters) {
+            const result = this.specialCharactersChecker.fixSpecialCharacters(sourceText, fixedText);
+            fixedText = result.text;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            issues.push(...result.foundIssues);
+            fixes.push(...result.appliedFixes);
+        }
+        return {
+            originalText: translatedText,
+            fixedText,
+            isModified: translatedText !== fixedText,
+            issues,
+            fixes,
+            metadata: {
+                sourceLength: sourceText.length,
+                originalLength: translatedText.length,
+                fixedLength: fixedText.length,
+                timestamp: new Date().toISOString(),
+            },
+        };
+    }
+    /**
+     * Sanitize translated text using multiple passes.
+     */
+    sanitizeTranslation(text) {
+        if (!text)
+            return text;
+        // First pass sanitization
+        let sanitized = this.textSanitizer.sanitize(text);
+        // Remove any remaining think tags
+        if (sanitized.includes("<think>")) {
+            sanitized = this.textSanitizer.removeThinkTags(sanitized);
+        }
+        // Final cleanup of duplicate lines
+        sanitized = sanitized
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line, index, arr) => line !== arr[index - 1])
+            .join("\n");
+        return sanitized;
+    }
+}
+export default QualityChecker;