agent-quality-kit 0.2.5 → 0.4.0

package/tool/i18n/en.mjs

@@ -0,0 +1,436 @@
+// tool/i18n/en.mjs — английский каталог строк вывода.
+//
+// Правка здесь обязана иметь пару в ru.mjs с тем же ключом: расхождение ловит модульная
+// проверка «оба каталога несут одни и те же ключи».
+
+import { templates } from "./templates-en.mjs";
+
+export const en = {
+  templates,
+  help: {
+    tagline: "tooling for building software with agents",
+    name: "<name>",
+    init: "lay the rules and guides into the current project",
+    initForce: "overwrite files that already exist",
+    start: "no code yet: day-zero guards and the order of work",
+    doctor: "check what is laid out and what is missing",
+    doctorRun: "and also run the declared gates",
+    add: "install a gate from the catalogue into the project",
+    find: "is there already such a gate — matched by intent",
+    why: "a bug slipped through — why did no guard catch it",
+    ratchet: "ratchet: existing violations become debt, new ones are blocked",
+    new: "scaffold your own gate for the catalogue",
+    note: "record a lesson in the shared bruise journal",
+    blob: "assemble the guides into a single GOD_AI.md",
+    report: "the mandatory report form: what is in place, what is not, what was not read",
+    badge: "a level badge for your README — and a check that it does not lie",
+    noInstall: "Without installing:  npx agent-quality-kit init",
+    language: "Output language: AQK_LANG=ru (or en), otherwise your system locale",
+  },
+
+  doctor: {
+    docsKit: "guides — the originals live here, not a copy",
+    docs: "guides",
+    rulesKit: "standards — the originals live here, not a copy",
+    rules: "standards",
+    agents: "entry point for agents",
+    gitignore: "repository hygiene",
+    git: "project under version control",
+
+    emptyCommands: (n) => `AGENTS.md has ${n} unfilled commands.`,
+    emptyCommandsWhy: "An agent cannot execute an empty line.",
+
+    levelHeading: "AQK compliance level",
+    levelNone: "none",
+    levelNotSet: "Level: the standard is not set up in this repository.",
+    levelNotSetWhy: [
+      "This is not a verdict on the project. The level measures how machine-readable",
+      "your practice is, not how mature it is. Checks may exist and work — but until",
+      "they are declared in .aqk.yml, no agent, no pipeline and no newcomer knows.",
+    ],
+    levelManifestNoZero: "Level: a manifest exists, but AQK-0 is not reached.",
+    level: (n) => `Level: AQK-${n}.`,
+    toReach: (n) => `To reach AQK-${n}:`,
+    gives: (what) => `What it buys you: ${what}`,
+    allDone: "All levels reached.",
+
+    gatesHeading: "Gates",
+    langs: "languages",
+    langsUnknown: "not detected",
+    files: "files",
+    hasThings: "has",
+    install: (cmd) => `install: ${cmd}`,
+    notApplicable: (n) => `Not applicable to this repository (${n}):`,
+    total: "Total:",
+    totalHeld: (n) => `held by a machine ${n}`,
+    totalTodo: (n) => `applicable but not installed ${n}`,
+    totalSkip: (n) => `hidden ${n}`,
+
+    runHeading: "Running the declared gates",
+    timeout: "did not finish within 5 minutes",
+    exitCode: (code) => `exit ${code}`,
+    moreLines: (n) => `… and ${n} more lines`,
+    declaredNotRun: (n) => `${n} gates declared, but never run.`,
+    declaredNotRunWhy: (cmd) => ` "declared" and "works" are different claims: ${cmd}`,
+
+    thresholdPass: (min) => `Threshold AQK-${min} passed.`,
+    thresholdFail: (min, now) => `Threshold AQK-${min} NOT passed: currently AQK-${now}.`,
+  },
+
+  trigger: {
+    noLangs: (langs) => `none of these languages: ${langs}`,
+    tooFewFiles: (n) => `fewer than ${n} files — too early`,
+    tooManyFiles: (n) => `more than ${n} files`,
+    notSet: "no trigger declared",
+    unknown: (key) => `the program cannot evaluate the condition "${key}"`,
+    flags: {
+      has_gates: ["no gates declared in the manifest", "gates are already declared"],
+      has_ci: ["no pipeline in this repository", "a pipeline already exists"],
+      has_db: ["no database in sight: no migrations, no sql", "a database exists"],
+      has_docker: ["no Dockerfile or compose", "docker is already here"],
+      has_deps: ["no dependency file in sight", "dependencies are declared"],
+      has_tests: ["no tests in sight", "tests exist"],
+      has_env: ["no environment file", "an environment file exists"],
+    },
+  },
+
+  recipe: {
+    skipped: (lang, prog) => `skipped the ${lang} recipe: "${prog}" is not installed`,
+    none: "no recipe described",
+  },
+
+  manifest: {
+    noGatesBlock: "no gates: block in .aqk.yml",
+    alreadyDeclared: "already declared",
+  },
+
+  add: {
+    noSuchGate: (slug, cmd) => `No such gate: ${slug}\nThe applicable ones — ${cmd}`,
+    noRecipe: (slug, stack) => `Entry ${slug} has no command for ${stack} and no portable one.`,
+    thisStack: "this stack",
+    needName: (cmd, doctor) => `Name the gate: ${cmd}. The list — ${doctor}`,
+    noManifest: (cmd) => `No .aqk.yml — run ${cmd} first`,
+    notApplicable: (why) => `This gate does not apply to the repository: ${why}`,
+    installAnyway: "Installing anyway — your call, but it has nothing to guard here.",
+    copied: (n) => `${n} files: the check and its samples`,
+    declared: (cmd) => `gate declared: ${cmd}`,
+    notDeclared: (why, slug, cmd) => `untouched (${why}). Add it yourself: ${slug}: "${cmd}"`,
+    nextTitle: "Next:",
+    next1: "Check that it goes red and stays quiet where it should:",
+    expectFail: "→ a failure is expected",
+    expectSilence: "→ silence is expected",
+    next2: "Put the command into your commit hook and your pipeline.",
+    next2Why: "A gate nobody runs is not a gate.",
+    next3: (cmd) => `Run everything declared: ${cmd}`,
+  },
+
+  gnew: {
+    needName: (cmd) => `Name it: ${cmd}`,
+    badName: (slug) => `The name "${slug}" will not do: lowercase latin with dashes, e.g. secrets-not-in-code.\nThe name is read in other people's projects — it is part of a shared vocabulary.`,
+    looksExisting: (slug) => `Looks like this already exists: ${slug}`,
+    recipeNotGate: "A recipe for another stack is a line in the recipes of an existing entry.",
+    forceHint: (cmd) => `Create a new one anyway: ${cmd}`,
+    exists: (path) => `${path} already exists.`,
+    nextTitle: "Next, in order:",
+    n1: "Check whether an off-the-shelf rule exists",
+    n1Where: "in ruff, eslint, semgrep.",
+    n1Why: "Off-the-shelf is more precise, better documented and maintained without you. Your own check is the fallback.",
+    n2: "Add the samples.",
+    n2Red: "— code the check must fire on.",
+    n2Green: "— the same code, done right.",
+    n2Why: "The green one matters more: it catches a check that goes red on correct code.",
+    n3: "Write the check",
+    n3Where: "in check.sh. The failure text must say what exactly to do.",
+    n4: "Fill in gate.yml:",
+    n4What: "the intent, the trigger, the failure it proved itself on.",
+    n5: "Run it:",
+    n5Why: "The arbiter must go red on red/ and stay quiet on green/. It did not — it is not an entry.",
+  },
+
+  ratchet: {
+    needName: (cmd) => `Name the gate: ${cmd}. It must already be declared in .aqk.yml`,
+    noManifest: (cmd) => `No .aqk.yml — run ${cmd} first`,
+    notDeclared: (slug, cmd) => `Gate "${slug}" is not declared in .aqk.yml. First: ${cmd}`,
+    already: (slug) => `Gate "${slug}" already has a ratchet.`,
+    notRunnable: (slug, cmd) =>
+      `Gate "${slug}" does not run: ${cmd}\n` +
+      `You cannot capture debt from a guard that does not exist — its own error messages\n` +
+      `would land in the registry and become a permission. Fix the command first.`,
+    registryHead: (slug, stamp) =>
+      `# Debt registry: ${slug}\n` +
+      `# Captured ${stamp}. This list may ONLY get shorter.\n` +
+      `# A new violation turns the gate red; a fixed one is struck out automatically.\n`,
+    recorded: (n) => `${n} violations recorded as debt`,
+    libCopied: "wrapper copied into the project",
+    wrapped: "command wrapped in the ratchet",
+    changesTitle: "What this changes:",
+    fromToday: "from the day it is installed",
+    changes1: (fromToday) => `The rule applies ${fromToday}. The old code stays untouched, but a new`,
+    changes2: "violation of the same class will not get through.",
+    test1: 'The test for a ratchet rather than an advisor: "can new code add a violation',
+    test2: 'and still pass?" If it can, there is no gate.',
+    run: (cmd) => `Run it: ${cmd}`,
+  },
+
+  find: {
+    needQuery: (cmd) => `Describe the intent in words: ${cmd}`,
+    example: 'find "debug printing reaches production"',
+    exists: "This already exists — no new entry needed:",
+    match: (pct) => `${pct}% match`,
+    recipes: (langs) => `recipes: ${langs}portable`,
+    existsWhy1: "If you have a recipe for another stack, that is a line in the recipes of the",
+    existsWhy2: "existing entry, not a new gate. One intent, many possible executors.",
+    near: "No exact match, but these are close:",
+    nearWhy: "Read their README. If the intent is the same — extend it, do not start a new one.",
+    none: "No such intent in the catalogue.",
+    journal: "The journal has a bruise on this topic:",
+    journalWhy: "A recorded bruise means the proof for a new entry already exists.",
+    howTitle: "How to add your own gate:",
+    how1: "Name the failure.",
+    how1What: "What concrete defect it caught in a live project, and what that cost.",
+    how1Why: '"It is a good practice" is not accepted: that is how a catalogue collects hundreds of entries and dies.',
+    how2: "Create the folder",
+    how2What: "— gate.yml, red/, green/, README.md.",
+    how2Why: "The full entry format is in kit/gates/README.md",
+    how3: "Check it by machine:",
+    how3Why: "The arbiter must go red on red/ and stay quiet on green/. It did not — it is not an entry.",
+    how4: "Send it as a change",
+    how4What: "to the kit repository.",
+  },
+
+  why: {
+    needQuery: (cmd) => `Describe what slipped through: ${cmd}`,
+    example: 'why "a file grew to nine thousand lines"',
+    ciAtOnce: "all at once: doctor --run",
+    ciOwnStep: "as its own step",
+    unsure: "No confident match. These entries look close:",
+    unsureByName: (cmd) => `Name the entry directly: ${cmd}`,
+    unsureNone: (cmd) => `None of them fits — then there was no guard: ${cmd}`,
+    decideTitle: "The rest is your call:",
+    decideQ: "is this specific to you, or a general case?",
+    decideWhy: "General goes into the catalogue and reaches everyone. Specific stays with you.",
+    decideNote: (cmd) => `Either way, the lesson goes into the shared journal: ${cmd}`,
+    fix: "Fix it like this:",
+    noGuard: "There was no guard.",
+    noGuardWhy: "No entry in the catalogue carries this intent.",
+    noGuardFix: (cmd) => `create an entry — ${cmd}`,
+    noGuardHint: "Take the red sample straight from this failure: it already happened, nothing to invent.",
+    closest: (slug, pct) => `Closest catalogue entry: ${slug}  ${pct}% match`,
+    notInstalled: "The guard exists in the catalogue but is not installed in this project.",
+    notInstalledHint1: "It will go red on old code — that is normal: the old is covered by a ratchet,",
+    notInstalledHint2: (cmd) => `the new is caught from day one. ${cmd}`,
+    declaredAs: (cmd) => `Declared as: ${cmd}`,
+    notRunning: "The guard is declared but does not run.",
+    notRunningWhy: "The worst case: silence reads as success.",
+    notRunningFix: "the path or the program in the command does not exist — check them.",
+    notRunningHint: 'A missing signal is indistinguishable from success, so this is not "a small config detail".',
+    bypassed: "The guard exists and catches this failure — so it was bypassed.",
+    noCiFix: "there is no pipeline. A check only a human runs",
+    noCiHint: 'works right up until the first "forgot".',
+    notInCiFix: "a pipeline exists, but this gate does not run in it.",
+    notInCiHint: (cmd) => `The cheapest way is one step: ${cmd} — it runs everything declared.`,
+    inCiFix: (how) => `the pipeline does run it (${how}) — so a red run`,
+    inCiHint1: "was skipped or overridden. Move the rule out of prose and into mechanics:",
+    inCiHint2: "a blocking step, not an optional one; no merging while red.",
+    blind: "The guard exists, is installed and runs — but does not see this failure.",
+    blindFix: (dir) => `put a piece of the broken code into ${dir}`,
+    blindHint1: "and drive the check to red on it. The order is the reverse of the habit: the sample",
+    blindHint2: "first, the fix second — otherwise it is unclear what exactly got fixed.",
+    blindCheck: "Verify after the fix: bash tool/selfcheck/gates.sh",
+  },
+
+  init: {
+    noDocs: (dir) => `Guides not found: ${dir}\nLooks like the package is not fully installed.`,
+    created: (n) => `created (${n}):`,
+    andMore: (n) => `… and ${n} more`,
+    kept: (n) => `already there, left untouched (${n}):`,
+    overwrite: (cmd) => `overwrite: ${cmd}`,
+    nextTitle: "What to do next, in order:",
+    n1a: "Open",
+    n1b: 'and fill in the "Commands" section. A command you cannot',
+    n1c: "copy and run is not a command, it is a wish.",
+    n2a: "Read",
+    n2b: "— it is the minimum a project needs,",
+    n2c: "independent of language. Go through it top to bottom and mark what is missing.",
+    n3a: "Fill in",
+    n3b: "— gates, samples, journal. Your AQK level",
+    n3c: (cmd) => `is computed from it: ${cmd}.`,
+    n4a: "Climb the levels",
+    n4b: "one at a time",
+    n4c: ". A gate guards an artefact that exists:",
+    n4d: "a check for code that is not written yet is a dead rule.",
+    burned: (cmd) => `Got burned by something — write it down: ${cmd}`,
+  },
+
+  feedback: {
+    title: "If this was useful:",
+    star: (url) => `Star it — ${url}`,
+    issue: "Found a bug or it did not fit — open an issue; both are the most useful feedback there is.",
+    once: "This message is shown once: it will not appear again on this machine.",
+  },
+
+  note: {
+    journalTitle: "Bruise journal",
+    needTitle: (cmd) => `A title is required: ${cmd}`,
+    noJournal: (url) => `No journal clone found.\nDo this once:\n  git clone ${url}.git ~/projects/aqk\nor point at it: export AQK_HOME=/path/to/aqk`,
+    journalMissing: (path) => `Journal not found: ${path}`,
+    emptyBody: `The entry body is empty. Pass it on standard input, for example:\n\n  aqk note "title" <<'EOF'\n  **What happened.** ...\n  **What it cost.** ...\n  **Conclusion.** 🔧 ...\n  EOF`,
+    noOutcome:
+      "The entry carries no decision mark. A lesson without a conclusion is a story, not a lesson.\n" +
+      "Add one of the three:\n" +
+      "  ✅ **Became a gate:** <catalogue entry name>\n" +
+      "  🔧 **Became a change to the tooling:** <what exactly changed>\n" +
+      "  👤 **Will not become a gate:** <why>",
+    unknownProject: "unknown",
+    projectField: "Project",
+    pushed: (title) => `Recorded and pushed: ${title}`,
+    localOnly: (cmd) => `Recorded locally, the push failed. Push it: ${cmd}`,
+  },
+
+  blob: {
+    noDocs: (dir) => `Guides not found: ${dir}`,
+    header: (stamp) =>
+      `<!-- ASSEMBLED BY aqk blob ${stamp} from kit/docs. Do not edit by hand:\n` +
+      `     the next assembly overwrites it. The source is the separate files. -->\n\n` +
+      `# AQK — the guides in one file\n`,
+    source: (path) => `source: ${path}`,
+    done: (n, kb) => `GOD_AI.md — ${n} files, ${kb} KB`,
+    rebuilt: "Reassembled by every run. Edit the originals in kit/docs.",
+  },
+
+  start: {
+    initFailed: (cmd) => `Could not lay out the kit. Start with ${cmd}`,
+    tooManyFiles: (n) => `This repository already has ${n} code files — that is a different scenario.`,
+    useDoctor: (cmd) => `${cmd} will inspect what is here and split the entries into three lists:`,
+    threeLists: "held by a machine · applicable but not installed · not applicable, and why.",
+    anyway: (cmd) => `Install the day-zero guards anyway: ${cmd}`,
+    expectRed: "Expect red: a guard installed onto living code goes red across all of it.",
+    expectRedFix: (cmd) => `That is cured by a ratchet — ${cmd} — not by switching it off.`,
+    installed: (n) => `Day-zero guards installed: ${n}`,
+    noDebt1: "There is no debt: on an empty project they have nothing to let through. The same guard,",
+    noDebt2: "installed six months later, would go red on all the old code — and be switched off.",
+    allDeclared: "Every applicable entry is already declared.",
+    notYet: "Not applicable yet:",
+    notYetWhy: "Once the sign appears, the entry shows up on its own.",
+    orderTitle: "The order people actually do this in:",
+    o1: "The task, in words.",
+    o1What: "What, and for whom, without a single technical term.",
+    o1Why: "Until the task is described in words, any architecture protects who knows what.",
+    o2: "Constraints.",
+    o2What: "Deadlines, money, load, what you are not allowed to use.",
+    o2Why: "Constraints pick the solution far more often than taste does: without them, taste picks.",
+    o3: "Sizing.",
+    o3What: "How much data, how many requests, how many people — in numbers, at least an order of magnitude.",
+    o3Why: 'A number separates "we need a queue" from "a table is enough". Without it, people argue in words.',
+    o4: "Architecture.",
+    o4What: "And only now — out of the first three, not before them.",
+    softNote1: "The program does not check this order: it lives in .aqk/docs/, and an agent can",
+    softNote2: "ignore it. The machine holds something else — the guards above. The difference between",
+    softNote3: "soft and hard is exactly this: text is asked for, a command is executed.",
+    next: "Next:",
+    nextWhy: "— run everything that is declared",
+  },
+
+  manifestDoc: {
+    head: [
+      "# .aqk.yml — the Agent Quality Kit manifest",
+      "# What this is: a machine-readable description of how agents live in this repository.",
+      "# `aqk doctor` computes the compliance level. An empty field = the level is not reached,",
+      "# and that is honest: filling it with placeholders is pointless, files are checked, not words.",
+    ],
+    entry: "# AQK-0 — what the agent reads first.",
+    rules: "# AQK-1 — where the standards are and which checks are mandatory.",
+    gates: [
+      "  # name: a command returning 0 or non-zero. An empty declaration protects nothing and is",
+      '  # rejected by the "a declared gate runs" check — hence examples here, not placeholders.',
+      '  #   lint: "ruff check ."',
+      '  #   test: "pytest -q"',
+      "  # To install a ready entry from the catalogue together with its samples: aqk add <name>",
+    ],
+    samples: [
+      "# AQK-2 — what proves the gates work, and where the debt registries are.",
+      "# samples: the directory with red and green samples (a gate must go red on the first and",
+      "# stay quiet on the second). ratchets: lists of known violations that may only get",
+      "# shorter.",
+    ],
+    lessons: "# AQK-3 — where lessons accumulate. A path or an address.",
+  },
+
+  badge: {
+    noManifest: (cmd) => `No .aqk.yml — there is no level yet. Start with ${cmd}`,
+    notReached: (cmd) => `AQK-0 is not reached — there is nothing to put on a badge. What is missing: ${cmd}`,
+    redGates: (n, names) =>
+      `Red gates: ${n} (${names}). A badge issued over a red gate is the author's claim, not a machine's fact.`,
+    hint: (n) => `Proven by a run: ${n} gates, all green. Paste the line above into your README.`,
+    keepTrue: (cmd) => `To keep the badge from turning into a lie, put this in your pipeline: ${cmd}`,
+    checkMissing: (places) => `No AQK badge in any of: ${places}. This is the line to paste:`,
+    checkMismatch: (where, level) => `The badge lies: ${where}, while the run says AQK-${level}. Replace it with:`,
+    checkOk: (level, where) => `Badge matches the run: AQK-${level} — ${where}`,
+  },
+
+  report2: {
+    title: "AQK report",
+    noManifest: (cmd) => `No .aqk.yml — nothing to report on. Start with ${cmd}`,
+    level: "Level",
+    holdsTitle: "What a machine holds (from a run, not from the manifest)",
+    nothingRuns: "⬜ no gate is declared",
+    native: (prog) => `native recipe: ${prog}`,
+    portable: "portable check",
+    weakerTitle: "Weaker than it could be",
+    weaker: (progs) => `${progs} is available on this system, but the gate uses the portable check — it catches less`,
+    missingTitle: "What is missing",
+    nothingMissing: "✅ every applicable entry is installed",
+    needsTool: (prog) => `needs ${prog} — not on this system`,
+    notInstalled: "applicable, but not installed",
+    hiddenTitle: "Not applicable to this repository",
+    readTitle: "What the kit told you to read",
+    readWarn:
+      "The mark only means the file is on disk. Whether it was read, the machine does not know " +
+      "and does not pretend to: that is answered by whoever is reporting.",
+    ignoreTitle: "What .aqkignore hides",
+    ignoreNone: "no .aqkignore file — nothing is hidden",
+    ignoreWarn:
+      "Hiding things silently is the same class as a silent gate: the gates do not look at these " +
+      "paths at all. A line here means there is no protection there, and will not be.",
+    whyTitle: "Why this matters — briefly",
+    whyNothing: "nothing to add: everything applicable is in place",
+    saved: (path) => `Saved: ${path}`,
+    docs: {
+      baseline: "the minimum a project needs, independent of language",
+      readyMade: "the map of off-the-shelf rules: look for a ready one before writing your own",
+      rulesGeneral: "general working rules",
+      rulesTesting: "rules about tests",
+      rulesSecurity: "rules about security",
+    },
+  },
+
+  levels: [
+    {
+      title: "a manifest and an entry point",
+      need: "create .aqk.yml and point entry at the file an agent reads first (AGENTS.md)",
+      gives: "any tool understands what to read in this repository",
+    },
+    {
+      title: "rules and working gates",
+      need: "set rules (the standards directory) and fill at least one gate in gates with a real command",
+      gives: "checks are declared as commands, not described in prose",
+    },
+    {
+      title: "gates are proven, debt is under a ratchet",
+      need: "set samples (red and green gate samples) and ratchets (debt registries)",
+      gives: "the gate has proven it catches defects and stays quiet on correct code",
+    },
+    {
+      title: "lessons come back into the work",
+      need: "set lessons — the path or address of a journal where every incident yields a conclusion",
+      gives: "the project learns: the same bruise is not collected twice",
+    },
+  ],
+
+  report: {
+    title: "aqk doctor --run",
+    version: "version",
+    level: "level",
+    summary: (ok, all) => `total: ${ok} of ${all} green`,
+  },
+};

package/tool/i18n/index.mjs

@@ -0,0 +1,33 @@
+// tool/i18n/index.mjs — выбор языка вывода.
+//
+// ЗАЧЕМ. Комплект ставят из npm, площадка англоязычная. Русский вывод отсекает тех, кто мог бы
+// им пользоваться; английский по умолчанию отсекал бы автора. Поэтому язык выбирается, а не
+// назначается.
+//
+// ЧТО ПЕРЕВОДИТСЯ, А ЧТО НЕТ. Переводится то, что печатается человеку. Комментарии в коде
+// остаются русскими: они для того, кто правит программу, а не для того, кто ею пользуется.
+//
+// ПОЧЕМУ КАТАЛОГ, А НЕ СТРОКИ ПО МЕСТУ. Два языка вперемешку в коде команд читаются вдвое
+// хуже и расходятся молча. Каталоги лежат отдельно, и модульная проверка сверяет, что в них
+// одни и те же ключи: «поддерживаем два языка» — утверждение, которое обязана держать машина.
+
+import { ru } from "./ru.mjs";
+import { en } from "./en.mjs";
+
+// Порядок: явная переменная окружения → системная локаль → английский. Английский последним
+// потому, что незнакомый язык интерфейса — это препятствие, а незнакомый английский в 2026-м
+// препятствие меньшее, чем незнакомая кириллица.
+function pickLang(env = process.env) {
+  const forced = String(env.AQK_LANG || "").toLowerCase();
+  if (forced.startsWith("ru")) return "ru";
+  if (forced.startsWith("en")) return "en";
+  const locale = String(env.LC_ALL || env.LC_MESSAGES || env.LANG || "").toLowerCase();
+  if (locale.startsWith("ru")) return "ru";
+  return "en";
+}
+
+const CATALOGS = { ru, en };
+const LANG = pickLang();
+const L = CATALOGS[LANG];
+
+export { L, LANG, pickLang, CATALOGS };