failproofai 0.0.2 → 0.0.3

package/scripts/translate-docs/config.ts

@@ -0,0 +1,248 @@
+import type { LanguageConfig } from "./types";
+
+export const LANGUAGES: LanguageConfig[] = [
+  // Tier 1 — largest developer populations
+  { code: "zh", name: "Chinese (Simplified)", nativeName: "\u7b80\u4f53\u4e2d\u6587", tier: 1 },
+  { code: "ja", name: "Japanese", nativeName: "\u65e5\u672c\u8a9e", tier: 1 },
+  { code: "ko", name: "Korean", nativeName: "\ud55c\uad6d\uc5b4", tier: 1 },
+  { code: "es", name: "Spanish", nativeName: "Espa\u00f1ol", tier: 1 },
+  { code: "pt-br", name: "Portuguese (Brazil)", nativeName: "Portugu\u00eas", tier: 1 },
+  { code: "de", name: "German", nativeName: "Deutsch", tier: 1 },
+  { code: "fr", name: "French", nativeName: "Fran\u00e7ais", tier: 1 },
+  // Tier 2 — strong tech communities
+  { code: "ru", name: "Russian", nativeName: "\u0420\u0443\u0441\u0441\u043a\u0438\u0439", tier: 2 },
+  { code: "hi", name: "Hindi", nativeName: "\u0939\u093f\u0928\u094d\u0926\u0940", tier: 2 },
+  { code: "tr", name: "Turkish", nativeName: "T\u00fcrk\u00e7e", tier: 2 },
+  { code: "vi", name: "Vietnamese", nativeName: "Ti\u1ebfng Vi\u1ec7t", tier: 2 },
+  { code: "it", name: "Italian", nativeName: "Italiano", tier: 2 },
+  // Tier 3 — RTL languages
+  { code: "ar", name: "Arabic", nativeName: "\u0627\u0644\u0639\u0631\u0628\u064a\u0629", tier: 3, rtl: true },
+  { code: "he", name: "Hebrew", nativeName: "\u05e2\u05d1\u05e8\u05d9\u05ea", tier: 3, rtl: true },
+];
+
+export function getLanguagesByTier(maxTier: number): LanguageConfig[] {
+  return LANGUAGES.filter((l) => l.tier <= maxTier);
+}
+
+export function getLanguageByCode(code: string): LanguageConfig | undefined {
+  return LANGUAGES.find((l) => l.code === code);
+}
+
+export function getLanguageCodes(maxTier?: number): string[] {
+  const langs = maxTier ? getLanguagesByTier(maxTier) : LANGUAGES;
+  return langs.map((l) => l.code);
+}
+
+/** Return the default model for a given tier. Tier 1 gets Sonnet, Tier 2/3 gets Haiku. */
+export function getModelForTier(tier: number): string {
+  return tier <= 1 ? "claude-sonnet-4-6" : "claude-haiku-4-5-20251001";
+}
+
+/** Terms that should never be translated — kept as-is in all languages. */
+export const DO_NOT_TRANSLATE = [
+  "failproofai",
+  "Failproof AI",
+  "FailproofAI",
+  "Claude Code",
+  "Agents SDK",
+  "Claude",
+  "Anthropic",
+  "Node.js",
+  "Bun",
+  "npm",
+  "npx",
+  "MDX",
+  "JSON",
+  "JSONL",
+  "ESM",
+  "CJS",
+  "settings.json",
+  "policies-config.json",
+  "policies-config.local.json",
+  "hook-activity.jsonl",
+  "hook.log",
+  "dist/index.js",
+  ".failproofai",
+  "~/.failproofai",
+  "~/.claude",
+  // CLI commands and flags
+  "failproofai policies --install",
+  "failproofai policies --uninstall",
+  "--install",
+  "--uninstall",
+  "--scope",
+  "--port",
+  "--strict",
+  "--projects-path",
+  "--allowed-origins",
+  // Policy names
+  "block-sudo",
+  "block-rm-rf",
+  "sanitize-api-keys",
+  "prevent-secret-leakage",
+  "block-force-push",
+  "restrict-to-project",
+  "detect-loops",
+  // Technical terms
+  "PreToolUse",
+  "PostToolUse",
+  "PreNotification",
+  "PostNotification",
+  "allow",
+  "deny",
+  "instruct",
+  "customPolicies",
+  "localhost",
+  "stdin",
+  "stdout",
+];
+
+/** Navigation group translations for each language. */
+export const NAV_TRANSLATIONS: Record<
+  string,
+  {
+    docs: string;
+    examples: string;
+    gettingStarted: string;
+    coreConcepts: string;
+    cli: string;
+    tools: string;
+    advanced: string;
+  }
+> = {
+  en: {
+    docs: "Docs",
+    examples: "Examples",
+    gettingStarted: "Getting Started",
+    coreConcepts: "Core Concepts",
+    cli: "CLI",
+    tools: "Tools",
+    advanced: "Advanced",
+  },
+  zh: {
+    docs: "\u6587\u6863",
+    examples: "\u793a\u4f8b",
+    gettingStarted: "\u5feb\u901f\u5f00\u59cb",
+    coreConcepts: "\u6838\u5fc3\u6982\u5ff5",
+    cli: "CLI",
+    tools: "\u5de5\u5177",
+    advanced: "\u8fdb\u9636",
+  },
+  ja: {
+    docs: "\u30c9\u30ad\u30e5\u30e1\u30f3\u30c8",
+    examples: "\u4f8b",
+    gettingStarted: "\u306f\u3058\u3081\u306b",
+    coreConcepts: "\u57fa\u672c\u6982\u5ff5",
+    cli: "CLI",
+    tools: "\u30c4\u30fc\u30eb",
+    advanced: "\u4e0a\u7d1a",
+  },
+  ko: {
+    docs: "\ubb38\uc11c",
+    examples: "\uc608\uc81c",
+    gettingStarted: "\uc2dc\uc791\ud558\uae30",
+    coreConcepts: "\ud575\uc2ec \uac1c\ub150",
+    cli: "CLI",
+    tools: "\ub3c4\uad6c",
+    advanced: "\uace0\uae09",
+  },
+  es: {
+    docs: "Documentaci\u00f3n",
+    examples: "Ejemplos",
+    gettingStarted: "Primeros pasos",
+    coreConcepts: "Conceptos principales",
+    cli: "CLI",
+    tools: "Herramientas",
+    advanced: "Avanzado",
+  },
+  "pt-br": {
+    docs: "Documenta\u00e7\u00e3o",
+    examples: "Exemplos",
+    gettingStarted: "Come\u00e7ando",
+    coreConcepts: "Conceitos principais",
+    cli: "CLI",
+    tools: "Ferramentas",
+    advanced: "Avan\u00e7ado",
+  },
+  de: {
+    docs: "Dokumentation",
+    examples: "Beispiele",
+    gettingStarted: "Erste Schritte",
+    coreConcepts: "Kernkonzepte",
+    cli: "CLI",
+    tools: "Werkzeuge",
+    advanced: "Fortgeschritten",
+  },
+  fr: {
+    docs: "Documentation",
+    examples: "Exemples",
+    gettingStarted: "D\u00e9marrage",
+    coreConcepts: "Concepts cl\u00e9s",
+    cli: "CLI",
+    tools: "Outils",
+    advanced: "Avanc\u00e9",
+  },
+  ru: {
+    docs: "\u0414\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u0430\u0446\u0438\u044f",
+    examples: "\u041f\u0440\u0438\u043c\u0435\u0440\u044b",
+    gettingStarted: "\u041d\u0430\u0447\u0430\u043b\u043e \u0440\u0430\u0431\u043e\u0442\u044b",
+    coreConcepts: "\u041e\u0441\u043d\u043e\u0432\u043d\u044b\u0435 \u043a\u043e\u043d\u0446\u0435\u043f\u0446\u0438\u0438",
+    cli: "CLI",
+    tools: "\u0418\u043d\u0441\u0442\u0440\u0443\u043c\u0435\u043d\u0442\u044b",
+    advanced: "\u041f\u0440\u043e\u0434\u0432\u0438\u043d\u0443\u0442\u044b\u0439",
+  },
+  hi: {
+    docs: "\u0926\u0938\u094d\u0924\u093e\u0935\u0947\u091c\u093c",
+    examples: "\u0909\u0926\u093e\u0939\u0930\u0923",
+    gettingStarted: "\u0936\u0941\u0930\u0942 \u0915\u0930\u0947\u0902",
+    coreConcepts: "\u092e\u0942\u0932 \u0905\u0935\u0927\u093e\u0930\u0923\u093e\u090f\u0901",
+    cli: "CLI",
+    tools: "\u0909\u092a\u0915\u0930\u0923",
+    advanced: "\u0909\u0928\u094d\u0928\u0924",
+  },
+  tr: {
+    docs: "Belgeler",
+    examples: "\u00d6rnekler",
+    gettingStarted: "Ba\u015flang\u0131\u00e7",
+    coreConcepts: "Temel Kavramlar",
+    cli: "CLI",
+    tools: "Ara\u00e7lar",
+    advanced: "Geli\u015fmi\u015f",
+  },
+  vi: {
+    docs: "T\u00e0i li\u1ec7u",
+    examples: "V\u00ed d\u1ee5",
+    gettingStarted: "B\u1eaft \u0111\u1ea7u",
+    coreConcepts: "Kh\u00e1i ni\u1ec7m c\u1ed1t l\u00f5i",
+    cli: "CLI",
+    tools: "C\u00f4ng c\u1ee5",
+    advanced: "N\u00e2ng cao",
+  },
+  it: {
+    docs: "Documentazione",
+    examples: "Esempi",
+    gettingStarted: "Per iniziare",
+    coreConcepts: "Concetti chiave",
+    cli: "CLI",
+    tools: "Strumenti",
+    advanced: "Avanzato",
+  },
+  ar: {
+    docs: "\u0627\u0644\u0645\u0633\u062a\u0646\u062f\u0627\u062a",
+    examples: "\u0623\u0645\u062b\u0644\u0629",
+    gettingStarted: "\u0627\u0644\u0628\u062f\u0627\u064a\u0629",
+    coreConcepts: "\u0627\u0644\u0645\u0641\u0627\u0647\u064a\u0645 \u0627\u0644\u0623\u0633\u0627\u0633\u064a\u0629",
+    cli: "CLI",
+    tools: "\u0627\u0644\u0623\u062f\u0648\u0627\u062a",
+    advanced: "\u0645\u062a\u0642\u062f\u0645",
+  },
+  he: {
+    docs: "\u05ea\u05d9\u05e2\u05d5\u05d3",
+    examples: "\u05d3\u05d5\u05d2\u05de\u05d0\u05d5\u05ea",
+    gettingStarted: "\u05ea\u05d7\u05d9\u05dc\u05ea \u05e2\u05d1\u05d5\u05d3\u05d4",
+    coreConcepts: "\u05de\u05d5\u05e9\u05d2\u05d9 \u05d9\u05e1\u05d5\u05d3",
+    cli: "CLI",
+    tools: "\u05db\u05dc\u05d9\u05dd",
+    advanced: "\u05de\u05ea\u05e7\u05d3\u05dd",
+  },
+};

package/scripts/translate-docs/mdx-translator.ts

@@ -0,0 +1,153 @@
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getLanguageByCode } from "./config";
+import { translateContent } from "./translator";
+import {
+  readCache,
+  writeCache,
+  isCached,
+  setCacheEntry,
+} from "./cache";
+import type { TranslationResult, TranslationCache } from "./types";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DOCS_DIR = join(__dirname, "..", "..", "docs");
+
+/**
+ * Rewrite internal doc links to include the language prefix.
+ * e.g. href="/built-in-policies" -> href="/es/built-in-policies"
+ *      [Getting started](/getting-started) -> [Getting started](/es/getting-started)
+ */
+export function rewriteInternalLinks(
+  content: string,
+  lang: string,
+): string {
+  // Rewrite MDX component href attributes pointing to internal paths
+  let result = content.replace(
+    /href="(\/[^"]*?)"/g,
+    (_match, path: string) => {
+      // Skip external URLs and anchors
+      if (path.startsWith("/http") || path === "/") return `href="${path}"`;
+      return `href="/${lang}${path}"`;
+    },
+  );
+
+  // Rewrite Markdown links with internal paths
+  result = result.replace(
+    /\]\((\/[^)]*?)\)/g,
+    (_match, path: string) => {
+      if (path.startsWith("/http") || path === "/") return `](${path})`;
+      return `](/${lang}${path})`;
+    },
+  );
+
+  return result;
+}
+
+/**
+ * Translate a single MDX doc page for a given language.
+ */
+export async function translateMdxPage(
+  sourcePath: string,
+  lang: string,
+  options: { force?: boolean; dryRun?: boolean; model?: string; cache?: TranslationCache } = {},
+): Promise<TranslationResult> {
+  const relPath = relative(DOCS_DIR, sourcePath);
+  const outputPath = join(DOCS_DIR, lang, relPath);
+  const sourceContent = readFileSync(sourcePath, "utf-8");
+
+  const langConfig = getLanguageByCode(lang);
+  if (!langConfig) throw new Error(`Unknown language: ${lang}`);
+
+  // Check cache — use provided cache object or read from disk
+  if (!options.force && !options.dryRun) {
+    const cache = options.cache ?? readCache();
+    if (isCached(cache, relPath, lang, sourceContent)) {
+      return {
+        lang,
+        sourcePath,
+        outputPath,
+        inputTokens: 0,
+        outputTokens: 0,
+        cached: true,
+      };
+    }
+  }
+
+  if (options.dryRun) {
+    return {
+      lang,
+      sourcePath,
+      outputPath,
+      inputTokens: 0,
+      outputTokens: 0,
+      cached: false,
+    };
+  }
+
+  // Translate
+  const { translated, inputTokens, outputTokens } = await translateContent(
+    sourceContent,
+    lang,
+    langConfig.name,
+    options.model,
+  );
+
+  // Rewrite internal links
+  const withLinks = rewriteInternalLinks(translated, lang);
+
+  // Write output
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, withLinks);
+
+  // Update cache — skip if caller manages the cache (batch write)
+  if (!options.cache) {
+    const cache = readCache();
+    setCacheEntry(cache, relPath, lang, sourceContent, inputTokens, outputTokens);
+    writeCache(cache);
+  }
+
+  return {
+    lang,
+    sourcePath,
+    outputPath,
+    inputTokens,
+    outputTokens,
+    cached: false,
+  };
+}
+
+/**
+ * Get all MDX page paths from the docs directory (English only, no language subdirs).
+ */
+export function getEnglishMdxPages(): string[] {
+  const results: string[] = [];
+
+  function walk(dir: string, prefix: string = "") {
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry);
+      const rel = prefix ? `${prefix}/${entry}` : entry;
+      if (statSync(full).isDirectory()) {
+        // Skip language directories at the top level
+        if (!prefix && isLanguageDir(entry)) continue;
+        // Skip non-doc directories like logo, i18n
+        if (!prefix && (entry === "logo" || entry === "i18n")) continue;
+        walk(full, rel);
+      } else if (entry.endsWith(".mdx")) {
+        results.push(full);
+      }
+    }
+  }
+
+  walk(DOCS_DIR);
+  return results.sort();
+}
+
+function isLanguageDir(name: string): boolean {
+  const langCodes = [
+    "zh", "ja", "ko", "es", "pt-br", "de", "fr",
+    "ru", "hi", "tr", "vi", "it", "ar", "he",
+  ];
+  return langCodes.includes(name);
+}

package/scripts/translate-docs/mintlify-nav.ts

@@ -0,0 +1,107 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { NAV_TRANSLATIONS, LANGUAGES } from "./config";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DOCS_JSON_PATH = join(__dirname, "..", "..", "docs", "docs.json");
+
+interface NavGroup {
+  group: string;
+  pages: string[];
+}
+
+interface NavTab {
+  tab: string;
+  groups: NavGroup[];
+}
+
+interface LanguageNav {
+  language: string;
+  tabs: NavTab[];
+}
+
+/**
+ * Build a navigation entry for a specific language by transforming the
+ * English navigation structure.
+ */
+export function buildLanguageNav(
+  englishTabs: NavTab[],
+  lang: string,
+): LanguageNav {
+  const t = NAV_TRANSLATIONS[lang];
+  if (!t) throw new Error(`No nav translations for language: ${lang}`);
+
+  const groupNameMap: Record<string, string> = {
+    "Getting Started": t.gettingStarted,
+    "Core Concepts": t.coreConcepts,
+    CLI: t.cli,
+    Tools: t.tools,
+    Advanced: t.advanced,
+    Examples: t.examples,
+  };
+
+  const tabNameMap: Record<string, string> = {
+    Docs: t.docs,
+    Examples: t.examples,
+  };
+
+  const tabs: NavTab[] = englishTabs.map((tab) => ({
+    tab: tabNameMap[tab.tab] || tab.tab,
+    groups: tab.groups.map((group) => ({
+      group: groupNameMap[group.group] || group.group,
+      pages: group.pages.map((page) => `${lang}/${page}`),
+    })),
+  }));
+
+  return { language: lang, tabs };
+}
+
+/**
+ * Read the current docs.json config.
+ */
+export function readDocsConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(DOCS_JSON_PATH, "utf-8"));
+}
+
+/**
+ * Generate the full languages array for docs.json from the English nav
+ * and a list of language codes.
+ */
+export function generateLanguagesArray(
+  englishTabs: NavTab[],
+  langCodes: string[],
+): LanguageNav[] {
+  // English first (default)
+  const english: LanguageNav = { language: "en", tabs: englishTabs };
+  const others = langCodes.map((code) => buildLanguageNav(englishTabs, code));
+  return [english, ...others];
+}
+
+/**
+ * Update docs.json to use the languages array structure.
+ */
+export function updateDocsJson(langCodes: string[]): void {
+  const config = readDocsConfig();
+  const nav = config.navigation as Record<string, unknown>;
+
+  // Extract existing English tabs
+  const englishTabs = nav.tabs as NavTab[];
+  if (!englishTabs) {
+    throw new Error("docs.json navigation.tabs not found — is this already using the languages format?");
+  }
+
+  // Build languages array
+  const languages = generateLanguagesArray(englishTabs, langCodes);
+
+  // Replace tabs with languages, preserve global
+  const newNav: Record<string, unknown> = {
+    languages,
+  };
+  if (nav.global) {
+    newNav.global = nav.global;
+  }
+
+  config.navigation = newNav;
+  writeFileSync(DOCS_JSON_PATH, JSON.stringify(config, null, 2) + "\n");
+}

package/scripts/translate-docs/readme-translator.ts

@@ -0,0 +1,154 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { LANGUAGES, getLanguageByCode } from "./config";
+import { translateContent } from "./translator";
+import { readCache, writeCache, isCached, setCacheEntry } from "./cache";
+import type { TranslationResult, TranslationCache } from "./types";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = join(__dirname, "..", "..");
+const README_PATH = join(ROOT_DIR, "README.md");
+const I18N_DIR = join(ROOT_DIR, "docs", "i18n");
+
+function buildLanguageSelector(currentLang: string): string {
+  const flags: Record<string, string> = {
+    en: "\ud83c\uddfa\ud83c\uddf8",
+    zh: "\ud83c\udde8\ud83c\uddf3",
+    ja: "\ud83c\uddef\ud83c\uddf5",
+    ko: "\ud83c\uddf0\ud83c\uddf7",
+    es: "\ud83c\uddea\ud83c\uddf8",
+    "pt-br": "\ud83c\udde7\ud83c\uddf7",
+    de: "\ud83c\udde9\ud83c\uddea",
+    fr: "\ud83c\uddeb\ud83c\uddf7",
+    ru: "\ud83c\uddf7\ud83c\uddfa",
+    hi: "\ud83c\uddee\ud83c\uddf3",
+    tr: "\ud83c\uddf9\ud83c\uddf7",
+    vi: "\ud83c\uddfb\ud83c\uddf3",
+    it: "\ud83c\uddee\ud83c\uddf9",
+    ar: "\ud83c\uddf8\ud83c\udde6",
+    he: "\ud83c\uddee\ud83c\uddf1",
+  };
+
+  const links: string[] = [];
+
+  // English link (to root README)
+  if (currentLang !== "en") {
+    links.push(`[${flags.en} English](../../README.md)`);
+  }
+
+  for (const lang of LANGUAGES) {
+    const flag = flags[lang.code] || "";
+    if (lang.code === currentLang) {
+      links.push(`**${flag} ${lang.nativeName}**`);
+    } else {
+      links.push(`[${flag} ${lang.nativeName}](README.${lang.code}.md)`);
+    }
+  }
+
+  return links.join(" | ");
+}
+
+export async function translateReadme(
+  lang: string,
+  options: { force?: boolean; dryRun?: boolean; model?: string; cache?: TranslationCache } = {},
+): Promise<TranslationResult> {
+  const outputPath = join(I18N_DIR, `README.${lang}.md`);
+  const sourceContent = readFileSync(README_PATH, "utf-8");
+
+  const langConfig = getLanguageByCode(lang);
+  if (!langConfig) throw new Error(`Unknown language: ${lang}`);
+
+  // Check cache — use provided cache object or read from disk
+  if (!options.force && !options.dryRun) {
+    const cache = options.cache ?? readCache();
+    if (isCached(cache, "README.md", lang, sourceContent)) {
+      return {
+        lang,
+        sourcePath: README_PATH,
+        outputPath,
+        inputTokens: 0,
+        outputTokens: 0,
+        cached: true,
+      };
+    }
+  }
+
+  if (options.dryRun) {
+    return {
+      lang,
+      sourcePath: README_PATH,
+      outputPath,
+      inputTokens: 0,
+      outputTokens: 0,
+      cached: false,
+    };
+  }
+
+  // Translate
+  const { translated, inputTokens, outputTokens } = await translateContent(
+    sourceContent,
+    lang,
+    langConfig.name,
+    options.model,
+  );
+
+  // Build the final output with header
+  const disclaimer = langConfig.rtl
+    ? `> **\u26a0\ufe0f** \u0647\u0630\u0647 \u062a\u0631\u062c\u0645\u0629 \u0622\u0644\u064a\u0629. \u0644\u0644\u0627\u0637\u0644\u0627\u0639 \u0639\u0644\u0649 \u0623\u062d\u062f\u062b \u0625\u0635\u062f\u0627\u0631\u060c \u0631\u0627\u062c\u0639 [English README](../../README.md).`
+    : `> **\u26a0\ufe0f** This is an auto-generated translation. For the latest version, see the [English README](../../README.md). Community corrections welcome!`;
+
+  const langSelector = buildLanguageSelector(lang);
+  const rtlOpen = langConfig.rtl ? `<div dir="rtl">\n\n` : "";
+  const rtlClose = langConfig.rtl ? `\n\n</div>` : "";
+
+  const output = `${disclaimer}\n\n${langSelector}\n\n---\n${rtlOpen}\n${translated}\n${rtlClose}`;
+
+  // Write output
+  mkdirSync(I18N_DIR, { recursive: true });
+  writeFileSync(outputPath, output);
+
+  // Update cache — skip if caller manages the cache (batch write)
+  if (!options.cache) {
+    const cache = readCache();
+    setCacheEntry(cache, "README.md", lang, sourceContent, inputTokens, outputTokens);
+    writeCache(cache);
+  }
+
+  return {
+    lang,
+    sourcePath: README_PATH,
+    outputPath,
+    inputTokens,
+    outputTokens,
+    cached: false,
+  };
+}
+
+/**
+ * Build the language selector line to add to the main README.
+ */
+export function buildMainReadmeLanguageLinks(): string {
+  const flags: Record<string, string> = {
+    zh: "\ud83c\udde8\ud83c\uddf3",
+    ja: "\ud83c\uddef\ud83c\uddf5",
+    ko: "\ud83c\uddf0\ud83c\uddf7",
+    es: "\ud83c\uddea\ud83c\uddf8",
+    "pt-br": "\ud83c\udde7\ud83c\uddf7",
+    de: "\ud83c\udde9\ud83c\uddea",
+    fr: "\ud83c\uddeb\ud83c\uddf7",
+    ru: "\ud83c\uddf7\ud83c\uddfa",
+    hi: "\ud83c\uddee\ud83c\uddf3",
+    tr: "\ud83c\uddf9\ud83c\uddf7",
+    vi: "\ud83c\uddfb\ud83c\uddf3",
+    it: "\ud83c\uddee\ud83c\uddf9",
+    ar: "\ud83c\uddf8\ud83c\udde6",
+    he: "\ud83c\uddee\ud83c\uddf1",
+  };
+
+  const links = LANGUAGES.map(
+    (l) => `[${flags[l.code] || ""} ${l.nativeName}](docs/i18n/README.${l.code}.md)`,
+  );
+
+  return `**Translations**: ${links.join(" | ")}`;
+}