@mxml3gend/gloss 0.1.2 → 0.1.3

package/README.md

@@ -40,6 +40,7 @@ export default {
     exclude: ["**/*.test.tsx"],
     mode: "regex", // or "ast" for strict parsing
   },
+  strictPlaceholders: true, // default true; set false to treat placeholder mismatches as warnings
 };
 ```
 
@@ -54,6 +55,7 @@ module.exports = {
   scan: {
     mode: "ast",
   },
+  strictPlaceholders: false,
 };
 ```
 
@@ -63,8 +65,13 @@ module.exports = {
 gloss --help
 gloss --version
 gloss --no-open
+gloss --no-cache
 gloss --port 5179
 gloss open key auth.login.title
+gloss check --no-cache
+gloss cache status
+gloss cache clear
+npm run test:perf
 ```
 
 ## CI Guardrails
@@ -86,6 +93,21 @@ gloss check --format both
 
 The local UI also consumes this data through `/api/check` and shows a hardcoded-text status chip.
 
+## Performance Regression Gate
+
+Gloss ships with a deterministic 1000-key fixture regression test for scanner performance.
+
+```bash
+npm run test:perf
+```
+
+Optional environment overrides:
+
+```bash
+GLOSS_PERF_COLD_MAX_MS=5000
+GLOSS_PERF_WARM_MAX_MS=3500
+```
+
 ## Typed Key Generation
 
 Generate `i18n-keys.d.ts` from current translation keys:

package/dist/baseline.js

@@ -0,0 +1,118 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const BASELINE_DIRECTORY = ".gloss";
+const BASELINE_FILENAME = "baseline.json";
+const SUMMARY_KEYS = [
+    "missingTranslations",
+    "orphanKeys",
+    "invalidKeys",
+    "placeholderMismatches",
+    "hardcodedTexts",
+    "errorIssues",
+    "warningIssues",
+    "totalIssues",
+];
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const emptyDelta = () => ({
+    missingTranslations: 0,
+    orphanKeys: 0,
+    invalidKeys: 0,
+    placeholderMismatches: 0,
+    hardcodedTexts: 0,
+    errorIssues: 0,
+    warningIssues: 0,
+    totalIssues: 0,
+});
+const normalizeSummary = (value) => {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const source = value;
+    const next = {};
+    for (const key of SUMMARY_KEYS) {
+        const entry = source[key];
+        if (!isFiniteNumber(entry)) {
+            return null;
+        }
+        next[key] = entry;
+    }
+    return next;
+};
+const baselineFilePath = (rootDir) => path.join(rootDir, BASELINE_DIRECTORY, BASELINE_FILENAME);
+const readBaselineFile = async (rootDir) => {
+    const filePath = baselineFilePath(rootDir);
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== 1 || typeof parsed.updatedAt !== "string") {
+            return null;
+        }
+        const summary = normalizeSummary(parsed.summary);
+        if (!summary) {
+            return null;
+        }
+        return {
+            schemaVersion: 1,
+            updatedAt: parsed.updatedAt,
+            summary,
+        };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+};
+const computeDelta = (current, previous) => {
+    if (!previous) {
+        return emptyDelta();
+    }
+    const delta = {};
+    for (const key of SUMMARY_KEYS) {
+        delta[key] = current[key] - previous[key];
+    }
+    return delta;
+};
+export async function updateIssueBaseline(rootDir, summary) {
+    const previous = await readBaselineFile(rootDir);
+    const delta = computeDelta(summary, previous?.summary ?? null);
+    const currentUpdatedAt = new Date().toISOString();
+    const baseline = {
+        schemaVersion: 1,
+        updatedAt: currentUpdatedAt,
+        summary,
+    };
+    const filePath = baselineFilePath(rootDir);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(`${filePath}.tmp`, `${JSON.stringify(baseline, null, 2)}\n`, "utf8");
+    await fs.rename(`${filePath}.tmp`, filePath);
+    return {
+        hasPrevious: Boolean(previous),
+        baselinePath: path.relative(rootDir, filePath) || filePath,
+        previousUpdatedAt: previous?.updatedAt ?? null,
+        currentUpdatedAt,
+        delta,
+    };
+}
+export async function resetIssueBaseline(rootDir) {
+    const filePath = baselineFilePath(rootDir);
+    let existed = true;
+    try {
+        await fs.rm(filePath);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            existed = false;
+        }
+        else {
+            throw error;
+        }
+    }
+    return {
+        existed,
+        baselinePath: path.relative(rootDir, filePath) || filePath,
+    };
+}

package/dist/cache.js

@@ -0,0 +1,78 @@
+import { clearCacheMetrics, readCacheMetrics, } from "./cacheMetrics.js";
+import { clearKeyUsageCache, getKeyUsageCacheStatus, keyUsageCacheKey, } from "./usage.js";
+import { clearUsageScannerCache, getUsageScannerCacheStatus, inferUsageRoot, usageScannerCacheKey, } from "./usageScanner.js";
+const fromMetricsEntry = (cacheKey, entry, staleRelativeToConfig) => {
+    if (!entry) {
+        return {
+            cacheKey,
+            fileCount: 0,
+            totalSizeBytes: 0,
+            oldestMtimeMs: null,
+            staleRelativeToConfig,
+            source: "missing",
+        };
+    }
+    return {
+        cacheKey,
+        fileCount: entry.fileCount,
+        totalSizeBytes: entry.totalSizeBytes,
+        oldestMtimeMs: entry.oldestMtimeMs,
+        staleRelativeToConfig,
+        source: "metrics",
+    };
+};
+export const getCacheStatus = async (rootDir, cfg) => {
+    const usageKey = usageScannerCacheKey(inferUsageRoot(cfg), cfg.scan);
+    const keyUsageKey = keyUsageCacheKey(cfg);
+    const metrics = await readCacheMetrics(rootDir);
+    const metricsUsage = metrics?.usageScanner?.[usageKey] ?? null;
+    const metricsKeyUsage = metrics?.keyUsage?.[keyUsageKey] ?? null;
+    const usageStale = !metricsUsage;
+    const keyUsageStale = !metricsKeyUsage;
+    const usageBucket = metricsUsage
+        ? fromMetricsEntry(usageKey, metricsUsage, usageStale)
+        : (() => {
+            const memory = getUsageScannerCacheStatus(inferUsageRoot(cfg), cfg.scan);
+            return {
+                ...memory,
+                staleRelativeToConfig: memory.fileCount === 0,
+                source: "memory",
+            };
+        })();
+    const keyUsageBucket = metricsKeyUsage
+        ? fromMetricsEntry(keyUsageKey, metricsKeyUsage, keyUsageStale)
+        : (() => {
+            const memory = getKeyUsageCacheStatus(cfg);
+            return {
+                ...memory,
+                staleRelativeToConfig: memory.fileCount === 0,
+                source: "memory",
+            };
+        })();
+    const totalCachedFiles = usageBucket.fileCount + keyUsageBucket.fileCount;
+    const totalCachedSizeBytes = usageBucket.totalSizeBytes + keyUsageBucket.totalSizeBytes;
+    const oldestMtimeCandidates = [usageBucket.oldestMtimeMs, keyUsageBucket.oldestMtimeMs]
+        .filter((value) => typeof value === "number" && Number.isFinite(value));
+    const oldestMtimeMs = oldestMtimeCandidates.length > 0 ? Math.min(...oldestMtimeCandidates) : null;
+    const oldestEntryAgeMs = oldestMtimeMs === null ? null : Math.max(0, Date.now() - oldestMtimeMs);
+    return {
+        metricsFileFound: metrics !== null,
+        metricsUpdatedAt: metrics?.updatedAt ?? null,
+        usageScanner: usageBucket,
+        keyUsage: keyUsageBucket,
+        totalCachedFiles,
+        totalCachedSizeBytes,
+        oldestEntryAgeMs,
+        staleRelativeToConfig: usageBucket.staleRelativeToConfig || keyUsageBucket.staleRelativeToConfig,
+    };
+};
+export const clearGlossCaches = async (rootDir) => {
+    const usage = clearUsageScannerCache();
+    const keyUsage = clearKeyUsageCache();
+    const metrics = await clearCacheMetrics(rootDir);
+    return {
+        usage,
+        keyUsage,
+        metrics,
+    };
+};

package/dist/cacheMetrics.js

@@ -0,0 +1,120 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const CACHE_DIRECTORY = ".gloss";
+const CACHE_METRICS_FILENAME = "cache-metrics.json";
+const metricsFilePath = (rootDir) => path.join(rootDir, CACHE_DIRECTORY, CACHE_METRICS_FILENAME);
+const emptyMetrics = () => ({
+    schemaVersion: 1,
+    updatedAt: new Date().toISOString(),
+    usageScanner: {},
+    keyUsage: {},
+});
+const normalizeEntry = (value) => {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const source = value;
+    if (typeof source.cacheKey !== "string" || source.cacheKey.trim().length === 0) {
+        return null;
+    }
+    if (typeof source.fileCount !== "number" ||
+        !Number.isFinite(source.fileCount) ||
+        source.fileCount < 0) {
+        return null;
+    }
+    if (typeof source.totalSizeBytes !== "number" ||
+        !Number.isFinite(source.totalSizeBytes) ||
+        source.totalSizeBytes < 0) {
+        return null;
+    }
+    if (source.oldestMtimeMs !== null &&
+        (typeof source.oldestMtimeMs !== "number" || !Number.isFinite(source.oldestMtimeMs))) {
+        return null;
+    }
+    if (typeof source.updatedAt !== "string") {
+        return null;
+    }
+    return {
+        cacheKey: source.cacheKey,
+        fileCount: source.fileCount,
+        totalSizeBytes: source.totalSizeBytes,
+        oldestMtimeMs: source.oldestMtimeMs,
+        updatedAt: source.updatedAt,
+    };
+};
+const normalizeEntries = (value) => {
+    if (!value || typeof value !== "object") {
+        return {};
+    }
+    const source = value;
+    const entries = {};
+    for (const [key, rawEntry] of Object.entries(source)) {
+        const entry = normalizeEntry(rawEntry);
+        if (entry) {
+            entries[key] = entry;
+        }
+    }
+    return entries;
+};
+export const readCacheMetrics = async (rootDir) => {
+    const filePath = metricsFilePath(rootDir);
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== 1 || typeof parsed.updatedAt !== "string") {
+            return null;
+        }
+        return {
+            schemaVersion: 1,
+            updatedAt: parsed.updatedAt,
+            usageScanner: normalizeEntries(parsed.usageScanner),
+            keyUsage: normalizeEntries(parsed.keyUsage),
+        };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+};
+export const updateCacheMetrics = async (rootDir, kind, entry) => {
+    const existing = (await readCacheMetrics(rootDir)) ?? emptyMetrics();
+    const updatedAt = new Date().toISOString();
+    const next = {
+        ...existing,
+        updatedAt,
+        [kind]: {
+            ...existing[kind],
+            [entry.cacheKey]: {
+                ...entry,
+                updatedAt,
+            },
+        },
+    };
+    const filePath = metricsFilePath(rootDir);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(`${filePath}.tmp`, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    await fs.rename(`${filePath}.tmp`, filePath);
+};
+export const clearCacheMetrics = async (rootDir) => {
+    const filePath = metricsFilePath(rootDir);
+    let existed = true;
+    try {
+        await fs.rm(filePath);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            existed = false;
+        }
+        else {
+            throw error;
+        }
+    }
+    return {
+        existed,
+        path: path.relative(rootDir, filePath) || filePath,
+    };
+};

package/dist/check.js

@@ -24,7 +24,26 @@ const SIMPLE_PLACEHOLDER_REGEX = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 const ICU_PLACEHOLDER_REGEX = /\{([A-Za-z_][A-Za-z0-9_]*)\s*,\s*(plural|select|selectordinal)\s*,/g;
 const ICU_PLURAL_START_REGEX = /\{([A-Za-z_][A-Za-z0-9_]*)\s*,\s*plural\s*,/g;
 const ICU_CATEGORY_REGEX = /(?:^|[\s,])(=?\d+|zero|one|two|few|many|other)\s*\{/g;
+const HARDCODED_IGNORE_MARKER = "gloss-ignore";
+const CHECK_ALWAYS_FAIL_ON = ["missingTranslations", "invalidKeys"];
+const CHECK_ALWAYS_WARN_ON = ["orphanKeys", "hardcodedTexts"];
 const projectRoot = () => process.env.INIT_CWD || process.cwd();
+const getCheckPolicy = (cfg) => {
+    const strictPlaceholders = cfg.strictPlaceholders !== false;
+    const failOn = [...CHECK_ALWAYS_FAIL_ON];
+    const warnOn = [...CHECK_ALWAYS_WARN_ON];
+    if (strictPlaceholders) {
+        failOn.push("placeholderMismatches");
+    }
+    else {
+        warnOn.push("placeholderMismatches");
+    }
+    return {
+        strictPlaceholders,
+        failOn,
+        warnOn,
+    };
+};
 const normalizePath = (filePath) => filePath.split(path.sep).join("/");
 const withCollapsedWhitespace = (value) => value.replace(/\s+/g, " ").trim();
 const lineNumberAtIndex = (source, index) => {
@@ -39,9 +58,9 @@ const lineNumberAtIndex = (source, index) => {
 const hasIgnoredPathSegment = (relativePath) => normalizePath(relativePath)
     .split("/")
     .some((segment) => HARDCODED_IGNORED_DIRECTORIES.has(segment));
-const isLikelyHardcodedText = (value) => {
+const isLikelyHardcodedText = (value, minLength) => {
     const text = withCollapsedWhitespace(value);
-    if (text.length < 3) {
+    if (text.length < minLength) {
         return false;
     }
     if (!/[A-Za-z]/.test(text)) {
@@ -144,6 +163,33 @@ const scanHardcodedText = async (rootDir, cfg) => {
     const issues = [];
     const seen = new Set();
     const shouldScanFile = createScanMatcher(cfg.scan);
+    const hardcodedConfig = cfg.hardcodedText ?? {
+        enabled: true,
+        minLength: 3,
+        excludePatterns: [],
+    };
+    if (hardcodedConfig.enabled === false) {
+        return { issues, suppressedCount: 0 };
+    }
+    const minLength = typeof hardcodedConfig.minLength === "number" &&
+        Number.isFinite(hardcodedConfig.minLength) &&
+        hardcodedConfig.minLength >= 1
+        ? hardcodedConfig.minLength
+        : 3;
+    const excludeMatchers = (hardcodedConfig.excludePatterns ?? [])
+        .map((pattern) => pattern.trim())
+        .filter((pattern) => pattern.length > 0)
+        .map((pattern) => new RegExp(pattern));
+    let suppressedCount = 0;
+    const isSuppressed = (text, line, lines) => {
+        const currentLine = lines[line - 1] ?? "";
+        const previousLine = lines[line - 2] ?? "";
+        if (currentLine.includes(HARDCODED_IGNORE_MARKER) ||
+            previousLine.includes(HARDCODED_IGNORE_MARKER)) {
+            return true;
+        }
+        return excludeMatchers.some((matcher) => matcher.test(text));
+    };
     const visitDirectory = async (directory) => {
         const entries = await fs.readdir(directory, { withFileTypes: true });
         for (const entry of entries) {
@@ -164,11 +210,17 @@ const scanHardcodedText = async (rootDir, cfg) => {
                 continue;
             }
             const source = await fs.readFile(fullPath, "utf8");
+            const lines = source.split("\n");
             let textMatch = JSX_TEXT_REGEX.exec(source);
             while (textMatch) {
                 const text = withCollapsedWhitespace(textMatch[1]);
-                if (isLikelyHardcodedText(text)) {
+                if (isLikelyHardcodedText(text, minLength)) {
                     const line = lineNumberAtIndex(source, textMatch.index);
+                    if (isSuppressed(text, line, lines)) {
+                        suppressedCount += 1;
+                        textMatch = JSX_TEXT_REGEX.exec(source);
+                        continue;
+                    }
                     const dedupeKey = `${relativePath}:${line}:jsx_text:${text}`;
                     if (!seen.has(dedupeKey)) {
                         seen.add(dedupeKey);
@@ -181,8 +233,13 @@ const scanHardcodedText = async (rootDir, cfg) => {
             let attrMatch = JSX_ATTRIBUTE_REGEX.exec(source);
             while (attrMatch) {
                 const text = withCollapsedWhitespace(attrMatch[1]);
-                if (isLikelyHardcodedText(text)) {
+                if (isLikelyHardcodedText(text, minLength)) {
                     const line = lineNumberAtIndex(source, attrMatch.index);
+                    if (isSuppressed(text, line, lines)) {
+                        suppressedCount += 1;
+                        attrMatch = JSX_ATTRIBUTE_REGEX.exec(source);
+                        continue;
+                    }
                     const dedupeKey = `${relativePath}:${line}:jsx_attribute:${text}`;
                     if (!seen.has(dedupeKey)) {
                         seen.add(dedupeKey);
@@ -204,14 +261,16 @@ const scanHardcodedText = async (rootDir, cfg) => {
         }
         return left.text.localeCompare(right.text);
     });
-    return issues;
+    return { issues, suppressedCount };
 };
-export async function runGlossCheck(cfg) {
+export async function runGlossCheck(cfg, options) {
     const rootDir = projectRoot();
     const data = (await readAllTranslations(cfg));
     const flatByLocale = flattenByLocale(cfg, data);
     const usageRoot = inferUsageRoot(cfg);
-    const usage = await scanUsage(usageRoot, cfg.scan);
+    const usage = await scanUsage(usageRoot, cfg.scan, {
+        useCache: options?.useCache,
+    });
     const usageKeys = new Set(Object.keys(usage));
     const translationKeys = new Set(cfg.locales.flatMap((locale) => Object.keys(flatByLocale[locale] ?? {})));
     const allKeys = uniqueSorted([...translationKeys, ...usageKeys]);
@@ -240,6 +299,7 @@ export async function runGlossCheck(cfg) {
         });
         orphanKeys.push({ key, localesWithValue });
     }
+    orphanKeys.sort((left, right) => left.key.localeCompare(right.key));
     const invalidKeys = [];
     for (const key of translationKeys) {
         const reason = getInvalidTranslationKeyReason(key);
@@ -247,6 +307,7 @@ export async function runGlossCheck(cfg) {
             invalidKeys.push({ key, reason });
         }
     }
+    invalidKeys.sort((left, right) => left.key.localeCompare(right.key));
     const placeholderMismatches = [];
     for (const key of translationKeys) {
         const localesWithValue = cfg.locales.filter((locale) => {
@@ -292,6 +353,12 @@ export async function runGlossCheck(cfg) {
             }
         }
         if (mismatchedLocales.length > 0 || pluralMismatches.length > 0) {
+            pluralMismatches.sort((left, right) => {
+                if (left.locale !== right.locale) {
+                    return left.locale.localeCompare(right.locale);
+                }
+                return left.variable.localeCompare(right.variable);
+            });
             placeholderMismatches.push({
                 key,
                 referenceLocale,
@@ -302,24 +369,43 @@ export async function runGlossCheck(cfg) {
             });
         }
     }
-    const hardcodedTexts = await scanHardcodedText(usageRoot, cfg);
-    const summary = {
+    placeholderMismatches.sort((left, right) => left.key.localeCompare(right.key));
+    const hardcodedScan = await scanHardcodedText(usageRoot, cfg);
+    const hardcodedTexts = hardcodedScan.issues;
+    const policy = getCheckPolicy(cfg);
+    const categoryCounts = {
         missingTranslations: missingTranslations.length,
         orphanKeys: orphanKeys.length,
         invalidKeys: invalidKeys.length,
         placeholderMismatches: placeholderMismatches.length,
         hardcodedTexts: hardcodedTexts.length,
-        totalIssues: missingTranslations.length +
-            orphanKeys.length +
-            invalidKeys.length +
-            placeholderMismatches.length +
-            hardcodedTexts.length,
+        suppressedHardcodedTexts: hardcodedScan.suppressedCount,
+    };
+    const errorIssues = policy.failOn.reduce((total, category) => {
+        return total + categoryCounts[category];
+    }, 0);
+    const warningIssues = policy.warnOn.reduce((total, category) => {
+        return total + categoryCounts[category];
+    }, 0);
+    const totalIssues = errorIssues + warningIssues;
+    const summary = {
+        ...categoryCounts,
+        errorIssues,
+        warningIssues,
+        totalIssues,
     };
+    const ok = summary.errorIssues === 0;
     return {
-        ok: summary.totalIssues === 0,
+        schemaVersion: 1,
+        status: ok ? "pass" : "fail",
+        ok,
         generatedAt: new Date().toISOString(),
         rootDir: rootDir,
         locales: cfg.locales,
+        policy: {
+            failOn: [...policy.failOn],
+            warnOn: [...policy.warnOn],
+        },
         summary,
         missingTranslations,
         orphanKeys,
@@ -345,18 +431,34 @@ const printSample = (title, lines) => {
         console.log(`- ... +${lines.length - limit} more`);
     }
 };
-export const printGlossCheck = (result, format) => {
+export const printGlossCheck = (result, format, baseline) => {
+    const formatSigned = (value) => (value > 0 ? `+${value}` : `${value}`);
     if (format === "human" || format === "both") {
         console.log(`Gloss check for ${result.rootDir}`);
+        const placeholderSeverity = result.policy.failOn.includes("placeholderMismatches")
+            ? "error"
+            : "warning";
         printTable([
-            { label: "Missing translations", value: result.summary.missingTranslations },
-            { label: "Orphan keys", value: result.summary.orphanKeys },
-            { label: "Invalid keys", value: result.summary.invalidKeys },
             {
-                label: "Placeholder mismatches",
+                label: "Missing translations (error)",
+                value: result.summary.missingTranslations,
+            },
+            { label: "Orphan keys (warning)", value: result.summary.orphanKeys },
+            { label: "Invalid keys (error)", value: result.summary.invalidKeys },
+            {
+                label: `Placeholder mismatches (${placeholderSeverity})`,
                 value: result.summary.placeholderMismatches,
             },
-            { label: "Hardcoded text candidates", value: result.summary.hardcodedTexts },
+            {
+                label: "Hardcoded text candidates (warning)",
+                value: result.summary.hardcodedTexts,
+            },
+            {
+                label: "Hardcoded text suppressed",
+                value: result.summary.suppressedHardcodedTexts,
+            },
+            { label: "Error issues (fail CI)", value: result.summary.errorIssues },
+            { label: "Warning issues", value: result.summary.warningIssues },
             { label: "Total issues", value: result.summary.totalIssues },
         ]);
         printSample("Missing translations", result.missingTranslations.map((issue) => `${issue.key} -> missing in [${issue.missingLocales.join(", ")}]${issue.usedInCode ? " (used)" : ""}`));
@@ -369,14 +471,40 @@ export const printGlossCheck = (result, format) => {
             return `${issue.key} -> expected [${issue.expectedPlaceholders.join(", ")}] from ${issue.referenceLocale}; locales: [${issue.mismatchedLocales.join(", ")}]${pluralInfo}`;
         }));
         printSample("Hardcoded text candidates", result.hardcodedTexts.map((issue) => `${issue.file}:${issue.line} [${issue.kind}] ${issue.text}`));
-        console.log(result.ok
-            ? "\nResult: PASS"
-            : "\nResult: FAIL (non-zero exit code for CI guardrails)");
+        if (baseline?.hasPrevious) {
+            console.log("\nDelta since baseline");
+            printTable([
+                {
+                    label: "Missing translations",
+                    value: formatSigned(baseline.delta.missingTranslations),
+                },
+                { label: "Orphan keys", value: formatSigned(baseline.delta.orphanKeys) },
+                { label: "Invalid keys", value: formatSigned(baseline.delta.invalidKeys) },
+                {
+                    label: "Placeholder mismatches",
+                    value: formatSigned(baseline.delta.placeholderMismatches),
+                },
+                {
+                    label: "Hardcoded text candidates",
+                    value: formatSigned(baseline.delta.hardcodedTexts),
+                },
+                { label: "Error issues", value: formatSigned(baseline.delta.errorIssues) },
+                {
+                    label: "Warning issues",
+                    value: formatSigned(baseline.delta.warningIssues),
+                },
+                { label: "Total issues", value: formatSigned(baseline.delta.totalIssues) },
+            ]);
+        }
+        else if (baseline) {
+            console.log(`\nBaseline initialized at ${baseline.baselinePath}`);
+        }
+        console.log(result.ok ? "\nResult: PASS" : "\nResult: FAIL (blocking issues found)");
     }
     if (format === "json" || format === "both") {
         if (format === "both") {
             console.log("\nJSON output:");
         }
-        console.log(JSON.stringify(result, null, 2));
+        console.log(JSON.stringify({ ...result, baseline }, null, 2));
     }
 };