@git8n/cli 0.0.0-stage → 0.1.0

package/dist/git8n.js

@@ -0,0 +1,1769 @@
+#!/usr/bin/env node
+
+// ../mcp/src/cli/node.ts
+import { execFile, spawn } from "node:child_process";
+import { readdir, readFile as readFile2 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { promisify } from "node:util";
+
+// ../mcp/src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../mcp/src/api.ts
+var ApiError = class extends Error {
+  status;
+  // Written out rather than as a parameter property: Node runs this file with
+  // `--experimental-strip-types`, which removes types and rewrites nothing, and
+  // a parameter property is syntax it refuses.
+  constructor(message, status) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+  }
+};
+var ask = async (config, path, body, method) => {
+  const response = await (config.fetch ?? fetch)(`${config.url}${path}`, {
+    method: method ?? (body === void 0 ? "GET" : "POST"),
+    signal: AbortSignal.timeout(60 * 1e3),
+    ...config.token === void 0 ? { credentials: "include" } : {},
+    headers: {
+      ...config.token === void 0 ? {} : { Authorization: `Bearer ${config.token}` },
+      Accept: "application/json",
+      ...body === void 0 ? {} : { "Content-Type": "application/json" }
+    },
+    ...body === void 0 ? {} : { body: JSON.stringify(body) }
+  });
+  if (!response.ok) {
+    const said = await response.text().catch(() => "");
+    throw new ApiError(said || `${path} answered ${response.status}`, response.status);
+  }
+  return (await response.json()).data;
+};
+var repositories = (config) => ask(config, "/i18n/repositories");
+var rightsOf = (config) => ask(config, "/i18n/me");
+var catalogue = (config, repository, language2) => ask(
+  config,
+  `/i18n/catalogue?repository=${encodeURIComponent(repository)}&language=${encodeURIComponent(language2)}`
+);
+var waiting = (config, repository, language2) => ask(
+  config,
+  `/i18n/proposals?repository=${encodeURIComponent(repository)}&language=${encodeURIComponent(language2)}`
+);
+var propose = (config, batch) => ask(config, "/i18n/proposals", batch);
+var progress = (config, repository) => ask(config, `/i18n/progress?repository=${encodeURIComponent(repository)}`);
+var overview = (config, query = {}) => {
+  const params = new URLSearchParams();
+  if (query.page) params.set("page", String(query.page));
+  if (query.perPage) params.set("perPage", String(query.perPage));
+  if (query.q) params.set("q", query.q);
+  if (query.sort) params.set("sort", query.sort);
+  if (query.order) params.set("order", query.order);
+  if (query.progress) params.set("progress", query.progress);
+  const search = params.toString();
+  return ask(config, `/i18n/overview${search ? `?${search}` : ""}`);
+};
+
+// ../mcp/src/tools.ts
+import { z } from "zod";
+var fileName = z.string().regex(/^[A-Za-z0-9_-]+$/, "A file is a name such as common, not a path");
+var language = z.string().regex(/^[A-Za-z0-9_-]+$/, "A language is a tag such as fr or pt-BR");
+var PAGE = 200;
+var languageSchema = {
+  repository: z.string().min(1).describe("The repository to read, from i18n_repositories."),
+  language: language.describe("The language to read, which the repository must translate into.")
+};
+var listSchema = {
+  ...languageSchema,
+  state: z.enum(["missing", "review", "translated", "all"]).default("missing").describe(
+    "Which keys to answer. `missing` is what there is work on. `review` is a translation whose source changed: `was` holds the old source."
+  ),
+  file: fileName.optional().describe("Only the keys of this file, for example `common`."),
+  offset: z.number().int().min(0).default(0).describe("Where to start, for a catalogue past one answer.")
+};
+var readSchema = {
+  ...languageSchema,
+  file: fileName,
+  key: z.string().min(1).describe("The dotted path of the key, as i18next reads it.")
+};
+var proposeSchema = {
+  ...languageSchema,
+  readAt: z.string().regex(/^[0-9a-f]{40}$/, "The `commit` of the listing this batch answers").describe(
+    "The `commit` the keys were read at, taken from i18n_keys or i18n_key. Every page of one listing answers the same one. It is what lets a publication refuse a key whose source moved since \u2014 never invent one, and never mix the values of two listings in one call."
+  ),
+  values: z.array(
+    z.object({
+      file: fileName,
+      key: z.string().min(1),
+      value: z.string(),
+      empty: z.boolean().optional().describe(
+        'true leaves the key empty on purpose in this language, with value "". Use it only when the source asks for no text in this language, never to skip a key. A key sent without it loses its mark.'
+      )
+    })
+  ).min(1).max(2e3).describe(
+    "The whole batch. One call is one commit, so three hundred keys are three hundred keys, not three hundred commits."
+  )
+};
+var answer = (value) => ({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }] });
+var HELD_MS = 5 * 60 * 1e3;
+var createCatalogues = () => {
+  const held = /* @__PURE__ */ new Map();
+  const reading = /* @__PURE__ */ new Map();
+  return {
+    read: async (config, repository, language2, now) => {
+      const key = `${repository}:${language2}`;
+      const hit = held.get(key);
+      if (hit && now - hit.at < HELD_MS) return hit.value;
+      const shared = reading.get(key);
+      if (shared) return shared;
+      const started = catalogue(config, repository, language2).then((value) => {
+        held.set(key, { at: now, value });
+        return value;
+      }).finally(() => {
+        if (reading.get(key) === started) reading.delete(key);
+      });
+      reading.set(key, started);
+      return started;
+    },
+    clear: () => {
+      held.clear();
+      reading.clear();
+    }
+  };
+};
+var disabledIn = (read) => Object.entries(read.files ?? {}).filter(([, state]) => state === "disabled").map(([file]) => file).sort();
+var matching = (entries, state, file) => entries.filter((entry) => (state === "all" || entry.state === state) && (file === void 0 || entry.file === file));
+var listKeys = async (config, input, held, now = Date.now()) => {
+  const read = await held.read(config, input.repository, input.language, now);
+  const found = matching(read.entries, input.state, input.file);
+  const page = found.slice(input.offset, input.offset + PAGE);
+  return answer({
+    // The revision the values were read at. A proposal carries it back.
+    commit: read.commit,
+    source: read.source,
+    language: read.language,
+    total: found.length,
+    offset: input.offset,
+    returned: page.length,
+    // Said plainly rather than left to be worked out from three numbers.
+    more: input.offset + page.length < found.length,
+    // An agent that sees no key of a file must not read « fully translated ».
+    // A proposal on one of these files is refused.
+    filesWithNoVersion: disabledIn(read),
+    entries: page
+  });
+};
+var readKey = async (config, input, held, now = Date.now()) => {
+  const read = await held.read(config, input.repository, input.language, now);
+  const found = read.entries.find((entry) => entry.file === input.file && entry.key === input.key);
+  if (disabledIn(read).includes(input.file)) {
+    return answer({
+      found: false,
+      reason: `${input.file} has no ${input.language} version, and takes no proposal.`
+    });
+  }
+  if (!found) {
+    return answer({
+      found: false,
+      reason: `${input.file}.${input.key} is not a key of the source of ${input.language}.`
+    });
+  }
+  return answer({ found: true, commit: read.commit, source: read.source, entry: found });
+};
+var proposeBatch = async (config, input) => answer(await propose(config, input));
+var listRepositories = async (config) => answer(await repositories(config));
+var whoAmI = async (config) => answer(await rightsOf(config));
+var listProposals = async (config, input) => answer(await waiting(config, input.repository, input.language));
+
+// ../mcp/src/server.ts
+var answering = (run2) => run2().catch((error) => {
+  const said = error instanceof ApiError ? `${error.status} \u2014 ${error.message}` : String(error);
+  return { isError: true, content: [{ type: "text", text: said }] };
+});
+var buildServer = (config) => {
+  const server = new McpServer({ name: "git8n", version: "0.1.0" });
+  const held = createCatalogues();
+  server.registerTool(
+    "i18n_repositories",
+    {
+      title: "The repositories to translate",
+      description: "Which repositories the editor translates, their source language and their targets.",
+      inputSchema: {}
+    },
+    () => answering(() => listRepositories(config))
+  );
+  server.registerTool(
+    "i18n_me",
+    {
+      title: "What this token may do",
+      description: "The repositories where this account is a member, and in each one its role, the languages it may propose in, and whether it writes the source. A translator writes proposals and does not publish. A reviewer or an owner also publishes.",
+      inputSchema: {}
+    },
+    () => answering(() => whoAmI(config))
+  );
+  server.registerTool(
+    "i18n_keys",
+    {
+      title: "The keys of a language",
+      description: "Every key of the source beside what one language says about it, filtered by state and by file. The answer carries the `commit` the values were read at; a proposal takes it back.",
+      inputSchema: listSchema
+    },
+    (input) => answering(() => listKeys(config, input, held))
+  );
+  server.registerTool(
+    "i18n_key",
+    {
+      title: "One key, with its context",
+      description: "One key: what the source says, what the target says, and its state. The file and the dotted path are the context \u2014 `analysis.requests_export_hint` says what the string is for, and a translation without it is a wrong translation.",
+      inputSchema: readSchema
+    },
+    (input) => answering(() => readKey(config, input, held))
+  );
+  server.registerTool(
+    "i18n_propose",
+    {
+      title: "Propose a batch of translations",
+      description: "Writes a whole batch as one commit on the branch of its language. Three hundred keys are one commit, not three hundred. Nothing is published: a reviewer does that.",
+      inputSchema: proposeSchema
+    },
+    (input) => answering(() => proposeBatch(config, input))
+  );
+  server.registerTool(
+    "i18n_proposals",
+    {
+      title: "What is waiting on a language",
+      description: "The batches the branch of a language holds and the base does not, with who wrote each one.",
+      inputSchema: languageSchema
+    },
+    (input) => answering(() => listProposals(config, input))
+  );
+  return server;
+};
+var serveOverStdio = (config) => buildServer(config).connect(new StdioServerTransport());
+
+// ../mcp/src/cli/run.ts
+import { isAbsolute, join as join3 } from "node:path";
+import { parseArgs } from "node:util";
+
+// ../mcp/src/cli/check.ts
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+var RULES = {
+  "invalid-json": { severity: "error", title: "The file is not a JSON object." },
+  "invalid-manifest": { severity: "error", title: "The manifest is not valid." },
+  "not-a-string": { severity: "error", title: "A value is not a string or an object." },
+  placeholders: { severity: "error", title: "The translation does not keep the placeholders of the source." },
+  "missing-key": { severity: "warning", title: "A key of the source has no translation." },
+  "empty-value": { severity: "warning", title: "A translation is empty, and the manifest does not mark it." },
+  "stale-empty": { severity: "warning", title: "A key is empty on purpose, but its source changed since." },
+  "empty-source": { severity: "warning", title: "A text of the source is empty." },
+  "extra-key": { severity: "warning", title: "A key is not in the source." },
+  "extra-file": { severity: "warning", title: "A file has no version in the source." },
+  "skipped-file": { severity: "warning", title: "The editor leaves out a file with this name." }
+};
+var CheckSetupError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CheckSetupError";
+  }
+};
+var LOCALES_GUESSES = ["locales", "src/locales", "public/locales", "src/i18n/locales", "i18n"];
+var FILE_NAME = /^[A-Za-z0-9_-]+$/;
+var sourceHashOf = (text) => createHash("sha256").update(text, "utf8").digest("hex").slice(0, 12);
+var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var pathsOf = (node, prefix = "") => Object.entries(node).flatMap(([key, value]) => {
+  const path = prefix ? `${prefix}.${key}` : key;
+  return isObject(value) ? pathsOf(value, path) : [[path, value]];
+});
+var groupAt = (text, open) => {
+  let depth = 0;
+  for (let at = open; at < text.length; at += 1) {
+    if (text[at] === "{") depth += 1;
+    if (text[at] === "}") depth -= 1;
+    if (depth === 0) return { inner: text.slice(open + 1, at), end: at + 1 };
+  }
+  return null;
+};
+var ICU_CHOICE = /\{\s*[A-Za-z_][\w.]*\s*,\s*(?:plural|select|selectordinal)\s*,/;
+var I18NEXT_GROUP = /^\{\s*([^{},]+?)\s*(?:,[^{}]*)?\}$/;
+var ICU_ARGUMENT = /^\s*([A-Za-z_][\w.]*)\s*(?:,\s*(plural|select|selectordinal)\s*,([\s\S]*))?(?:,[^{}]*)?$/;
+var addIcuArguments = (text, found) => {
+  for (let at = text.indexOf("{"); at !== -1; at = text.indexOf("{", at)) {
+    const group = groupAt(text, at);
+    if (!group) return;
+    const argument = ICU_ARGUMENT.exec(group.inner);
+    const interpolation = I18NEXT_GROUP.exec(group.inner);
+    if (interpolation) {
+      found.add(`{{${interpolation[1]}}}`);
+    } else if (argument) {
+      found.add(`{${argument[1]}}`);
+      if (argument[2]) {
+        const branches = argument[3].replace(/^\s*offset:\s*\d+/, "");
+        for (let open = branches.indexOf("{"); open !== -1; open = branches.indexOf("{", open)) {
+          const branch = groupAt(branches, open);
+          if (!branch) break;
+          addIcuArguments(branch.inner, found);
+          open = branch.end;
+        }
+      }
+    }
+    at = group.end;
+  }
+};
+var placeholdersOf = (text) => {
+  const found = /* @__PURE__ */ new Set();
+  let rest = text;
+  if (!ICU_CHOICE.test(rest)) {
+    rest = rest.replace(/\{\{\s*([^{},]+?)\s*(?:,[^{}]*)?\}\}/g, (_, name) => {
+      found.add(`{{${name}}}`);
+      return " ";
+    });
+  }
+  rest = rest.replace(/\$t\([^)]*\)/g, (match) => {
+    found.add(match.replace(/\s+/g, ""));
+    return " ";
+  });
+  addIcuArguments(rest, found);
+  for (const match of rest.matchAll(/<\/?([A-Za-z0-9][\w-]*)\s*\/?>/g)) found.add(match[0].replace(/\s+/g, ""));
+  for (const match of rest.matchAll(/%(?:\d+\$)?[sdif]/g)) found.add(match[0]);
+  return [...found].sort();
+};
+var parseManifest = (text) => {
+  const raw = JSON.parse(text);
+  if (!isObject(raw)) throw new Error("it is not a JSON object");
+  const states = /* @__PURE__ */ new Map();
+  const marks = /* @__PURE__ */ new Map();
+  const issues = [];
+  if (raw.source !== void 0 && (typeof raw.source !== "string" || raw.source === "")) {
+    throw new Error('"source" is not a language');
+  }
+  for (const [file, byLanguage] of Object.entries(isObject(raw.files) ? raw.files : {})) {
+    for (const [language2, state] of Object.entries(isObject(byLanguage) ? byLanguage : {})) {
+      if (state !== "available" && state !== "partial" && state !== "disabled") {
+        issues.push(`files.${file}.${language2} is not available, partial or disabled`);
+        continue;
+      }
+      states.set(`${language2}
+${file}`, state);
+    }
+  }
+  for (const [language2, byName] of Object.entries(isObject(raw.empty) ? raw.empty : {})) {
+    for (const [name, mark] of Object.entries(isObject(byName) ? byName : {})) {
+      if (isObject(mark) && typeof mark.source === "string") marks.set(`${language2}
+${name}`, mark.source);
+    }
+  }
+  return { source: raw.source, states, marks, issues };
+};
+var PLURAL_FORMS = ["zero", "one", "two", "few", "many", "other"];
+var pluralOf = (key) => {
+  const match = /^(.+)_(zero|one|two|few|many|other)$/.exec(key);
+  return match ? { base: match[1], form: match[2] } : null;
+};
+var pluralFormsOf = (language2, fallback) => {
+  try {
+    const forms = new Intl.PluralRules(language2).resolvedOptions().pluralCategories;
+    return PLURAL_FORMS.filter((form) => forms.includes(form));
+  } catch {
+    return fallback;
+  }
+};
+var COUNT = /* @__PURE__ */ new Set(["{{count}}", "{count}"]);
+var sameList = (a, b) => a.length === b.length && a.every((item, index) => item === b[index]);
+var describeDifference = (source, target) => {
+  const lost = source.filter((item) => !target.includes(item));
+  const added = target.filter((item) => !source.includes(item));
+  return [lost.length > 0 ? `lost ${lost.join(" ")}` : "", added.length > 0 ? `added ${added.join(" ")}` : ""].filter(Boolean).join(", ");
+};
+var checkLocales = async (options, reader) => {
+  const problems = [];
+  const report = (problem) => problems.push({ ...problem, severity: RULES[problem.rule].severity });
+  const summarize = (counts) => ({
+    ...counts,
+    errors: problems.filter((problem) => problem.severity === "error").length,
+    warnings: problems.filter((problem) => problem.severity === "warning").length,
+    problems
+  });
+  let locales = options.locales;
+  let folders = null;
+  if (locales === null) {
+    for (const guess of LOCALES_GUESSES) {
+      folders = await reader.readDir(guess);
+      if (folders !== null) {
+        locales = guess;
+        break;
+      }
+    }
+    if (locales === null) {
+      throw new CheckSetupError(`No folder of locales: pass --locales. Tried ${LOCALES_GUESSES.join(", ")}.`);
+    }
+  } else {
+    folders = await reader.readDir(locales);
+    if (folders === null) throw new CheckSetupError(`${locales} is not a folder.`);
+  }
+  const manifestPath = options.manifest ?? join(locales, "manifest.json");
+  const manifestText = await reader.readFile(manifestPath);
+  let manifest = { states: /* @__PURE__ */ new Map(), marks: /* @__PURE__ */ new Map() };
+  if (manifestText === null && options.manifest !== null) throw new CheckSetupError(`${manifestPath} does not exist.`);
+  if (manifestText !== null) {
+    const invalid = (reason) => report({
+      rule: "invalid-manifest",
+      path: manifestPath,
+      language: "",
+      key: null,
+      message: `${manifestPath} is not a manifest: ${reason}.`
+    });
+    try {
+      const { issues, ...read2 } = parseManifest(manifestText);
+      manifest = read2;
+      issues.forEach(invalid);
+    } catch (error) {
+      invalid(error.message);
+    }
+  }
+  const source = options.source ?? manifest.source;
+  if (!source && problems.length > 0) return summarize({ locales, source: "", languages: [], files: 0, keys: 0 });
+  if (!source) throw new CheckSetupError('No source language: pass --source, or name "source" in the manifest.');
+  if (options.source && manifest.source && options.source !== manifest.source) {
+    throw new CheckSetupError(`--source is ${options.source}, and the manifest names ${manifest.source}.`);
+  }
+  const languageFolders = (folders ?? []).filter((entry) => entry.directory).map((entry) => entry.name);
+  if (!languageFolders.includes(source)) throw new CheckSetupError(`${join(locales, source)} is not a folder.`);
+  const languages = options.languages ?? languageFolders.filter((name) => name !== source).sort();
+  const missingFolders = languages.filter((language2) => !languageFolders.includes(language2));
+  if (missingFolders.length > 0) {
+    throw new CheckSetupError(`No folder for ${missingFolders.join(", ")} in ${locales}.`);
+  }
+  const pathOf = (language2, file) => join(locales, language2, `${file}.json`);
+  const filesOf = async (language2) => {
+    const names = [];
+    for (const entry of await reader.readDir(join(locales, language2)) ?? []) {
+      if (entry.directory || !entry.name.endsWith(".json")) continue;
+      const file = entry.name.slice(0, -".json".length);
+      if (FILE_NAME.test(file)) names.push(file);
+      else {
+        report({
+          rule: "skipped-file",
+          path: join(locales, language2, entry.name),
+          language: language2,
+          key: null,
+          message: `${entry.name}: a file name has only letters, digits, - and _.`
+        });
+      }
+    }
+    return names.sort();
+  };
+  const read = async (language2, file) => {
+    const path = pathOf(language2, file);
+    const text = await reader.readFile(path);
+    if (text === null) return /* @__PURE__ */ new Map();
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (error) {
+      report({ rule: "invalid-json", path, language: language2, key: null, message: error.message });
+      return null;
+    }
+    if (!isObject(parsed)) {
+      report({ rule: "invalid-json", path, language: language2, key: null, message: "The top of the file is not an object." });
+      return null;
+    }
+    const strings = /* @__PURE__ */ new Map();
+    for (const [key, value] of pathsOf(parsed)) {
+      if (typeof value === "string") strings.set(key, value);
+      else {
+        report({
+          rule: "not-a-string",
+          path,
+          language: language2,
+          key: `${file}:${key}`,
+          message: `${file}:${key} holds ${value === null ? "null" : Array.isArray(value) ? "an array" : typeof value}.`
+        });
+      }
+    }
+    return strings;
+  };
+  const sourceFiles = await filesOf(source);
+  const sources = /* @__PURE__ */ new Map();
+  let files = sourceFiles.length;
+  let keys = 0;
+  for (const file of sourceFiles) {
+    const strings = await read(source, file);
+    if (strings === null) continue;
+    sources.set(file, strings);
+    keys += strings.size;
+    for (const [key, text] of strings) {
+      if (text === "") {
+        report({
+          rule: "empty-source",
+          path: pathOf(source, file),
+          language: source,
+          key: `${file}:${key}`,
+          message: `${file}:${key} is empty in the source.`
+        });
+      }
+    }
+  }
+  for (const language2 of languages) {
+    const targetFiles = await filesOf(language2);
+    files += targetFiles.length;
+    for (const file of targetFiles.filter((name) => !sourceFiles.includes(name))) {
+      report({
+        rule: "extra-file",
+        path: pathOf(language2, file),
+        language: language2,
+        key: null,
+        message: `${file}.json has no version in ${source}.`
+      });
+    }
+    for (const file of sourceFiles) {
+      const sourceStrings = sources.get(file);
+      if (!sourceStrings || manifest.states.get(`${language2}
+${file}`) === "disabled") continue;
+      const path = pathOf(language2, file);
+      const target = targetFiles.includes(file) ? await read(language2, file) : /* @__PURE__ */ new Map();
+      if (target === null) continue;
+      const plurals = /* @__PURE__ */ new Map();
+      for (const [key, text] of sourceStrings) {
+        const plural2 = pluralOf(key);
+        if (plural2) plurals.set(plural2.base, (plurals.get(plural2.base) ?? /* @__PURE__ */ new Map()).set(plural2.form, text));
+      }
+      const sourceHasOneForm = pluralFormsOf(source, ["one", "other"]).length === 1;
+      for (const [base, forms] of plurals) {
+        if (!forms.has("other") || forms.size === 1 && !sourceHasOneForm) plurals.delete(base);
+      }
+      const checkKey = (key, text, form) => {
+        const id = `${file}:${key}`;
+        const value = target.get(key);
+        if (value === void 0) {
+          report({ rule: "missing-key", path, language: language2, key: id, message: `${id} has no ${language2} text.` });
+        } else if (value === "") {
+          const mark = manifest.marks.get(`${language2}
+${id}`);
+          if (mark === void 0) {
+            report({ rule: "empty-value", path, language: language2, key: id, message: `${id} is empty in ${language2}.` });
+          } else if (mark !== sourceHashOf(text)) {
+            report({
+              rule: "stale-empty",
+              path,
+              language: language2,
+              key: id,
+              message: `${id} is empty on purpose in ${language2}, but its ${source} text changed since.`
+            });
+          }
+        } else {
+          const implicitCount = form !== null && form !== "other";
+          const expected = placeholdersOf(text).filter((item) => !implicitCount || !COUNT.has(item));
+          const found = placeholdersOf(value).filter((item) => !implicitCount || !COUNT.has(item));
+          if (!sameList(expected, found)) {
+            report({
+              rule: "placeholders",
+              path,
+              language: language2,
+              key: id,
+              message: `${id}: ${describeDifference(expected, found)}.`
+            });
+          }
+        }
+      };
+      const allowed = new Set(sourceStrings.keys());
+      for (const [key, text] of sourceStrings) {
+        if (!plurals.has(pluralOf(key)?.base ?? "")) checkKey(key, text, null);
+      }
+      for (const [base, forms] of plurals) {
+        for (const form of pluralFormsOf(language2, [...forms.keys()])) {
+          allowed.add(`${base}_${form}`);
+          checkKey(`${base}_${form}`, forms.get(form) ?? forms.get("other"), form);
+        }
+      }
+      for (const key of target.keys()) {
+        if (!allowed.has(key)) {
+          report({
+            rule: "extra-key",
+            path,
+            language: language2,
+            key: `${file}:${key}`,
+            message: `${file}:${key} is not in ${source}.`
+          });
+        }
+      }
+    }
+  }
+  return summarize({ locales, source, languages, files, keys });
+};
+var REPORTERS = ["pretty", "json", "github"];
+var plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+var summaryOf = (report) => `${plural(report.errors, "error")}, ${plural(report.warnings, "warning")} in ${plural(report.files, "file")} (${report.source} \u2192 ${report.languages.join(", ") || "no language"}, ${plural(report.keys, "key")}).`;
+var prettyReport = (report) => {
+  const lines = [];
+  const byPath = /* @__PURE__ */ new Map();
+  for (const problem of report.problems) byPath.set(problem.path, [...byPath.get(problem.path) ?? [], problem]);
+  for (const [path, problems] of [...byPath].sort(([a], [b]) => a.localeCompare(b))) {
+    lines.push(path);
+    for (const problem of problems) {
+      lines.push(`  ${problem.severity === "error" ? "error  " : "warning"}  ${problem.message}  ${problem.rule}`);
+    }
+    lines.push("");
+  }
+  lines.push(summaryOf(report));
+  return `${lines.join("\n")}
+`;
+};
+var escapeData = (text) => text.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+var escapeProperty = (text) => escapeData(text).replace(/:/g, "%3A").replace(/,/g, "%2C");
+var githubReport = (report) => {
+  const lines = report.problems.map(
+    (problem) => `::${problem.severity} file=${escapeProperty(problem.path)},title=${escapeProperty(`i18n ${problem.rule}`)}::` + escapeData(problem.message)
+  );
+  lines.push(summaryOf(report));
+  return `${lines.join("\n")}
+`;
+};
+var failed = (report, maxWarnings) => report.errors > 0 || maxWarnings !== null && report.warnings > maxWarnings;
+
+// ../mcp/src/cli/credentials.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+
+// ../mcp/src/cli/errors.ts
+var EXIT = {
+  ok: 0,
+  /** The API refused, or a sign-in did not end. */
+  failed: 1,
+  /** A command, an option, a configuration or an input is wrong. */
+  usage: 2,
+  /** No account is signed in, or the API refused the token. */
+  signedOut: 3
+};
+var ERRORS = {
+  G8N1001: { exit: EXIT.usage, title: "The command or an option is wrong." },
+  G8N1002: { exit: EXIT.usage, title: "No address of the API: pass --api or set GIT8N_API_URL." },
+  G8N1003: { exit: EXIT.usage, title: "The input of apply is not valid." },
+  G8N1004: { exit: EXIT.usage, title: "The file of the credentials is not valid." },
+  G8N1005: { exit: EXIT.usage, title: "check cannot find the locales, the manifest or the source language." },
+  G8N2001: { exit: EXIT.signedOut, title: "No account is signed in, or the API refused the token." },
+  G8N2002: { exit: EXIT.failed, title: "The device code expired before somebody approved it." },
+  G8N2003: { exit: EXIT.failed, title: "The person refused the device code." },
+  G8N3001: { exit: EXIT.usage, title: "No repository matches." },
+  G8N3002: { exit: EXIT.usage, title: "The repository is not clear: pass --repo." },
+  G8N3003: { exit: EXIT.usage, title: "The language is not clear, or the account cannot open it: pass --lang." },
+  G8N3004: {
+    exit: EXIT.failed,
+    title: "A key is not a key of the source, or its file has no version in the language."
+  },
+  G8N4001: { exit: EXIT.failed, title: "The API refused the request." },
+  G8N4002: { exit: EXIT.failed, title: "The API failed, or did not answer." }
+};
+var CliError = class extends Error {
+  code;
+  exit;
+  /** More lines for a person: the repositories to choose from, the keys that are not there. */
+  details;
+  constructor(code, message, details = []) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.exit = ERRORS[code].exit;
+    this.details = details;
+  }
+};
+var messageOf = (said) => {
+  try {
+    const parsed = JSON.parse(said);
+    if (typeof parsed.message === "string") return parsed.message;
+  } catch {
+  }
+  return said;
+};
+var asCliError = (error) => {
+  if (error instanceof CliError) return error;
+  if (error instanceof ApiError) {
+    const message = `${error.status} \u2014 ${messageOf(error.message)}`;
+    if (error.status === 401) return new CliError("G8N2001", `${message}. Run git8n login.`);
+    return new CliError(error.status < 500 ? "G8N4001" : "G8N4002", message);
+  }
+  if (error instanceof Error) {
+    const cause = error.cause instanceof Error ? `: ${error.cause.code ?? error.cause.message}` : "";
+    return new CliError("G8N4002", `${error.message}${cause}`);
+  }
+  return new CliError("G8N4002", String(error));
+};
+
+// ../mcp/src/cli/credentials.ts
+var credentialsPath = (env, home) => join2(env.XDG_CONFIG_HOME || join2(home, ".config"), "git8n", "credentials.json");
+var readCredentials = async (path) => {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { servers: {} };
+    throw new CliError("G8N1004", `${path} cannot be read: ${error.message}`);
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.servers !== "object") throw new Error();
+    return parsed;
+  } catch {
+    throw new CliError("G8N1004", `${path} is not valid. Delete it, then run git8n login again.`);
+  }
+};
+var writeCredentials = async (path, credentials) => {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const next = `${path}.${process.pid}.tmp`;
+  await writeFile(next, `${JSON.stringify(credentials, null, 2)}
+`, { mode: 384 });
+  await chmod(next, 384);
+  await rename(next, path);
+};
+
+// ../mcp/src/cli/keys.ts
+var idOf = (entry) => `${entry.file}:${entry.key}`;
+var parseId = (id) => {
+  const colon = id.indexOf(":");
+  if (colon <= 0 || colon === id.length - 1) {
+    throw new CliError("G8N1001", `${id} is not a key. Name a key as <file>:<key>, for example common:hello.title.`);
+  }
+  return { file: id.slice(0, colon), key: id.slice(colon + 1) };
+};
+var disabledFilesOf = (read) => Object.entries(read.files ?? {}).filter(([, state]) => state === "disabled").map(([file]) => file).sort();
+var parentOf = (key) => key.slice(0, Math.max(key.lastIndexOf("."), 0));
+var neighboursOf = (read, entry, most = 5) => read.entries.filter(
+  (other) => other.file === entry.file && other.key !== entry.key && parentOf(other.key) === parentOf(entry.key)
+).slice(0, most);
+var pageOf = (rows, cursor, limit) => {
+  const page = rows.slice(cursor, cursor + limit);
+  return {
+    total: rows.length,
+    cursor,
+    nextCursor: cursor + page.length < rows.length ? cursor + page.length : null,
+    rows: page
+  };
+};
+var matchesText = (entry, text) => {
+  const wanted = text.toLowerCase();
+  return [idOf(entry), entry.source, entry.value ?? ""].some((field) => field.toLowerCase().includes(wanted));
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var flatten = (file, value, path, into) => {
+  if (typeof value === "string") {
+    if (!path) throw new CliError("G8N1003", `${file} holds a text and no key.`);
+    into.set(`${file}:${path}`, value);
+    return;
+  }
+  if (!isRecord(value)) {
+    throw new CliError("G8N1003", `${file}:${path} is not a text. A value is a string, or an object of keys.`);
+  }
+  for (const [name, inner] of Object.entries(value)) flatten(file, inner, path ? `${path}.${name}` : name, into);
+};
+var textsOf = (input, file) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    throw new CliError("G8N1003", `The input is not JSON: ${error.message}`);
+  }
+  if (!isRecord(parsed)) throw new CliError("G8N1003", "The input must be a JSON object of keys and texts.");
+  const texts = /* @__PURE__ */ new Map();
+  if (file) {
+    flatten(file, parsed, "", texts);
+  } else {
+    for (const [name, value] of Object.entries(parsed)) {
+      if (name.includes(":")) {
+        if (typeof value !== "string") throw new CliError("G8N1003", `${name} is not a text.`);
+        const { file: inFile, key } = parseId(name);
+        texts.set(`${inFile}:${key}`, value);
+      } else if (isRecord(value)) {
+        flatten(name, value, "", texts);
+      } else {
+        throw new CliError(
+          "G8N1003",
+          `${name} names no file. Write <file>:<key>, put the keys under their file, or pass --file.`
+        );
+      }
+    }
+  }
+  const blank = [...texts].filter(([, text]) => text.trim() === "").map(([id]) => id);
+  if (blank.length > 0) {
+    throw new CliError(
+      "G8N1003",
+      "An empty text is not a translation. To leave a key empty on purpose, mark it \xAB vide expr\xE8s \xBB in the editor.",
+      blank.slice(0, 10)
+    );
+  }
+  return texts;
+};
+var MOST_KEYS = 2e3;
+var planOf = (read, texts, readAt) => {
+  const disabled = new Set(disabledFilesOf(read));
+  const byId = new Map(read.entries.map((entry) => [idOf(entry), entry]));
+  const closed = [...texts.keys()].filter((id) => disabled.has(parseId(id).file));
+  const unknown = [...texts.keys()].filter((id) => !byId.has(id) && !disabled.has(parseId(id).file));
+  if (closed.length > 0) {
+    throw new CliError(
+      "G8N3004",
+      `These keys are in a file that has no ${read.language} version, and take no proposal.`,
+      closed.slice(0, 10)
+    );
+  }
+  if (unknown.length > 0) {
+    throw new CliError(
+      "G8N3004",
+      `${unknown.length} key(s) of the input are not keys of the source (${read.source}).`,
+      unknown.slice(0, 10)
+    );
+  }
+  const changes = [];
+  const unchanged = [];
+  const stillToReview = [];
+  for (const [id, to] of texts) {
+    const entry = byId.get(id);
+    if (entry.value !== to) changes.push({ id, file: entry.file, key: entry.key, from: entry.value, to });
+    else if (entry.state === "review") stillToReview.push(id);
+    else unchanged.push(id);
+  }
+  if (changes.length > MOST_KEYS) {
+    throw new CliError(
+      "G8N1003",
+      `${changes.length} keys are more than ${MOST_KEYS} in one proposal. Split the input.`
+    );
+  }
+  return { readAt, changes, unchanged, stillToReview };
+};
+var valuesOf = (plan) => plan.changes.map(({ file, key, to }) => ({ file, key, value: to }));
+
+// ../mcp/src/cli/login.ts
+var CLIENT_ID = "git8n-cli";
+var GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+var post = (io, url, body) => io.fetch(url, {
+  method: "POST",
+  headers: { "Content-Type": "application/json", Accept: "application/json" },
+  body: JSON.stringify(body),
+  signal: AbortSignal.timeout(30 * 1e3)
+});
+var askDeviceCode = async (io, api) => {
+  const response = await post(io, `${api}/api/auth/device/code`, { client_id: CLIENT_ID });
+  if (!response.ok) {
+    throw new CliError(
+      response.status < 500 ? "G8N4001" : "G8N4002",
+      `${response.status} \u2014 the API gave no device code: ${await response.text().catch(() => "")}`
+    );
+  }
+  return await response.json();
+};
+var waitForApproval = async (io, api, code) => {
+  const deadline = io.now() + code.expires_in * 1e3;
+  let interval = Math.max(code.interval, 1) * 1e3;
+  for (; ; ) {
+    if (io.now() >= deadline) throw new CliError("G8N2002", "The code expired. Run git8n login again.");
+    await io.sleep(interval);
+    const response = await post(io, `${api}/api/auth/device/token`, {
+      grant_type: GRANT,
+      device_code: code.device_code,
+      client_id: CLIENT_ID
+    });
+    const answered = await response.json().catch(() => ({}));
+    if (response.ok && answered.access_token) return answered.access_token;
+    switch (answered.error) {
+      case "authorization_pending":
+        continue;
+      case "slow_down":
+        interval += 5e3;
+        continue;
+      case "expired_token":
+        throw new CliError("G8N2002", "The code expired. Run git8n login again.");
+      case "access_denied":
+        throw new CliError("G8N2003", "The code was refused in the editor.");
+      default:
+        throw new CliError(
+          response.status < 500 ? "G8N4001" : "G8N4002",
+          `${response.status} \u2014 the API refused the device code: ${answered.error ?? "no reason"}`
+        );
+    }
+  }
+};
+var personOf = async (io, api, token) => {
+  const response = await io.fetch(`${api}/api/auth/get-session`, {
+    headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+    signal: AbortSignal.timeout(30 * 1e3)
+  }).catch(() => null);
+  if (!response?.ok) return null;
+  const session = await response.json().catch(() => null);
+  return session?.user ? { name: session.user.name, email: session.user.email } : null;
+};
+var signOut = async (io, api, token) => {
+  const response = await io.fetch(`${api}/api/auth/sign-out`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: "{}",
+    signal: AbortSignal.timeout(30 * 1e3)
+  }).catch(() => null);
+  return response?.ok ?? false;
+};
+
+// ../mcp/src/cli/prompt.ts
+var promptKeysOf = (read, entries) => entries.map((entry) => ({
+  id: idOf(entry),
+  source: entry.source,
+  ...entry.state === "review" ? { was: entry.was, value: entry.value } : {},
+  neighbours: neighboursOf(read, entry, 3).map((other) => ({
+    id: idOf(other),
+    source: other.source,
+    value: other.value
+  }))
+}));
+var quoted = (text) => text ? `\xAB ${text} \xBB` : "(none)";
+var translatePrompt = (args) => {
+  const { repository, read, keys } = args;
+  const lines = [
+    `# Translate ${repository} from ${read.source} to ${read.language}`,
+    "",
+    `You translate the texts of the interface of ${repository}. The source language is ${read.source}. The target language is ${read.language}.`,
+    "",
+    "Rules:",
+    "- Keep each placeholder as it is: {{name}}, {count}, <0>\u2026</0>, %s, $t(\u2026).",
+    "- Keep the tone and about the length of the source. A button stays short.",
+    "- The id of a key and its neighbours say where the text shows. Use them.",
+    "- Translate only the keys of this list.",
+    "",
+    `Revision of the source: ${read.commit}`,
+    "",
+    `## Keys (${keys.length} of ${args.total})`
+  ];
+  for (const key of keys) {
+    lines.push("", `### ${key.id}`, `Source: ${quoted(key.source)}`);
+    if (key.was !== void 0) {
+      lines.push(`The source was: ${quoted(key.was)}`, `The translation now: ${quoted(key.value)}`);
+    }
+    if (key.neighbours.length > 0) {
+      lines.push("Neighbours:");
+      for (const other of key.neighbours) {
+        lines.push(`- ${other.id}: ${quoted(other.source)} \u2192 ${quoted(other.value)}`);
+      }
+    }
+  }
+  lines.push(
+    "",
+    "## Answer",
+    "",
+    "Answer with one JSON object only: one entry for each key above, the id as the name and the translation as the value.",
+    "",
+    "```json",
+    JSON.stringify(Object.fromEntries(keys.slice(0, 2).map((key) => [key.id, "\u2026"])), null, 2),
+    "```",
+    "",
+    `Then send it with: git8n apply - --repo ${repository} --lang ${read.language} --read-at ${read.commit}`
+  );
+  if (args.nextCursor !== null) lines.push("", `More keys wait: add --cursor ${args.nextCursor} for the next ones.`);
+  return `${lines.join("\n")}
+`;
+};
+
+// ../mcp/src/cli/repository.ts
+var nameOf = (repository) => `${repository.owner}/${repository.name}`;
+var githubSlugsOf = (remotes) => {
+  const slugs = remotes.flatMap((remote) => {
+    const found = /github\.com[:/]+([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i.exec(remote.trim());
+    return found ? [`${found[1]}/${found[2]}`.toLowerCase()] : [];
+  });
+  return [...new Set(slugs)];
+};
+var listOf = (repositories2) => repositories2.length === 0 ? ["This account opens no repository."] : ["The repositories of this account:", ...repositories2.map((repository) => `  ${nameOf(repository)}`)];
+var pickRepository = (repositories2, wanted, slugs) => {
+  if (wanted) {
+    const found = repositories2.find(
+      (repository) => repository.id === wanted || nameOf(repository).toLowerCase() === wanted.toLowerCase()
+    );
+    if (!found) throw new CliError("G8N3001", `No repository of this account is ${wanted}.`, listOf(repositories2));
+    return found;
+  }
+  const fromGit = repositories2.filter((repository) => slugs.includes(nameOf(repository).toLowerCase()));
+  if (fromGit.length === 1) return fromGit[0];
+  if (fromGit.length === 0 && slugs.length > 0) {
+    throw new CliError(
+      "G8N3001",
+      `This account opens no repository of this folder (${slugs.join(", ")}). Pass --repo <owner/name>.`,
+      listOf(repositories2)
+    );
+  }
+  if (repositories2.length === 1) return repositories2[0];
+  if (repositories2.length === 0) throw new CliError("G8N3001", "This account opens no repository.");
+  throw new CliError("G8N3002", "Name the repository with --repo <owner/name>.", listOf(repositories2));
+};
+var languagesOpenTo = (me, repository) => {
+  if (me.admin) return repository.targets;
+  const membership = me.memberships.find((held) => held.repositoryId === repository.id);
+  return repository.targets.filter((language2) => membership?.languages.includes(language2));
+};
+var pickLanguage = (me, repository, wanted) => {
+  const open = languagesOpenTo(me, repository);
+  if (wanted) {
+    if (!repository.targets.includes(wanted)) {
+      throw new CliError("G8N3003", `${nameOf(repository)} does not translate into ${wanted}.`, [
+        `Its target languages: ${repository.targets.join(", ") || "none"}.`
+      ]);
+    }
+    if (!open.includes(wanted)) {
+      throw new CliError("G8N3003", `This account cannot open ${wanted} in ${nameOf(repository)}.`, [
+        `The languages this account can open there: ${open.join(", ") || "none"}.`
+      ]);
+    }
+    return wanted;
+  }
+  if (open.length === 1) return open[0];
+  throw new CliError("G8N3003", "Name the language with --lang <language>.", [
+    `The languages this account can open in ${nameOf(repository)}: ${open.join(", ") || "none"}.`
+  ]);
+};
+
+// ../mcp/src/cli/run.ts
+var ACCESS_TOKEN_PREFIX = "g8n_";
+var GLOBAL = ["api", "json", "help", "version"];
+var COMMANDS = {
+  login: ["no-open"],
+  logout: [],
+  whoami: [],
+  status: ["repo"],
+  keys: ["repo", "lang", "state", "missing", "file", "values", "limit", "cursor"],
+  get: ["repo", "lang"],
+  search: ["repo", "lang", "file", "limit", "cursor"],
+  apply: ["repo", "lang", "file", "dry-run", "read-at"],
+  proposals: ["repo", "lang"],
+  prompt: ["repo", "lang", "to", "state", "file", "limit", "cursor"],
+  mcp: [],
+  check: ["locales", "manifest", "source", "lang", "reporter", "max-warnings"]
+};
+var OPTIONS = {
+  api: { type: "string" },
+  json: { type: "boolean" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "v" },
+  "no-open": { type: "boolean" },
+  repo: { type: "string" },
+  lang: { type: "string" },
+  to: { type: "string" },
+  state: { type: "string" },
+  missing: { type: "boolean" },
+  file: { type: "string" },
+  values: { type: "boolean" },
+  limit: { type: "string" },
+  cursor: { type: "string" },
+  "dry-run": { type: "boolean" },
+  "read-at": { type: "string" },
+  locales: { type: "string" },
+  manifest: { type: "string" },
+  source: { type: "string" },
+  reporter: { type: "string" },
+  "max-warnings": { type: "string" }
+};
+var HELP = `git8n \u2014 the translations of a repository, from a terminal
+
+Usage: git8n <command> [options]
+
+Account
+  login              Sign in with a code that you approve in the editor
+  logout             Sign out, and forget the token of this computer
+  whoami             The account, and what it may do in each repository
+
+Read
+  status             The progress of each language
+  keys               The keys of a language (--missing, --state, --file, --values)
+  get <file:key>     One key, with its neighbours
+  search <text>      The keys whose id, source or translation holds a text
+  proposals          The batches that wait on a language
+
+Write
+  apply <file|->     Propose a JSON object of translations as one commit (--dry-run)
+
+Agents
+  prompt translate   A prompt that asks an LLM for the missing translations
+  mcp                The MCP server, on stdin and stdout
+
+CI, with no server
+  check              Check the locale files of this folder (--locales, --reporter, --max-warnings)
+
+Options
+  --api <url>        The address of the editor. Default: the last login
+  --repo <owner/name>  The repository. Default: the GitHub remote of this folder
+  --lang <language>  The target language. Default: the only one the account can open
+  --json             Answer one JSON document on stdout
+  -h, --help         This help
+  -v, --version      The version
+
+Environment
+  GIT8N_API_URL     The address of the editor
+  GIT8N_API_TOKEN   An access token of the page \xAB Jetons \xBB, in place of login
+  GIT8N_REPO        The repository, in place of --repo
+
+Exit status: 0 done, 1 refused or failed, 2 wrong command or input, 3 not signed in.
+Documentation: <api>/docs/reference/cli
+`;
+var integerOf = (name, value, fallback, least, most) => {
+  if (value === void 0) return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < least || parsed > most) {
+    throw new CliError("G8N1001", `--${name} takes a whole number from ${least} to ${most}.`);
+  }
+  return parsed;
+};
+var STATES = ["missing", "review", "translated", "all"];
+var stateOf = (options, fallback) => {
+  if (options.missing) return "missing";
+  const state = options.state ?? fallback;
+  if (!STATES.includes(state)) {
+    throw new CliError("G8N1001", `--state takes one of ${STATES.join(", ")}.`);
+  }
+  return state;
+};
+async function run(argv, io) {
+  let json = argv.includes("--json");
+  try {
+    let parsed;
+    try {
+      parsed = parseArgs({ args: argv, options: OPTIONS, allowPositionals: true, strict: true });
+    } catch (error) {
+      throw new CliError("G8N1001", `${error.message}. Run git8n --help.`);
+    }
+    const options = parsed.values;
+    const [command, ...rest] = parsed.positionals;
+    json = options.json === true;
+    if (options.version) {
+      io.stdout(json ? `${JSON.stringify({ data: { version: io.version } })}
+` : `${io.version}
+`);
+      return EXIT.ok;
+    }
+    if (options.help || !command) {
+      io.stdout(HELP);
+      return command || options.help ? EXIT.ok : EXIT.usage;
+    }
+    const allowed = COMMANDS[command];
+    if (!allowed) throw new CliError("G8N1001", `${command} is not a command. Run git8n --help.`);
+    const extra = Object.keys(options).filter(
+      (name) => !GLOBAL.includes(name) && !allowed.includes(name)
+    );
+    if (extra.length > 0) {
+      throw new CliError("G8N1001", `${command} takes no ${extra.map((name) => `--${name}`).join(", ")}.`);
+    }
+    return await new Session(io, options, json).run(command, rest);
+  } catch (error) {
+    const failure = asCliError(error);
+    if (json) {
+      io.stdout(
+        `${JSON.stringify({ error: { code: failure.code, message: failure.message, details: failure.details } }, null, 2)}
+`
+      );
+    } else {
+      io.stderr(`error ${failure.code}: ${failure.message}
+`);
+      for (const line of failure.details) io.stderr(`  ${line}
+`);
+    }
+    return failure.exit;
+  }
+}
+var Session = class {
+  io;
+  options;
+  json;
+  path;
+  credentialsRead;
+  tokenUsed;
+  // No parameter properties: Node runs this file with type stripping, which refuses them.
+  constructor(io, options, json) {
+    this.io = io;
+    this.options = options;
+    this.json = json;
+    this.path = credentialsPath(io.env, io.home);
+  }
+  async run(command, positionals) {
+    try {
+      return await this.dispatch(command, positionals);
+    } catch (error) {
+      throw this.refusedToken(error);
+    }
+  }
+  /** A 401 says how to get a token that works: a new access token, or a new login. */
+  refusedToken(error) {
+    if (!(error instanceof ApiError) || error.status !== 401 || this.tokenUsed === void 0) return error;
+    if (this.io.env.GIT8N_API_TOKEN) {
+      return new CliError(
+        "G8N2001",
+        "The API refused the token of GIT8N_API_TOKEN: it expired, or somebody revoked it. Make a new one on the page \xAB Jetons d\u2019acc\xE8s \xBB."
+      );
+    }
+    if (this.tokenUsed.startsWith(ACCESS_TOKEN_PREFIX)) {
+      return new CliError(
+        "G8N2001",
+        "The API refused the access token of this computer: it expired, or somebody revoked it. Make a new one on the page \xAB Jetons d\u2019acc\xE8s \xBB."
+      );
+    }
+    return new CliError("G8N2001", "The session of this computer ended. Run git8n login.");
+  }
+  async dispatch(command, positionals) {
+    const expectArgs = (count, usage) => {
+      if (positionals.length !== count) throw new CliError("G8N1001", `Usage: git8n ${usage}`);
+    };
+    switch (command) {
+      case "login":
+        expectArgs(0, "login [--api <url>]");
+        return this.login();
+      case "logout":
+        expectArgs(0, "logout [--api <url>]");
+        return this.logout();
+      case "whoami":
+        expectArgs(0, "whoami");
+        return this.whoami();
+      case "status":
+        expectArgs(0, "status [--repo <owner/name>]");
+        return this.status();
+      case "keys":
+        expectArgs(0, "keys [--lang <language>] [--missing]");
+        return this.keys();
+      case "get":
+        expectArgs(1, "get <file:key> [--lang <language>]");
+        return this.get(positionals[0]);
+      case "search":
+        expectArgs(1, "search <text> [--lang <language>]");
+        return this.search(positionals[0]);
+      case "apply":
+        expectArgs(1, "apply <file.json|-> [--lang <language>] [--dry-run]");
+        return this.apply(positionals[0]);
+      case "proposals":
+        expectArgs(0, "proposals [--lang <language>]");
+        return this.proposals();
+      case "prompt":
+        if (positionals[0] !== "translate" || positionals.length !== 1) {
+          throw new CliError("G8N1001", "Usage: git8n prompt translate --to <language>");
+        }
+        return this.promptTranslate();
+      case "mcp":
+        expectArgs(0, "mcp");
+        return this.mcp();
+      case "check":
+        expectArgs(0, "check [--locales <folder>] [--reporter pretty|json|github] [--max-warnings <n>]");
+        return this.check();
+      default:
+        throw new CliError("G8N1001", `${command} is not a command.`);
+    }
+  }
+  answer(data, human) {
+    this.io.stdout(this.json ? `${JSON.stringify({ data }, null, 2)}
+` : human());
+    return EXIT.ok;
+  }
+  credentials() {
+    this.credentialsRead ??= readCredentials(this.path);
+    return this.credentialsRead;
+  }
+  async api() {
+    const named = this.options.api ?? this.io.env.GIT8N_API_URL ?? (await this.credentials()).default;
+    if (!named) throw new CliError("G8N1002", "Pass --api <url>, for example --api https://git8n.example.com.");
+    return named.replace(/\/+$/, "");
+  }
+  async config() {
+    const url = await this.api();
+    const token = this.io.env.GIT8N_API_TOKEN || (await this.credentials()).servers[url]?.token;
+    if (!token) throw new CliError("G8N2001", `No account is signed in to ${url}. Run git8n login.`);
+    this.tokenUsed = token;
+    return { url, token, fetch: this.io.fetch };
+  }
+  async repository(config) {
+    const wanted = this.options.repo ?? this.io.env.GIT8N_REPO;
+    return pickRepository(await repositories(config), wanted, githubSlugsOf(await this.io.gitRemotes(this.io.cwd)));
+  }
+  /** The repository, the language and its catalogue, for the commands that read keys. */
+  async read(language2) {
+    const config = await this.config();
+    const [repository, me] = await Promise.all([this.repository(config), rightsOf(config)]);
+    const chosen = pickLanguage(me, repository, language2 ?? this.options.lang);
+    const read = await catalogue(config, repository.id, chosen);
+    return { config, repository, read };
+  }
+  rowOf(entry, withValues) {
+    return {
+      id: idOf(entry),
+      file: entry.file,
+      key: entry.key,
+      state: entry.state,
+      ...entry.empty ? { empty: true } : {},
+      ...withValues ? { source: entry.source, value: entry.value, ...entry.was === void 0 ? {} : { was: entry.was } } : {}
+    };
+  }
+  humanRows(entries, withValues) {
+    const width = Math.max(0, ...entries.map((entry) => idOf(entry).length));
+    return entries.map((entry) => {
+      const head = `${idOf(entry).padEnd(width)}  ${entry.state}${entry.empty ? " (empty on purpose)" : ""}`;
+      if (!withValues) return `${head}
+`;
+      return [
+        head,
+        `    source: ${entry.source}`,
+        ...entry.was === void 0 ? [] : [`    was:    ${entry.was}`],
+        `    value:  ${entry.value ?? "\u2014"}`,
+        ""
+      ].join("\n");
+    }).join("");
+  }
+  pagedFooter(page) {
+    if (this.json) return;
+    const first = page.rows.length === 0 ? 0 : page.cursor + 1;
+    this.io.stderr(
+      `${first}\u2013${page.cursor + page.rows.length} of ${page.total}${page.nextCursor === null ? "" : `. Next: --cursor ${page.nextCursor}`}
+`
+    );
+  }
+  async login() {
+    const api = await this.api();
+    const credentials = await this.credentials();
+    const code = await askDeviceCode(this.io, api);
+    const address = code.verification_uri_complete ?? `${code.verification_uri}?user_code=${code.user_code}`;
+    this.io.stderr(`Open ${code.verification_uri} and enter the code ${code.user_code}
+`);
+    if (!this.options["no-open"] && await this.io.openUrl(address)) {
+      this.io.stderr("The browser is open. Approve the code there.\n");
+    }
+    this.io.stderr("Waiting for the approval\u2026\n");
+    const token = await waitForApproval(this.io, api, code);
+    const person = await personOf(this.io, api, token);
+    await writeCredentials(this.path, {
+      default: api,
+      servers: { ...credentials.servers, [api]: { token, ...person ?? {} } }
+    });
+    if (this.io.env.GIT8N_API_TOKEN) {
+      this.io.stderr("GIT8N_API_TOKEN is set: the commands use it, not this sign-in.\n");
+    }
+    return this.answer(
+      { api, account: person, credentials: this.path },
+      () => `Signed in to ${api}${person ? ` as ${person.name} <${person.email}>` : ""}.
+`
+    );
+  }
+  async logout() {
+    const api = await this.api();
+    const credentials = await this.credentials();
+    const held = credentials.servers[api];
+    if (!held) {
+      return this.answer({ api, signedOut: false, revoked: false }, () => `No account is signed in to ${api}.
+`);
+    }
+    const revoked = held.token.startsWith(ACCESS_TOKEN_PREFIX) ? false : await signOut(this.io, api, held.token);
+    const { [api]: _gone, ...servers } = credentials.servers;
+    await writeCredentials(this.path, {
+      ...credentials.default === api ? {} : { default: credentials.default },
+      servers
+    });
+    return this.answer(
+      { api, signedOut: true, revoked },
+      () => `Signed out of ${api}.${revoked ? "" : " The API did not end the session: it ends after 14 days without use."}
+`
+    );
+  }
+  async whoami() {
+    const config = await this.config();
+    const me = await rightsOf(config);
+    const [all, person] = await Promise.all([
+      me.admin || me.memberships.length > 0 ? repositories(config) : Promise.resolve([]),
+      config.token.startsWith(ACCESS_TOKEN_PREFIX) ? Promise.resolve(null) : personOf(this.io, config.url, config.token)
+    ]);
+    const byId = new Map(all.map((repository) => [repository.id, repository]));
+    const memberships = me.memberships.map((membership) => ({
+      repository: byId.has(membership.repositoryId) ? nameOf(byId.get(membership.repositoryId)) : membership.repositoryId,
+      repositoryId: membership.repositoryId,
+      role: membership.role,
+      languages: membership.languages,
+      writesSource: membership.writesSource
+    }));
+    const via = this.io.env.GIT8N_API_TOKEN ? "GIT8N_API_TOKEN" : "login";
+    return this.answer(
+      { api: config.url, account: person, via, admin: me.admin, memberships },
+      () => [
+        `${config.url}${person ? ` \u2014 ${person.name} <${person.email}>` : ""} (token from ${via})`,
+        ...me.admin ? ["Admin: sets the repositories up."] : [],
+        ...memberships.length === 0 ? ["Member of no repository."] : [],
+        ...memberships.map(
+          (held) => `${held.repository}  ${held.role}  ${held.languages.join(", ") || "\u2014"}${held.writesSource ? "  writes the source" : ""}`
+        ),
+        ""
+      ].join("\n")
+    );
+  }
+  async status() {
+    const config = await this.config();
+    const wanted = this.options.repo ?? this.io.env.GIT8N_REPO;
+    const all = await repositories(config);
+    const slugs = githubSlugsOf(await this.io.gitRemotes(this.io.cwd));
+    const named = wanted !== void 0 || all.some((repository) => slugs.includes(nameOf(repository).toLowerCase()));
+    if (named) {
+      const repository = pickRepository(all, wanted, slugs);
+      const languages = await progress(config, repository.id);
+      return this.answer(
+        {
+          repository: {
+            id: repository.id,
+            name: nameOf(repository),
+            branch: repository.branch,
+            source: repository.source,
+            targets: repository.targets
+          },
+          languages
+        },
+        () => [
+          `${nameOf(repository)} (${repository.branch}) \u2014 source ${repository.source}`,
+          ...languages.map(
+            (row) => `  ${row.language.padEnd(6)} ${String(row.published).padStart(5)}/${row.total} published  ${row.proposed} proposed  ${row.missing} missing  ${row.review} to review`
+          ),
+          ""
+        ].join("\n")
+      );
+    }
+    const rows = [];
+    for (let page = 1; ; page += 1) {
+      const answered = await overview(config, { page, perPage: 50, sort: "name" });
+      rows.push(...answered.rows);
+      if (!answered.hasMore) break;
+    }
+    const summary = rows.map((row) => ({
+      id: row.id,
+      name: `${row.owner}/${row.name}`,
+      source: row.source,
+      targets: row.targets,
+      languages: row.progress,
+      ...row.progressError ? { error: row.progressError } : {}
+    }));
+    return this.answer(
+      { repositories: summary },
+      () => summary.length === 0 ? "This account opens no repository.\n" : summary.map(
+        (row) => [
+          `${row.name} \u2014 source ${row.source}`,
+          ...(row.languages ?? []).map(
+            (language2) => `  ${language2.language.padEnd(6)} ${String(language2.published).padStart(5)}/${language2.total} published  ${language2.proposed} proposed  ${language2.missing} missing`
+          ),
+          ...row.error ? [`  ${row.error}`] : [],
+          ""
+        ].join("\n")
+      ).join("")
+    );
+  }
+  async keys() {
+    const state = stateOf(this.options, "all");
+    const limit = integerOf("limit", this.options.limit, 100, 1, 2e3);
+    const cursor = integerOf("cursor", this.options.cursor, 0, 0, Number.MAX_SAFE_INTEGER);
+    const { repository, read } = await this.read();
+    const found = read.entries.filter(
+      (entry) => (state === "all" || entry.state === state) && (this.options.file === void 0 || entry.file === this.options.file)
+    );
+    const page = pageOf(found, cursor, limit);
+    const withValues = this.options.values === true;
+    this.pagedFooter(page);
+    return this.answer(
+      {
+        repository: nameOf(repository),
+        language: read.language,
+        source: read.source,
+        commit: read.commit,
+        filesWithNoVersion: disabledFilesOf(read),
+        total: page.total,
+        cursor: page.cursor,
+        nextCursor: page.nextCursor,
+        entries: page.rows.map((entry) => this.rowOf(entry, withValues))
+      },
+      () => this.humanRows(page.rows, withValues)
+    );
+  }
+  async get(id) {
+    const wanted = parseId(id);
+    const { repository, read } = await this.read();
+    if (disabledFilesOf(read).includes(wanted.file)) {
+      throw new CliError("G8N3004", `${wanted.file} has no ${read.language} version.`);
+    }
+    const entry = read.entries.find((held) => held.file === wanted.file && held.key === wanted.key);
+    if (!entry) throw new CliError("G8N3004", `${id} is not a key of the source (${read.source}).`);
+    const neighbours = neighboursOf(read, entry);
+    return this.answer(
+      {
+        repository: nameOf(repository),
+        language: read.language,
+        source: read.source,
+        commit: read.commit,
+        entry: this.rowOf(entry, true),
+        neighbours: neighbours.map((other) => this.rowOf(other, true))
+      },
+      () => [
+        this.humanRows([entry], true),
+        ...neighbours.length === 0 ? [] : ["Neighbours:\n", this.humanRows(neighbours, true)]
+      ].join("")
+    );
+  }
+  async search(text) {
+    const limit = integerOf("limit", this.options.limit, 100, 1, 2e3);
+    const cursor = integerOf("cursor", this.options.cursor, 0, 0, Number.MAX_SAFE_INTEGER);
+    const { repository, read } = await this.read();
+    const found = read.entries.filter(
+      (entry) => matchesText(entry, text) && (this.options.file === void 0 || entry.file === this.options.file)
+    );
+    const page = pageOf(found, cursor, limit);
+    this.pagedFooter(page);
+    return this.answer(
+      {
+        repository: nameOf(repository),
+        language: read.language,
+        commit: read.commit,
+        total: page.total,
+        cursor: page.cursor,
+        nextCursor: page.nextCursor,
+        entries: page.rows.map((entry) => this.rowOf(entry, true))
+      },
+      () => this.humanRows(page.rows, true)
+    );
+  }
+  async apply(input) {
+    const readAt = this.options["read-at"];
+    if (readAt !== void 0 && !/^[0-9a-f]{40}$/.test(readAt)) {
+      throw new CliError("G8N1001", "--read-at takes the full sha of a commit, as keys --json answers it.");
+    }
+    const texts = textsOf(input === "-" ? await this.io.readStdin() : await this.io.readFile(input), this.options.file);
+    if (texts.size === 0) throw new CliError("G8N1003", "The input holds no key.");
+    const { config, repository, read } = await this.read();
+    const plan = planOf(read, texts, readAt ?? read.commit);
+    const base = { repository: nameOf(repository), language: read.language, ...plan };
+    if (this.options["dry-run"] || plan.changes.length === 0) {
+      return this.answer(
+        { ...base, proposed: null },
+        () => [
+          ...plan.changes.map((change) => `${change.id}
+    ${change.from ?? "\u2014"}
+  \u2192 ${change.to}`),
+          `${plan.changes.length} to propose, ${plan.unchanged.length} unchanged, read at ${plan.readAt.slice(0, 7)}.`,
+          ...this.stillToReview(plan.stillToReview),
+          plan.changes.length === 0 ? "Nothing to propose." : "Dry run: nothing was sent.",
+          ""
+        ].join("\n")
+      );
+    }
+    const proposed = await propose(config, {
+      repository: repository.id,
+      language: read.language,
+      readAt: plan.readAt,
+      values: valuesOf(plan)
+    });
+    return this.answer(
+      { ...base, proposed },
+      () => [
+        `Proposed ${proposed.keys} key(s) in ${read.language} as ${proposed.commit.slice(0, 7)} on ${proposed.branch}. A reviewer publishes them.`,
+        ...this.stillToReview(plan.stillToReview),
+        ""
+      ].join("\n")
+    );
+  }
+  stillToReview(ids) {
+    if (ids.length === 0) return [];
+    return [
+      `${ids.length} key(s) to review keep the same text: a proposal does not change their state. A reviewer keeps them in the editor.`,
+      ...ids.slice(0, 10).map((id) => `  ${id}`)
+    ];
+  }
+  async proposals() {
+    const config = await this.config();
+    const [repository, me] = await Promise.all([this.repository(config), rightsOf(config)]);
+    const language2 = pickLanguage(me, repository, this.options.lang);
+    const batches = await waiting(config, repository.id, language2);
+    return this.answer(
+      { repository: nameOf(repository), language: language2, batches },
+      () => batches.length === 0 ? `Nothing waits on ${language2}.
+` : batches.map(
+        (batch) => `${batch.commit.slice(0, 7)}  ${batch.at.slice(0, 10)}  ${batch.author}  ${batch.message.split("\n")[0]}
+`
+      ).join("")
+    );
+  }
+  async promptTranslate() {
+    const state = stateOf(this.options, "missing");
+    if (state === "translated" || state === "all") {
+      throw new CliError("G8N1001", "prompt translate takes --state missing or --state review.");
+    }
+    if (this.options.to && this.options.lang && this.options.to !== this.options.lang) {
+      throw new CliError("G8N1001", "--to and --lang name two languages. Pass one.");
+    }
+    const limit = integerOf("limit", this.options.limit, 50, 1, 500);
+    const cursor = integerOf("cursor", this.options.cursor, 0, 0, Number.MAX_SAFE_INTEGER);
+    const { repository, read } = await this.read(this.options.to);
+    const found = read.entries.filter(
+      (entry) => entry.state === state && (this.options.file === void 0 || entry.file === this.options.file)
+    );
+    const page = pageOf(found, cursor, limit);
+    const keys = promptKeysOf(read, page.rows);
+    const prompt = translatePrompt({
+      repository: nameOf(repository),
+      read,
+      keys,
+      total: page.total,
+      nextCursor: page.nextCursor
+    });
+    if (!this.json && page.total === 0) this.io.stderr(`No key is ${state} in ${read.language}.
+`);
+    return this.answer(
+      {
+        repository: nameOf(repository),
+        language: read.language,
+        source: read.source,
+        commit: read.commit,
+        total: page.total,
+        cursor: page.cursor,
+        nextCursor: page.nextCursor,
+        keys,
+        prompt
+      },
+      () => prompt
+    );
+  }
+  /** Reads the locale files of the working copy, and answers 1 when they fail the check. No API, no login. */
+  async check() {
+    const reporter = this.options.reporter ?? (this.json ? "json" : "pretty");
+    if (!REPORTERS.includes(reporter))
+      throw new CliError("G8N1001", `--reporter takes one of ${REPORTERS.join(", ")}.`);
+    const maxWarnings = this.options["max-warnings"] === void 0 ? null : integerOf("max-warnings", this.options["max-warnings"], 0, 0, Number.MAX_SAFE_INTEGER);
+    const { cwd } = this.io;
+    const inCwd = (path) => isAbsolute(path) ? path : join3(cwd, path);
+    const languages = this.options.lang?.split(",").map((language2) => language2.trim()).filter(Boolean);
+    let report;
+    try {
+      report = await checkLocales(
+        {
+          locales: this.options.locales ?? null,
+          manifest: this.options.manifest ?? null,
+          source: this.options.source ?? null,
+          languages: languages && languages.length > 0 ? languages : null
+        },
+        {
+          readDir: (path) => this.io.readDir(inCwd(path)),
+          readFile: (path) => this.io.readFile(inCwd(path)).catch(() => null)
+        }
+      );
+    } catch (error) {
+      if (error instanceof CheckSetupError) throw new CliError("G8N1005", error.message);
+      throw error;
+    }
+    const output = {
+      pretty: () => prettyReport(report),
+      github: () => githubReport(report),
+      json: () => `${JSON.stringify({ data: { ...report, maxWarnings, failed: failed(report, maxWarnings) } }, null, 2)}
+`
+    }[reporter];
+    this.io.stdout(output());
+    return failed(report, maxWarnings) ? EXIT.failed : EXIT.ok;
+  }
+  async mcp() {
+    if (this.json) throw new CliError("G8N1001", "mcp speaks the MCP protocol, and takes no --json.");
+    await this.io.serveMcp(await this.config());
+    return EXIT.ok;
+  }
+};
+
+// ../mcp/src/cli/node.ts
+var readStdin = async () => {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+};
+var openUrl = (url) => new Promise((resolve) => {
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  const child = spawn(command, args, { stdio: "ignore", detached: true });
+  child.on("error", () => resolve(false));
+  child.on("spawn", () => {
+    child.unref();
+    resolve(true);
+  });
+});
+var gitRemotes = async (cwd) => {
+  try {
+    const { stdout } = await promisify(execFile)("git", ["remote", "-v"], { cwd });
+    return stdout.split("\n").flatMap((line) => line.split(/\s+/)[1] ?? []);
+  } catch {
+    return [];
+  }
+};
+var main = async (version) => {
+  process.exitCode = await run(process.argv.slice(2), {
+    env: process.env,
+    home: homedir(),
+    cwd: process.cwd(),
+    stdout: (text) => process.stdout.write(text),
+    stderr: (text) => process.stderr.write(text),
+    readStdin,
+    readFile: (path) => readFile2(path, "utf8"),
+    readDir: async (path) => {
+      try {
+        return (await readdir(path, { withFileTypes: true })).map((entry) => ({
+          name: entry.name,
+          directory: entry.isDirectory()
+        }));
+      } catch {
+        return null;
+      }
+    },
+    fetch: (input, init) => fetch(input, init),
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    now: () => Date.now(),
+    openUrl,
+    gitRemotes,
+    serveMcp: serveOverStdio,
+    version
+  });
+};
+
+// package.json
+var package_default = {
+  name: "@git8n/cli",
+  version: "0.1.0",
+  description: "The CLI and the MCP server of git8n: read, check and propose the translations of a GitHub repository.",
+  keywords: [
+    "cli",
+    "github",
+    "i18n",
+    "i18next",
+    "localization",
+    "mcp",
+    "translation"
+  ],
+  homepage: "https://git8n.sakuga.dev/docs/",
+  bugs: "https://github.com/sakuga-software/git8n/issues",
+  license: "AGPL-3.0-only",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/sakuga-software/git8n.git",
+    directory: "packages/cli"
+  },
+  bin: {
+    git8n: "./dist/git8n.js"
+  },
+  files: [
+    "dist"
+  ],
+  type: "module",
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "esbuild src/git8n.ts --bundle --platform=node --format=esm --target=node22 --outfile=dist/git8n.js --external:@modelcontextprotocol/sdk --external:zod",
+    typecheck: "tsc --noEmit",
+    test: "pnpm run build && vitest run",
+    prepack: "pnpm run build"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.30.1",
+    zod: "catalog:"
+  },
+  devDependencies: {
+    "@git8n/mcp": "workspace:*",
+    "@types/node": "catalog:",
+    esbuild: "^0.28.2",
+    typescript: "catalog:",
+    vitest: "catalog:"
+  },
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/git8n.ts
+await main(package_default.version);