@hagicode/hagi18n 0.1.0-dev.1.1.45d0d2f

package/dist/locale-toolkit.js

@@ -0,0 +1,679 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import { DEFAULT_BASE_LOCALE, resolveHagi18nConfig } from "./config.js";
+const PLACEHOLDER_PATTERN = /{{\s*[^}]+\s*}}/g;
+const PROTECTED_TOKEN_PATTERN = /[\uE000\uE001]/u;
+const LOCALE_ALIAS_MAP = new Map([
+    ["zh", "zh-CN"],
+    ["zh-cn", "zh-CN"],
+    ["en", "en-US"],
+    ["en-us", "en-US"]
+]);
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneValue(value) {
+    return structuredClone(value);
+}
+function compareValues(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+export function normalizeLocaleName(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return LOCALE_ALIAS_MAP.get(trimmed.toLowerCase()) ?? trimmed;
+}
+function resolveExistingLocale(locales, requestedLocale) {
+    const normalizedRequestedLocale = normalizeLocaleName(requestedLocale);
+    if (!normalizedRequestedLocale) {
+        return null;
+    }
+    const exactMatch = locales.find((locale) => locale === normalizedRequestedLocale);
+    if (exactMatch) {
+        return exactMatch;
+    }
+    return (locales.find((locale) => locale.toLowerCase() === normalizedRequestedLocale.toLowerCase()) ?? null);
+}
+function resolveTargetLocales(locales, baseLocale, targetLocales, includeBaseLocale = false) {
+    if (!targetLocales || targetLocales.length === 0) {
+        return includeBaseLocale
+            ? [...locales]
+            : locales.filter((locale) => locale !== baseLocale);
+    }
+    const resolvedTargets = [];
+    for (const targetLocale of targetLocales) {
+        const resolvedLocale = resolveExistingLocale(locales, targetLocale);
+        if (!resolvedLocale) {
+            throw new Error(`Target locale '${targetLocale}' was not found. Available locales: ${locales.join(", ")}`);
+        }
+        if (!includeBaseLocale && resolvedLocale === baseLocale) {
+            continue;
+        }
+        if (!resolvedTargets.includes(resolvedLocale)) {
+            resolvedTargets.push(resolvedLocale);
+        }
+    }
+    return resolvedTargets;
+}
+function isDoctorRuleAllowed(allowlist, ruleId, relativePath) {
+    return allowlist[ruleId]?.includes(relativePath) ?? false;
+}
+export async function listLocaleDirectories(localesRoot) {
+    const entries = await fs.readdir(localesRoot, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+}
+export async function walkYamlFiles(directory, prefix = "") {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const relativePath = prefix ? path.posix.join(prefix, entry.name) : entry.name;
+        const absolutePath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await walkYamlFiles(absolutePath, relativePath)));
+            continue;
+        }
+        if (entry.isFile() && (entry.name.endsWith(".yml") || entry.name.endsWith(".yaml"))) {
+            files.push(relativePath);
+        }
+    }
+    return files;
+}
+export async function readYamlLocaleFile(localesRoot, locale, relativeFilePath) {
+    const absolutePath = path.join(localesRoot, locale, relativeFilePath);
+    const raw = await fs.readFile(absolutePath, "utf8");
+    const parsed = yaml.load(raw);
+    if (parsed === undefined) {
+        return {
+            absolutePath,
+            raw,
+            data: {}
+        };
+    }
+    if (!isPlainObject(parsed)) {
+        throw new Error(`Top-level YAML document must be a mapping object: ${relativeFilePath}`);
+    }
+    return {
+        absolutePath,
+        raw,
+        data: parsed
+    };
+}
+export function collectScalarPaths(value, prefix = [], output = []) {
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => collectScalarPaths(item, [...prefix, String(index)], output));
+        return output;
+    }
+    if (isPlainObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+            collectScalarPaths(child, [...prefix, key], output);
+        }
+        return output;
+    }
+    output.push(prefix.join("."));
+    return output;
+}
+export function collectPlaceholders(value, prefix = [], output = new Map()) {
+    if (typeof value === "string") {
+        const key = prefix.join(".");
+        const matches = [...value.matchAll(PLACEHOLDER_PATTERN)]
+            .map((match) => match[0])
+            .sort((left, right) => left.localeCompare(right));
+        output.set(key, matches);
+        return output;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => collectPlaceholders(item, [...prefix, String(index)], output));
+        return output;
+    }
+    if (isPlainObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+            collectPlaceholders(child, [...prefix, key], output);
+        }
+    }
+    return output;
+}
+export function difference(source, other) {
+    const otherSet = new Set(other);
+    return source.filter((item) => !otherSet.has(item));
+}
+export function collectPlaceholderDifferences(basePlaceholders, currentPlaceholders) {
+    const differences = [];
+    for (const [pathKey, expectedPlaceholders] of basePlaceholders.entries()) {
+        const actualPlaceholders = currentPlaceholders.get(pathKey) ?? [];
+        if (expectedPlaceholders.length !== actualPlaceholders.length) {
+            differences.push({
+                path: pathKey,
+                expected: expectedPlaceholders,
+                actual: actualPlaceholders
+            });
+            continue;
+        }
+        const isSame = expectedPlaceholders.every((placeholder, index) => placeholder === actualPlaceholders[index]);
+        if (!isSame) {
+            differences.push({
+                path: pathKey,
+                expected: expectedPlaceholders,
+                actual: actualPlaceholders
+            });
+        }
+    }
+    return differences;
+}
+export function createAuditResult(locale) {
+    return {
+        locale,
+        missingFiles: [],
+        extraFiles: [],
+        filesWithProtectedTokens: [],
+        parseErrors: [],
+        missingKeys: [],
+        extraKeys: [],
+        placeholderMismatches: []
+    };
+}
+export function auditHasIssues(result) {
+    return (result.missingFiles.length > 0 ||
+        result.extraFiles.length > 0 ||
+        result.filesWithProtectedTokens.length > 0 ||
+        result.parseErrors.length > 0 ||
+        result.missingKeys.length > 0 ||
+        result.extraKeys.length > 0 ||
+        result.placeholderMismatches.length > 0);
+}
+async function resolveAuditInputs(options) {
+    const resolvedConfig = await resolveHagi18nConfig(options);
+    const locales = await listLocaleDirectories(resolvedConfig.localesRoot);
+    if (locales.length === 0) {
+        throw new Error(`No locale directories found under ${resolvedConfig.localesRoot}`);
+    }
+    const resolvedBaseLocale = resolveExistingLocale(locales, options.baseLocale ?? resolvedConfig.baseLocale ?? DEFAULT_BASE_LOCALE);
+    if (!resolvedBaseLocale) {
+        throw new Error(`Base locale '${options.baseLocale ?? resolvedConfig.baseLocale}' was not found. Available locales: ${locales.join(", ")}`);
+    }
+    const selectedLocales = resolveTargetLocales(locales, resolvedBaseLocale, options.targetLocales ?? resolvedConfig.targetLocales, true);
+    return {
+        config: resolvedConfig,
+        locales,
+        resolvedBaseLocale,
+        selectedLocales
+    };
+}
+export async function auditLocaleTree(options = {}) {
+    const { config, locales, resolvedBaseLocale, selectedLocales } = await resolveAuditInputs(options);
+    const baseFiles = await walkYamlFiles(path.join(config.localesRoot, resolvedBaseLocale));
+    const results = [];
+    for (const locale of selectedLocales) {
+        const result = createAuditResult(locale);
+        const localeDirectory = path.join(config.localesRoot, locale);
+        const localeFiles = await walkYamlFiles(localeDirectory);
+        result.missingFiles = difference(baseFiles, localeFiles);
+        result.extraFiles = difference(localeFiles, baseFiles);
+        const comparableFiles = baseFiles.filter((file) => localeFiles.includes(file));
+        for (const relativeFilePath of comparableFiles) {
+            try {
+                const baseDocument = await readYamlLocaleFile(config.localesRoot, resolvedBaseLocale, relativeFilePath);
+                const currentDocument = await readYamlLocaleFile(config.localesRoot, locale, relativeFilePath);
+                if (PROTECTED_TOKEN_PATTERN.test(currentDocument.raw)) {
+                    result.filesWithProtectedTokens.push(relativeFilePath);
+                }
+                const baseScalarPaths = collectScalarPaths(baseDocument.data).sort((left, right) => left.localeCompare(right));
+                const currentScalarPaths = collectScalarPaths(currentDocument.data).sort((left, right) => left.localeCompare(right));
+                for (const missingPath of difference(baseScalarPaths, currentScalarPaths)) {
+                    result.missingKeys.push({ file: relativeFilePath, path: missingPath });
+                }
+                for (const extraPath of difference(currentScalarPaths, baseScalarPaths)) {
+                    result.extraKeys.push({ file: relativeFilePath, path: extraPath });
+                }
+                const placeholderDifferences = collectPlaceholderDifferences(collectPlaceholders(baseDocument.data), collectPlaceholders(currentDocument.data));
+                for (const differenceItem of placeholderDifferences) {
+                    result.placeholderMismatches.push({
+                        file: relativeFilePath,
+                        ...differenceItem
+                    });
+                }
+            }
+            catch (error) {
+                result.parseErrors.push({
+                    file: relativeFilePath,
+                    message: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        results.push(result);
+    }
+    return {
+        localesRoot: config.localesRoot,
+        baseLocale: resolvedBaseLocale,
+        locales: selectedLocales,
+        allLocales: locales,
+        baseFileCount: baseFiles.length,
+        results,
+        hasIssues: results.some(auditHasIssues)
+    };
+}
+function syncNode(baseValue, targetValue, pathSegments = [], addedPaths = []) {
+    if (Array.isArray(baseValue)) {
+        if (!Array.isArray(targetValue)) {
+            addedPaths.push(pathSegments.join("."));
+            return cloneValue(baseValue);
+        }
+        const result = [];
+        for (let index = 0; index < baseValue.length; index += 1) {
+            const childPath = [...pathSegments, String(index)];
+            if (index < targetValue.length) {
+                result[index] = syncNode(baseValue[index], targetValue[index], childPath, addedPaths);
+            }
+            else {
+                addedPaths.push(childPath.join("."));
+                result[index] = cloneValue(baseValue[index]);
+            }
+        }
+        for (let index = baseValue.length; index < targetValue.length; index += 1) {
+            result[index] = cloneValue(targetValue[index]);
+        }
+        return result;
+    }
+    if (isPlainObject(baseValue)) {
+        if (!isPlainObject(targetValue)) {
+            addedPaths.push(pathSegments.join("."));
+            return cloneValue(baseValue);
+        }
+        const result = {};
+        for (const [key, childBaseValue] of Object.entries(baseValue)) {
+            const childPath = [...pathSegments, key];
+            if (Object.hasOwn(targetValue, key)) {
+                result[key] = syncNode(childBaseValue, targetValue[key], childPath, addedPaths);
+            }
+            else {
+                addedPaths.push(childPath.join("."));
+                result[key] = cloneValue(childBaseValue);
+            }
+        }
+        for (const [key, childTargetValue] of Object.entries(targetValue)) {
+            if (!Object.hasOwn(baseValue, key)) {
+                result[key] = cloneValue(childTargetValue);
+            }
+        }
+        return result;
+    }
+    return targetValue === undefined ? cloneValue(baseValue) : cloneValue(targetValue);
+}
+function pruneNode(baseValue, targetValue, pathSegments = [], removedPaths = []) {
+    if (Array.isArray(baseValue)) {
+        if (!Array.isArray(targetValue)) {
+            return cloneValue(targetValue);
+        }
+        const result = [];
+        const sharedLength = Math.min(baseValue.length, targetValue.length);
+        for (let index = 0; index < sharedLength; index += 1) {
+            result[index] = pruneNode(baseValue[index], targetValue[index], [...pathSegments, String(index)], removedPaths);
+        }
+        for (let index = sharedLength; index < targetValue.length; index += 1) {
+            removedPaths.push([...pathSegments, String(index)].join("."));
+        }
+        return result;
+    }
+    if (isPlainObject(baseValue)) {
+        if (!isPlainObject(targetValue)) {
+            return cloneValue(targetValue);
+        }
+        const result = {};
+        for (const [key, childTargetValue] of Object.entries(targetValue)) {
+            const childPath = [...pathSegments, key];
+            if (Object.hasOwn(baseValue, key)) {
+                result[key] = pruneNode(baseValue[key], childTargetValue, childPath, removedPaths);
+            }
+            else {
+                removedPaths.push(childPath.join("."));
+            }
+        }
+        return result;
+    }
+    return cloneValue(targetValue);
+}
+function dumpYamlDocument(value) {
+    return `${yaml.dump(value, {
+        lineWidth: -1,
+        noRefs: true,
+        sortKeys: false
+    })}`;
+}
+async function writeYamlLocaleFile(absolutePath, value) {
+    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+    await fs.writeFile(absolutePath, dumpYamlDocument(value), "utf8");
+}
+function createMutationSummary(command, localesRoot, baseLocale, targetLocales, dryRun) {
+    return {
+        command,
+        localesRoot,
+        baseLocale,
+        targetLocales,
+        dryRun,
+        changedFiles: [],
+        removedFiles: [],
+        parseErrors: [],
+        totals: {
+            createdFiles: 0,
+            updatedFiles: 0,
+            removedFiles: 0,
+            addedPaths: 0,
+            removedPaths: 0
+        },
+        hasIssues: false
+    };
+}
+async function resolveMutationInputs(options, command) {
+    const config = await resolveHagi18nConfig(options);
+    const locales = await listLocaleDirectories(config.localesRoot);
+    const resolvedBaseLocale = resolveExistingLocale(locales, options.baseLocale ?? config.baseLocale);
+    if (!resolvedBaseLocale) {
+        throw new Error(`Base locale '${options.baseLocale ?? config.baseLocale}' was not found. Available locales: ${locales.join(", ")}`);
+    }
+    const resolvedTargets = resolveTargetLocales(locales, resolvedBaseLocale, options.targetLocales ?? config.targetLocales);
+    return {
+        config,
+        resolvedBaseLocale,
+        resolvedTargets,
+        summary: createMutationSummary(command, config.localesRoot, resolvedBaseLocale, resolvedTargets, options.dryRun ?? true)
+    };
+}
+export async function syncLocaleTree(options = {}) {
+    const { config, resolvedBaseLocale, resolvedTargets, summary } = await resolveMutationInputs(options, "sync");
+    const baseFiles = await walkYamlFiles(path.join(config.localesRoot, resolvedBaseLocale));
+    for (const locale of resolvedTargets) {
+        for (const relativeFilePath of baseFiles) {
+            const absoluteTargetPath = path.join(config.localesRoot, locale, relativeFilePath);
+            try {
+                const baseDocument = await readYamlLocaleFile(config.localesRoot, resolvedBaseLocale, relativeFilePath);
+                let targetDocument = null;
+                try {
+                    targetDocument = await readYamlLocaleFile(config.localesRoot, locale, relativeFilePath);
+                }
+                catch (error) {
+                    if ((error &&
+                        typeof error === "object" &&
+                        "code" in error &&
+                        error.code === "ENOENT") ||
+                        String(error).includes("ENOENT")) {
+                        targetDocument = null;
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                if (!targetDocument) {
+                    summary.changedFiles.push({
+                        locale,
+                        file: relativeFilePath,
+                        action: "create",
+                        addedPaths: ["<entire-file>"]
+                    });
+                    summary.totals.createdFiles += 1;
+                    summary.totals.addedPaths += 1;
+                    if (!summary.dryRun) {
+                        await writeYamlLocaleFile(absoluteTargetPath, baseDocument.data);
+                    }
+                    continue;
+                }
+                const addedPaths = [];
+                const merged = syncNode(baseDocument.data, targetDocument.data, [], addedPaths);
+                if (addedPaths.length === 0 || compareValues(merged, targetDocument.data)) {
+                    continue;
+                }
+                summary.changedFiles.push({
+                    locale,
+                    file: relativeFilePath,
+                    action: "update",
+                    addedPaths
+                });
+                summary.totals.updatedFiles += 1;
+                summary.totals.addedPaths += addedPaths.length;
+                if (!summary.dryRun) {
+                    await writeYamlLocaleFile(absoluteTargetPath, merged);
+                }
+            }
+            catch (error) {
+                summary.parseErrors.push({
+                    locale,
+                    file: relativeFilePath,
+                    message: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+    }
+    summary.hasIssues = summary.parseErrors.length > 0;
+    return summary;
+}
+export async function pruneLocaleTree(options = {}) {
+    const { config, resolvedBaseLocale, resolvedTargets, summary } = await resolveMutationInputs(options, "prune");
+    const baseFiles = await walkYamlFiles(path.join(config.localesRoot, resolvedBaseLocale));
+    for (const locale of resolvedTargets) {
+        const localeRoot = path.join(config.localesRoot, locale);
+        const localeFiles = await walkYamlFiles(localeRoot);
+        const extraFiles = difference(localeFiles, baseFiles);
+        for (const relativeFilePath of extraFiles) {
+            summary.removedFiles.push({
+                locale,
+                file: relativeFilePath,
+                action: "remove-file"
+            });
+            summary.totals.removedFiles += 1;
+            if (!summary.dryRun) {
+                await fs.rm(path.join(localeRoot, relativeFilePath), { force: true });
+            }
+        }
+        const comparableFiles = baseFiles.filter((file) => localeFiles.includes(file));
+        for (const relativeFilePath of comparableFiles) {
+            try {
+                const baseDocument = await readYamlLocaleFile(config.localesRoot, resolvedBaseLocale, relativeFilePath);
+                const targetDocument = await readYamlLocaleFile(config.localesRoot, locale, relativeFilePath);
+                const removedPaths = [];
+                const pruned = pruneNode(baseDocument.data, targetDocument.data, [], removedPaths);
+                if (removedPaths.length === 0 || compareValues(pruned, targetDocument.data)) {
+                    continue;
+                }
+                summary.changedFiles.push({
+                    locale,
+                    file: relativeFilePath,
+                    action: "update",
+                    removedPaths
+                });
+                summary.totals.updatedFiles += 1;
+                summary.totals.removedPaths += removedPaths.length;
+                if (!summary.dryRun) {
+                    await writeYamlLocaleFile(path.join(config.localesRoot, locale, relativeFilePath), pruned);
+                }
+            }
+            catch (error) {
+                summary.parseErrors.push({
+                    locale,
+                    file: relativeFilePath,
+                    message: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+    }
+    summary.hasIssues = summary.parseErrors.length > 0;
+    return summary;
+}
+async function walkRepositoryFiles(rootDirectory, excludedDirectories, textExtensions, excludedPathPrefixes, prefix = "") {
+    const entries = await fs.readdir(rootDirectory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const relativePath = prefix ? path.posix.join(prefix, entry.name) : entry.name;
+        const absolutePath = path.join(rootDirectory, entry.name);
+        if (entry.isDirectory()) {
+            if (excludedDirectories.has(entry.name)) {
+                continue;
+            }
+            files.push(...(await walkRepositoryFiles(absolutePath, excludedDirectories, textExtensions, excludedPathPrefixes, relativePath)));
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        if (excludedPathPrefixes.some((pathPrefix) => relativePath.startsWith(pathPrefix))) {
+            continue;
+        }
+        if (textExtensions.has(path.extname(entry.name))) {
+            files.push(relativePath);
+        }
+    }
+    return files;
+}
+async function scanRepositoryForLegacyLocaleReferences(repoRoot, scanRules, allowlist, excludedDirectories, textFileExtensions, excludedPathPrefixes) {
+    const files = await walkRepositoryFiles(repoRoot, new Set(excludedDirectories), new Set(textFileExtensions), excludedPathPrefixes);
+    const issues = [];
+    for (const relativePath of files) {
+        const absolutePath = path.join(repoRoot, relativePath);
+        const sourceText = await fs.readFile(absolutePath, "utf8");
+        const lines = sourceText.split(/\r?\n/u);
+        lines.forEach((line, index) => {
+            for (const rule of scanRules) {
+                rule.regex.lastIndex = 0;
+                if (!rule.regex.test(line) || isDoctorRuleAllowed(allowlist, rule.id, relativePath)) {
+                    continue;
+                }
+                issues.push({
+                    ruleId: rule.id,
+                    file: relativePath,
+                    line: index + 1,
+                    message: rule.message,
+                    snippet: line.trim()
+                });
+            }
+        });
+    }
+    return issues;
+}
+export async function doctorLocaleTree(options = {}) {
+    const config = await resolveHagi18nConfig(options);
+    const audit = await auditLocaleTree(options);
+    const legacyReferenceIssues = await scanRepositoryForLegacyLocaleReferences(config.repoRoot, config.doctor.scanRules, config.doctor.allowlist, config.doctor.excludedDirectories, config.doctor.textFileExtensions, config.doctor.excludedPathPrefixes);
+    const affectedFiles = [...new Set(legacyReferenceIssues.map((issue) => issue.file))].sort((left, right) => left.localeCompare(right));
+    return {
+        repoRoot: config.repoRoot,
+        localesRoot: config.localesRoot,
+        baseLocale: audit.baseLocale,
+        locales: audit.locales,
+        audit,
+        legacyReferenceIssues,
+        totals: {
+            legacyReferenceIssues: legacyReferenceIssues.length,
+            affectedFiles: affectedFiles.length
+        },
+        hasIssues: audit.hasIssues || legacyReferenceIssues.length > 0
+    };
+}
+function formatListSection(title, items, formatter = (item) => String(item)) {
+    if (items.length === 0) {
+        return [];
+    }
+    return [
+        `  ${title}: ${items.length}`,
+        ...items.slice(0, 20).map((item) => `    - ${formatter(item)}`),
+        ...(items.length > 20 ? [`    - ...and ${items.length - 20} more`] : [])
+    ];
+}
+export function formatAuditSummary(summary) {
+    const lines = [
+        `Base locale: ${summary.baseLocale}`,
+        `Locales: ${summary.locales.join(", ")}`,
+        `Files audited from base locale: ${summary.baseFileCount}`,
+        ""
+    ];
+    for (const result of summary.results) {
+        lines.push(`${result.locale}: ${auditHasIssues(result) ? "issues found" : "ok"}`);
+        const sections = [
+            ...formatListSection("Missing files", result.missingFiles),
+            ...formatListSection("Extra files", result.extraFiles),
+            ...formatListSection("Protected token files", result.filesWithProtectedTokens),
+            ...formatListSection("Parse errors", result.parseErrors, (item) => `${item.file}: ${item.message}`),
+            ...formatListSection("Missing keys", result.missingKeys, (item) => `${item.file} -> ${item.path}`),
+            ...formatListSection("Extra keys", result.extraKeys, (item) => `${item.file} -> ${item.path}`),
+            ...formatListSection("Placeholder mismatches", result.placeholderMismatches, (item) => `${item.file} -> ${item.path} | expected ${JSON.stringify(item.expected)} | actual ${JSON.stringify(item.actual)}`)
+        ];
+        if (sections.length === 0) {
+            lines.push("  No issues.");
+        }
+        else {
+            lines.push(...sections);
+        }
+        lines.push("");
+    }
+    const localesWithIssues = summary.results
+        .filter(auditHasIssues)
+        .map((result) => result.locale);
+    if (localesWithIssues.length === 0) {
+        lines.push("Locale audit passed.");
+    }
+    else {
+        lines.push(`Locale audit failed for: ${localesWithIssues.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+export function formatMutationSummary(summary) {
+    const lines = [
+        `Command: ${summary.command}`,
+        `Base locale: ${summary.baseLocale}`,
+        `Target locales: ${summary.targetLocales.join(", ") || "(none)"}`,
+        `Mode: ${summary.dryRun ? "dry-run" : "write"}`,
+        ""
+    ];
+    if (summary.changedFiles.length === 0 &&
+        summary.removedFiles.length === 0 &&
+        summary.parseErrors.length === 0) {
+        lines.push("No changes.");
+    }
+    else {
+        lines.push(...formatListSection("Changed files", summary.changedFiles, (item) => {
+            if (item.action === "create") {
+                return `${item.locale}/${item.file} -> create`;
+            }
+            const details = item.addedPaths
+                ? `added ${item.addedPaths.length} path(s)`
+                : `removed ${item.removedPaths?.length ?? 0} path(s)`;
+            return `${item.locale}/${item.file} -> ${details}`;
+        }));
+        lines.push(...formatListSection("Removed files", summary.removedFiles, (item) => `${item.locale}/${item.file}`));
+        lines.push(...formatListSection("Parse errors", summary.parseErrors, (item) => `${item.locale}/${item.file}: ${item.message}`));
+    }
+    lines.push("");
+    lines.push(`Totals: createdFiles=${summary.totals.createdFiles}, updatedFiles=${summary.totals.updatedFiles}, removedFiles=${summary.totals.removedFiles}, addedPaths=${summary.totals.addedPaths}, removedPaths=${summary.totals.removedPaths}`);
+    return lines.join("\n");
+}
+export function formatDoctorSummary(summary) {
+    const lines = [
+        `Base locale: ${summary.baseLocale}`,
+        `Locales: ${summary.locales.join(", ")}`,
+        `Legacy reference issues: ${summary.totals.legacyReferenceIssues}`,
+        `Affected files: ${summary.totals.affectedFiles}`,
+        "",
+        formatAuditSummary(summary.audit)
+    ];
+    if (summary.legacyReferenceIssues.length === 0) {
+        lines.push("");
+        lines.push("Legacy locale reference scan passed.");
+        return lines.join("\n");
+    }
+    lines.push("");
+    lines.push("Legacy locale references:");
+    for (const issue of summary.legacyReferenceIssues.slice(0, 50)) {
+        lines.push(`  - ${issue.file}:${issue.line} [${issue.ruleId}] ${issue.message}`);
+        lines.push(`    ${issue.snippet}`);
+    }
+    if (summary.legacyReferenceIssues.length > 50) {
+        lines.push(`  - ...and ${summary.legacyReferenceIssues.length - 50} more`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=locale-toolkit.js.map