286 lines
12 KiB
JavaScript
286 lines
12 KiB
JavaScript
#!/usr/bin/env node
|
|
/* eslint-disable no-console */
|
|
import { spawn } from "node:child_process";
|
|
import { createHash } from "node:crypto";
|
|
import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
|
|
import path from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
|
const repoRoot = path.resolve(__dirname, "..");
|
|
export const reportPath = path.join(repoRoot, ".tc/baselines/i18n-hardcoded-strings/baseline-health.md");
|
|
|
|
const ignoredDirectoryNames = new Set([
|
|
".git",
|
|
".cache",
|
|
".next",
|
|
".react-router",
|
|
".tc",
|
|
".turbo",
|
|
".vite",
|
|
"build",
|
|
"cache",
|
|
"coverage",
|
|
"dist",
|
|
"docs",
|
|
"generated",
|
|
"llm-docs",
|
|
"node_modules",
|
|
]);
|
|
|
|
const ignoredFileNames = new Set(["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]);
|
|
|
|
export const i18nBrandInventoryScanRoots = ["apps/web/app", "apps/web/public", "apps/api", "apps/worker", "packages", "emails", "prisma", "server"];
|
|
|
|
export const i18nBrandInventoryPatterns = [
|
|
{ id: "locale-file-reference", pattern: /(?:public\/locales|locales\/|translations\.json|\bdefaultLocale\b|\bsupportedLocales\b|\bSupportedLocale\b)/g },
|
|
{ id: "translation-hook-or-call", pattern: /\buseTranslation\b|\bt\(\s*["'`][^"'`]+["'`]/g },
|
|
{ id: "i18next-reference", pattern: /\bi18next\b|\breact-i18next\b|\bremix-i18next\b/g },
|
|
{ id: "brand-package-reference", pattern: /(?:@toolctrl\/brand|packages\/brand|\.\.\/\.\.\/\.\.\/brand\/src\/index\.js)/g },
|
|
{ id: "brand-token-contract", pattern: /\b(?:defaultBrandTokens|createBrandTokens|resolveTransactionalBrandTokens|BrandTokens|BrandTokenOverrides|ToolCTRLBrandTokens|brandCssVariables)\b/g },
|
|
{ id: "transactional-mail-renderer", pattern: /\b(?:renderTransactionalMailTemplate|MailTemplateError|TransactionalTemplateName|TransactionalTemplateData|RenderedTransactionalMail)\b/g },
|
|
{ id: "brand-literal", pattern: /\b(?:ToolCTRL|toolctrl|SaasRock)\b/g },
|
|
{ id: "email-template-reference", pattern: /\b(?:emailTemplates?|transactional email|transactional mail|MailerSend|mailersend|templateId|subject:)\b/gi },
|
|
{ id: "logo-domain-legal-link", pattern: /\b(?:logo|favicon|terms|privacy|imprint|legal|domain|toolctrl\.com|saasrock\.com)\b/gi },
|
|
{ id: "hardcoded-jsx-text", pattern: />\s*[A-ZÄÖÜ][^<>{}\n]{8,}\s*</g },
|
|
{ id: "hardcoded-user-facing-string", pattern: /(?:title|label|placeholder|aria-label|alt|description|message|heading|subject)\s*[:=]\s*["'`][A-ZÄÖÜ][^"'`]{8,}["'`]/g },
|
|
];
|
|
|
|
export const gates = [
|
|
{ id: "typecheck", command: "pnpm", args: ["run", "typecheck"] },
|
|
{ id: "lint", command: "pnpm", args: ["run", "lint"] },
|
|
{ id: "ci-baseline", command: "node", args: ["scripts/verify-ci-baseline.mjs"] },
|
|
{ id: "vitest-i18n-smoke", command: "pnpm", args: ["exec", "vitest", "run", "packages/i18n/src/index.test.ts"] },
|
|
{ id: "hardcoded-string-guard", command: "node", args: ["scripts/verify-hardcoded-strings.mjs"] },
|
|
{ id: "i18n-brand-hardcoded-inventory", type: "i18n-brand-hardcoded-inventory" },
|
|
];
|
|
|
|
function shellCommand(gate) {
|
|
if (gate.type === "i18n-brand-hardcoded-inventory") return "read-only i18n/brand/hardcoded-string inventory";
|
|
return [gate.command, ...gate.args].join(" ");
|
|
}
|
|
|
|
function outputFingerprint(output) {
|
|
const normalized = output
|
|
.split(/\r?\n/)
|
|
.map((line) => line.trim())
|
|
.filter(Boolean)
|
|
.slice(-40)
|
|
.join("\n");
|
|
return { hash: createHash("sha256").update(output).digest("hex").slice(0, 12), excerpt: normalized.slice(0, 1200) || "(no output)" };
|
|
}
|
|
|
|
function parseNumber(value) {
|
|
const parsed = Number.parseInt(value, 10);
|
|
return Number.isFinite(parsed) ? parsed : 0;
|
|
}
|
|
|
|
function conservativeFailureCount(count, output) {
|
|
return count > 0 ? count : output.trim() ? 1 : 0;
|
|
}
|
|
|
|
function countVitestFailures(output) {
|
|
const failedTests = output.match(/Tests\s+(\d+)\s+failed/i);
|
|
if (failedTests) return parseNumber(failedTests[1]);
|
|
const failedFiles = output.match(/Test Files\s+(\d+)\s+failed/i);
|
|
return failedFiles ? parseNumber(failedFiles[1]) : 0;
|
|
}
|
|
|
|
export function failureCount(gateId, stdout, stderr, exitCode = 1) {
|
|
if (exitCode === 0 || gateId === "i18n-brand-hardcoded-inventory") return 0;
|
|
const output = `${stdout}\n${stderr}`;
|
|
if (gateId === "typecheck") return conservativeFailureCount((output.match(/error TS\d+/g) ?? []).length, output);
|
|
if (gateId === "lint") {
|
|
const problemsMatch = output.match(/✖\s+(\d+)\s+problems?\s+\((\d+)\s+errors?/i);
|
|
const compactMatch = output.match(/(\d+)\s+errors?/i);
|
|
return conservativeFailureCount(problemsMatch ? parseNumber(problemsMatch[2]) : compactMatch ? parseNumber(compactMatch[1]) : 0, output);
|
|
}
|
|
if (gateId === "vitest-i18n-smoke") return conservativeFailureCount(countVitestFailures(output), output);
|
|
if (gateId === "ci-baseline") return conservativeFailureCount((output.match(/^FAIL\s/gm) ?? []).length, output);
|
|
if (gateId === "hardcoded-string-guard") {
|
|
const totalForbidden = output.match(/total forbidden matches:\s*(\d+)/i);
|
|
return conservativeFailureCount(totalForbidden ? parseNumber(totalForbidden[1]) : 0, output);
|
|
}
|
|
return output.trim() ? 1 : 0;
|
|
}
|
|
|
|
function runShellGate(gate) {
|
|
return new Promise((resolve) => {
|
|
const startedAt = Date.now();
|
|
const child = spawn(gate.command, gate.args, { cwd: repoRoot, env: { ...process.env, CI: "1" }, shell: false });
|
|
let stdout = "";
|
|
let stderr = "";
|
|
child.stdout.on("data", (chunk) => {
|
|
stdout += chunk;
|
|
});
|
|
child.stderr.on("data", (chunk) => {
|
|
stderr += chunk;
|
|
});
|
|
child.on("error", (error) => {
|
|
stderr += `\n${error.message}`;
|
|
});
|
|
child.on("close", (code) => {
|
|
const output = `${stdout}\n${stderr}`;
|
|
resolve({
|
|
id: gate.id,
|
|
command: shellCommand(gate),
|
|
exitCode: code ?? 1,
|
|
durationMs: Date.now() - startedAt,
|
|
failureCount: failureCount(gate.id, stdout, stderr, code ?? 1),
|
|
fingerprint: outputFingerprint(output),
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
function isIgnoredDirectory(name, relativePath) {
|
|
return ignoredDirectoryNames.has(name) || ignoredDirectoryNames.has(relativePath) || name.endsWith(".cache");
|
|
}
|
|
|
|
function isIgnoredFile(name) {
|
|
return ignoredFileNames.has(name) || name.endsWith(".generated.ts") || name.endsWith(".generated.tsx") || name.endsWith(".min.js") || name.endsWith(".map");
|
|
}
|
|
|
|
async function rootExists(root, rootRelativePath) {
|
|
try {
|
|
await stat(path.join(root, rootRelativePath));
|
|
return true;
|
|
} catch (error) {
|
|
if (error?.code === "ENOENT") return false;
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function collectFiles(root, rootRelativePath) {
|
|
const absoluteRoot = path.join(root, rootRelativePath);
|
|
const rootStat = await stat(absoluteRoot);
|
|
if (rootStat.isFile()) return [absoluteRoot];
|
|
const files = [];
|
|
async function walk(directory) {
|
|
const entries = await readdir(directory, { withFileTypes: true });
|
|
for (const entry of entries) {
|
|
const absolutePath = path.join(directory, entry.name);
|
|
const relativePath = path.relative(root, absolutePath).split(path.sep).join("/");
|
|
if (entry.isDirectory()) {
|
|
if (isIgnoredDirectory(entry.name, relativePath)) continue;
|
|
await walk(absolutePath);
|
|
} else if (entry.isFile() && /\.(?:ts|tsx|js|jsx|mjs|cjs|css|json|webmanifest|html|hbs|mdx?)$/.test(entry.name) && !isIgnoredFile(entry.name)) {
|
|
files.push(absolutePath);
|
|
}
|
|
}
|
|
}
|
|
await walk(absoluteRoot);
|
|
return files;
|
|
}
|
|
|
|
export async function runI18nBrandInventory(root = repoRoot) {
|
|
const existingRoots = [];
|
|
const missingRoots = [];
|
|
for (const rootRelativePath of i18nBrandInventoryScanRoots) {
|
|
if (await rootExists(root, rootRelativePath)) existingRoots.push(rootRelativePath);
|
|
else missingRoots.push(rootRelativePath);
|
|
}
|
|
const files = (await Promise.all(existingRoots.map((rootRelativePath) => collectFiles(root, rootRelativePath)))).flat();
|
|
const counts = new Map(i18nBrandInventoryPatterns.map(({ id }) => [id, 0]));
|
|
const matches = [];
|
|
for (const file of files) {
|
|
const relativeFile = path.relative(root, file).split(path.sep).join("/");
|
|
const lines = (await readFile(file, "utf8")).split(/\r?\n/);
|
|
lines.forEach((line, index) => {
|
|
for (const { id, pattern } of i18nBrandInventoryPatterns) {
|
|
pattern.lastIndex = 0;
|
|
const found = line.match(pattern);
|
|
if (!found) continue;
|
|
counts.set(id, (counts.get(id) ?? 0) + found.length);
|
|
matches.push(`${relativeFile}:${index + 1}: [${id}] ${line.trim()}`);
|
|
}
|
|
});
|
|
}
|
|
return { roots: existingRoots, missingRoots, filesScanned: files.length, counts: Object.fromEntries(counts.entries()), totalMatches: matches.length, matches };
|
|
}
|
|
|
|
async function runI18nBrandInventoryGate(gate) {
|
|
const startedAt = Date.now();
|
|
const inventory = await runI18nBrandInventory(repoRoot);
|
|
const outputLines = [
|
|
`i18n/brand/hardcoded inventory scanned roots: ${inventory.roots.join(", ") || "(none)"}`,
|
|
`i18n/brand/hardcoded inventory missing roots skipped: ${inventory.missingRoots.join(", ") || "(none)"}`,
|
|
`i18n/brand/hardcoded inventory files scanned: ${inventory.filesScanned}`,
|
|
...Object.entries(inventory.counts).map(([id, count]) => `${id}: ${count}`),
|
|
`total matches: ${inventory.totalMatches}`,
|
|
...inventory.matches.slice(0, 240),
|
|
];
|
|
if (inventory.matches.length > 240) outputLines.push(`... ${inventory.matches.length - 240} additional matches omitted`);
|
|
const output = outputLines.join("\n");
|
|
const failureCount = inventory.roots.length === 0 || inventory.filesScanned === 0 ? 1 : 0;
|
|
return { id: gate.id, command: shellCommand(gate), exitCode: failureCount > 0 ? 1 : 0, durationMs: Date.now() - startedAt, failureCount, fingerprint: outputFingerprint(output) };
|
|
}
|
|
|
|
async function runGate(gate) {
|
|
if (gate.type === "i18n-brand-hardcoded-inventory") return runI18nBrandInventoryGate(gate);
|
|
return runShellGate(gate);
|
|
}
|
|
|
|
export function renderReport(results) {
|
|
const lines = [
|
|
"# i18n Hardcoded Strings Baseline Health",
|
|
"",
|
|
`Generated: ${new Date().toISOString()}`,
|
|
"",
|
|
"This report captures non-E2E baseline gates for i18n Hardcoded Strings baseline. The runner exits 0 when every gate was attempted and this report was written, even if individual gates fail.",
|
|
"The i18n smoke gate uses the existing packages/i18n/src/index.test.ts locale coverage. The hardcoded-string guard runs scripts/verify-hardcoded-strings.mjs and reports forbidden user-facing/brand literal drift before the read-only inventory context. The i18n/brand/hardcoded inventory gate is read-only and fingerprints locale references, translation hooks/calls, i18next usage, @toolctrl/brand package references, default brand token contracts, transactional mail renderer contracts, ToolCTRL/toolctrl/SaasRock branding literals, email templates, logo/domain/legal-link strings, and obvious user-facing hardcoded JSX/text literals while skipping missing roots plus generated, dependency, build, cache, documentation, lockfile, and TC artifact folders.",
|
|
"",
|
|
];
|
|
for (const result of results)
|
|
lines.push(
|
|
`## ${result.id}`,
|
|
"",
|
|
`- Command: \`${result.command}\``,
|
|
`- Exitcode: ${result.exitCode}`,
|
|
`- Failure Count: ${result.failureCount}`,
|
|
`- Duration: ${result.durationMs}ms`,
|
|
`- Output Fingerprint: ${result.fingerprint.hash}`,
|
|
"",
|
|
"```text",
|
|
result.fingerprint.excerpt,
|
|
"```",
|
|
"",
|
|
);
|
|
return `${lines.join("\n")}\n`;
|
|
}
|
|
|
|
async function writeFailureReport(error) {
|
|
await mkdir(path.dirname(reportPath), { recursive: true });
|
|
const output = error?.stack ?? String(error);
|
|
await writeFile(
|
|
reportPath,
|
|
renderReport([{ id: "runner-error", command: "node scripts/verify-i18n-hardcoded-baseline.mjs", exitCode: 1, durationMs: 0, failureCount: 1, fingerprint: outputFingerprint(output) }]),
|
|
"utf8",
|
|
);
|
|
}
|
|
|
|
async function main() {
|
|
const results = [];
|
|
for (const gate of gates) {
|
|
console.log(`Running ${gate.id}: ${shellCommand(gate)}`);
|
|
results.push(await runGate(gate));
|
|
}
|
|
await mkdir(path.dirname(reportPath), { recursive: true });
|
|
await writeFile(reportPath, renderReport(results), "utf8");
|
|
console.log(`Wrote ${path.relative(repoRoot, reportPath)}`);
|
|
if (results.some((result) => result.exitCode !== 0 || result.failureCount > 0)) {
|
|
process.exitCode = 1;
|
|
}
|
|
}
|
|
|
|
if (process.argv[1] === fileURLToPath(import.meta.url)) {
|
|
main().catch(async (error) => {
|
|
console.error(error);
|
|
try {
|
|
await writeFailureReport(error);
|
|
} finally {
|
|
process.exit(1);
|
|
}
|
|
});
|
|
}
|