odoro 1.0.9 → 2.1.0

package/dist/{commands-AHMXBWQQ.js → commands-GYA7NTCX.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { guessAlias, defaultAliases } from './chunk-T6RLHSCW.js';
-import { object, string, _minLength, array, _default, record, literal, safeParse, resolveGraph, describeProblem, parseMeta } from './chunk-34RGOZFA.js';
-import { colors, info, warn, success, error } from './chunk-JMEHF3KN.js';
+import { object, string, _minLength, array, _default, record, literal, safeParse, resolveGraph, describeProblem, parseMeta } from './chunk-4D56Z7G3.js';
+import { colors, info, warn, success, error } from './chunk-7ZB5MAM6.js';
 import { readFile, writeFile, mkdir, rm, rename } from 'fs/promises';
 import { join, isAbsolute, resolve, dirname, posix } from 'path';
 import * as prompts from '@clack/prompts';
@@ -9,37 +9,37 @@ import { createHash } from 'crypto';
 
 var CONFIG_FILE = "odoro.json";
 var trackedFileSchema = object({
-  /** Chemin dans le projet, relatif a sa racine, en barres obliques. */
+  /** Path in the project, relative to its root, in forward slashes. */
   path: string().check(_minLength(1)),
-  /** Empreinte du contenu **tel qu'il a ete livre**. */
+  /** Hash of the content **as it was delivered**. */
   hash: string().check(_minLength(1))
 });
 var installedSchema = object({
-  /** Date d'installation, en ISO 8601. */
+  /** Installation date, in ISO 8601. */
   installedAt: string().check(_minLength(1)),
-  /** Fichiers ecrits par cette entree. */
+  /** Files written by this entry. */
   files: array(trackedFileSchema)
 });
 var aliasesSchema = object({
   /**
-   * Prefixe d'import employe dans le code ecrit, sans barre finale.
-   * Par exemple `@/components/odoro`.
+   * Import prefix used in the written code, without a trailing slash. For
+   * example `@/components/odoro`.
    */
   import: string().check(_minLength(1)),
   /**
-   * Dossier correspondant sur le disque, relatif a la racine du projet.
-   * Par exemple `src/components/odoro`.
+   * Matching directory on disk, relative to the project root. For example
+   * `src/components/odoro`.
    */
   directory: string().check(_minLength(1))
 });
 var projectSchema = object({
-  /** Version du format, pour que la CLI sache si elle sait lire. */
+  /** Version of the format, so that the CLI knows whether it can read it. */
   version: _default(literal(1), 1),
-  /** Adresse du registre : une URL, ou un chemin local pour le developper. */
+  /** Address of the registry: a URL, or a local path to develop it. */
   registry: string().check(_minLength(1)),
-  /** Ou ecrire, et sous quel prefixe importer. */
+  /** Where to write, and under which prefix to import. */
   aliases: aliasesSchema,
-  /** Ce qui a ete installe, indexe par identifiant de registre. */
+  /** What was installed, indexed by registry identifier. */
   installed: _default(record(string(), installedSchema), {})
 });
 function fingerprint(content) {
@@ -62,15 +62,15 @@ async function loadProject(root) {
   } catch (error2) {
     return {
       ok: false,
-      reason: "invalide",
-      problems: [`JSON illisible \u2014 ${error2.message}`]
+      reason: "invalid",
+      problems: [`Unreadable JSON \u2014 ${error2.message}`]
     };
   }
   const parsed = safeParse(projectSchema, value);
   if (!parsed.success) {
     return {
       ok: false,
-      reason: "invalide",
+      reason: "invalid",
       problems: parsed.error.issues.map(
         (issue) => `${issue.path.join(".") || CONFIG_FILE} : ${issue.message}`
       )
@@ -89,28 +89,28 @@ async function saveProject(root, config) {
 
 // src/add/rewrite.ts
 var REGISTRY_TOKEN = "@registre";
-function estUnAlias(prefix) {
+function isAlias(prefix) {
   return /^[@~#]/.test(prefix);
 }
-function cheminRelatif(depuis, vers) {
-  const segmentsDepuis = depuis.split("/").slice(0, -1);
-  const segmentsVers = vers.split("/");
-  let commun = 0;
-  while (commun < segmentsDepuis.length && commun < segmentsVers.length - 1 && segmentsDepuis[commun] === segmentsVers[commun]) {
-    commun += 1;
+function relativeImport(from, to) {
+  const fromSegments = from.split("/").slice(0, -1);
+  const toSegments = to.split("/");
+  let common = 0;
+  while (common < fromSegments.length && common < toSegments.length - 1 && fromSegments[common] === toSegments[common]) {
+    common += 1;
   }
-  const montees = segmentsDepuis.length - commun;
-  const descente = segmentsVers.slice(commun).join("/");
-  return montees === 0 ? `./${descente}` : `${"../".repeat(montees)}${descente}`;
+  const climbs = fromSegments.length - common;
+  const descent = toSegments.slice(common).join("/");
+  return climbs === 0 ? `./${descent}` : `${"../".repeat(climbs)}${descent}`;
 }
 function rewriteImports(source, importPrefix, target) {
   const prefix = importPrefix.replace(/\/$/, "");
-  if (estUnAlias(prefix) || target === void 0) {
+  if (isAlias(prefix) || target === void 0) {
     return source.split(`${REGISTRY_TOKEN}/`).join(`${prefix}/`);
   }
   return source.replaceAll(
     new RegExp(`${REGISTRY_TOKEN}/([^'"\\s]+)`, "g"),
-    (_tout, chemin) => cheminRelatif(target, chemin)
+    (_whole, path) => relativeImport(target, path)
   );
 }
 function usedTokens(source) {
@@ -125,22 +125,22 @@ function usedTokens(source) {
 
 // src/add/inspect.ts
 var STATE_LABEL = {
-  "a-jour": "a jour",
-  retouche: "retouche localement",
-  "mise-a-jour": "une mise a jour existe",
-  divergence: "retouche localement, et le registre a change",
-  absent: "absent du projet",
-  inconnu: "inconnu du registre"
+  "up-to-date": "up to date",
+  edited: "edited locally",
+  "update-available": "an update exists",
+  diverged: "edited locally, and the registry has changed",
+  missing: "missing from the project",
+  unknown: "unknown to the registry"
 };
 function verdict(local, deliveredHash, upstream) {
-  if (local === null) return "absent";
-  if (upstream === null) return "inconnu";
+  if (local === null) return "missing";
+  if (upstream === null) return "unknown";
   const localChanged = fingerprint(local) !== deliveredHash;
   const upstreamChanged = fingerprint(upstream) !== deliveredHash;
-  if (!localChanged && !upstreamChanged) return "a-jour";
-  if (localChanged && !upstreamChanged) return "retouche";
-  if (!localChanged && upstreamChanged) return "mise-a-jour";
-  return "divergence";
+  if (!localChanged && !upstreamChanged) return "up-to-date";
+  if (localChanged && !upstreamChanged) return "edited";
+  if (!localChanged && upstreamChanged) return "update-available";
+  return "diverged";
 }
 async function inspectEntry(root, config, id, upstream) {
   const installed = config.installed[id];
@@ -207,16 +207,16 @@ async function readDocument(location, relativePath) {
     } catch (error2) {
       return {
         ok: false,
-        problems: [`${url} : injoignable \u2014 ${error2.message}`]
+        problems: [`${url} : unreachable \u2014 ${error2.message}`]
       };
     }
     if (!response.ok) {
-      return { ok: false, problems: [`${url} : reponse ${String(response.status)}.`] };
+      return { ok: false, problems: [`${url} : response ${String(response.status)}.`] };
     }
     try {
       return { ok: true, value: await response.json() };
     } catch {
-      return { ok: false, problems: [`${url} : la reponse n'est pas du JSON.`] };
+      return { ok: false, problems: [`${url} : the response is not JSON.`] };
     }
   }
   const file = join(location, relativePath);
@@ -224,14 +224,14 @@ async function readDocument(location, relativePath) {
   try {
     raw = await readFile(file, "utf8");
   } catch {
-    return { ok: false, problems: [`${file} : introuvable.`] };
+    return { ok: false, problems: [`${file} : not found.`] };
   }
   try {
     return { ok: true, value: JSON.parse(raw) };
   } catch (error2) {
     return {
       ok: false,
-      problems: [`${file} : JSON illisible \u2014 ${error2.message}`]
+      problems: [`${file} : unreadable JSON \u2014 ${error2.message}`]
     };
   }
 }
@@ -241,14 +241,14 @@ function asIndex(value, origin) {
     return {
       ok: false,
       problems: [
-        `${origin} : version de format ${String(candidate.version)} non reconnue. Mettez la CLI a jour.`
+        `${origin} : format version ${String(candidate.version)} not recognised. Update the CLI.`
       ]
     };
   }
   if (!Array.isArray(candidate.entries)) {
     return {
       ok: false,
-      problems: [`${origin} : l'index ne contient aucune liste d'entrees.`]
+      problems: [`${origin} : the index holds no list of entries.`]
     };
   }
   return { ok: true, value: candidate };
@@ -258,13 +258,15 @@ function asEntry(value, id) {
   if (!parsed.ok) return { ok: false, problems: parsed.problems };
   const sources = value.sources;
   if (typeof sources !== "object" || sources === null) {
-    return { ok: false, problems: [`${id} : l'entree ne porte aucun code source.`] };
+    return { ok: false, problems: [`${id} : the entry carries no source code.`] };
   }
   const record2 = sources;
   const problems = [];
   for (const file of parsed.meta.files) {
     if (typeof record2[file.path] !== "string") {
-      problems.push(`${id} : le fichier annonce "${file.path}" est absent de la reponse.`);
+      problems.push(
+        `${id} : the announced file "${file.path}" is missing from the response.`
+      );
     }
   }
   if (problems.length > 0) return { ok: false, problems };
@@ -299,20 +301,20 @@ async function planWrite(root, path, content, owner) {
   } catch {
     existing = null;
   }
-  const action = existing === null ? "creation" : existing.replaceAll("\r\n", "\n") === content.replaceAll("\r\n", "\n") ? "inchange" : "remplacement";
+  const action = existing === null ? "create" : existing.replaceAll("\r\n", "\n") === content.replaceAll("\r\n", "\n") ? "unchanged" : "replace";
   return { path, content, action, owner };
 }
-var PENDING = ".odoro-en-cours";
+var PENDING = ".odoro-pending";
 async function applyPlan(root, plan) {
-  const todo = plan.filter((entry) => entry.action !== "inchange");
-  const skipped = plan.filter((entry) => entry.action === "inchange").map((e) => e.path);
+  const todo = plan.filter((entry) => entry.action !== "unchanged");
+  const skipped = plan.filter((entry) => entry.action === "unchanged").map((entry) => entry.path);
   const pending = [];
   const previous = /* @__PURE__ */ new Map();
   try {
     for (const entry of todo) {
       const target = join(root, entry.path);
       await mkdir(dirname(target), { recursive: true });
-      if (entry.action === "remplacement") {
+      if (entry.action === "replace") {
         previous.set(entry.path, await readFile(target, "utf8"));
       } else {
         previous.set(entry.path, null);
@@ -381,14 +383,12 @@ async function prepareInstall(registry, requested) {
       continue;
     }
     if (matches.length > 1) {
-      problems.push(
-        `"${asked}" est ambigu : ${matches.join(", ")}. Precisez la categorie.`
-      );
+      problems.push(`"${asked}" is ambiguous: ${matches.join(", ")}. Name the category.`);
       continue;
     }
     const near = suggest(asked, known);
     problems.push(
-      near.length > 0 ? `"${asked}" est introuvable. Vouliez-vous dire ${near.join(", ")} ?` : `"${asked}" est introuvable. "odoro list" donne le catalogue.`
+      near.length > 0 ? `"${asked}" was not found. Did you mean ${near.join(", ")}?` : `"${asked}" was not found. "odoro list" gives the catalogue.`
     );
   }
   if (problems.length > 0) return { ok: false, problems };
@@ -442,9 +442,9 @@ function recordInstall(previous, entries, plan, now) {
 
 // src/add/weight.ts
 var BACKEND_WEIGHT = {
-  /** Scene 3D minimale : geometrie, materiau standard, lumiere directionnelle. */
+  /** Minimal 3D scene: geometry, standard material, directional light. */
   three: 130,
-  /** Rendu plein ecran : contexte, programme, triangle. */
+  /** Full-screen render: context, program, triangle. */
   ogl: 13
 };
 function weighEntries(entries) {
@@ -459,12 +459,12 @@ function weighEntries(entries) {
   const warnings = [];
   for (const [backend, ids] of byBackend) {
     const kilobytes = BACKEND_WEIGHT[backend];
-    const which = ids.length === 1 ? ids[0] : `${String(ids.length)} composants`;
+    const which = ids.length === 1 ? ids[0] : `${String(ids.length)} components`;
     warnings.push({
       backend,
       kilobytes,
       entries: ids,
-      message: backend === "three" ? `${String(which)} charge une scene 3D : environ ${String(kilobytes)} Ko compresses au premier affichage. Le backend leger en demande ${String(BACKEND_WEIGHT.ogl)}, si un effet plein ecran suffit.` : `${String(which)} charge le backend leger : environ ${String(kilobytes)} Ko compresses.`
+      message: backend === "three" ? `${String(which)} loads a 3D scene: about ${String(kilobytes)} kB compressed on the first paint. The light backend asks for ${String(BACKEND_WEIGHT.ogl)}, when a full-screen effect is enough.` : `${String(which)} loads the light backend: about ${String(kilobytes)} kB compressed.`
     });
   }
   return warnings.sort((a, b) => b.kilobytes - a.kilobytes);
@@ -486,9 +486,7 @@ function canAsk(options) {
   return options.yes !== true && process.stdin.isTTY === true;
 }
 function needsConfirmation(what) {
-  error(
-    `${what} Relancez avec ${colors.cyan("--yes")} pour l'accepter sans question.`
-  );
+  error(`${what} Run again with ${colors.cyan("--yes")} to accept it without asking.`);
   return 1;
 }
 function fail(title, problems) {
@@ -500,24 +498,24 @@ async function requireProject(root) {
   const loaded = await loadProject(root);
   if (loaded.ok) return loaded.config;
   if (loaded.reason === "absent") {
-    error(`Aucun ${CONFIG_FILE} ici. Lancez ${colors.cyan("odoro init")} d'abord.`);
+    error(`No ${CONFIG_FILE} here. Run ${colors.cyan("odoro init")} first.`);
     return 1;
   }
-  return fail(`${CONFIG_FILE} est illisible :`, loaded.problems);
+  return fail(`${CONFIG_FILE} is unreadable:`, loaded.problems);
 }
 async function initCommand(options) {
   const { root } = options;
   const existing = await loadProject(root);
   if (existing.ok && options.yes !== true) {
     if (!canAsk(options)) {
-      return needsConfirmation(`${CONFIG_FILE} existe deja et serait remplace.`);
+      return needsConfirmation(`${CONFIG_FILE} already exists and would be replaced.`);
     }
     const replace = await prompts.confirm({
-      message: `${CONFIG_FILE} existe deja. Le remplacer ?`,
+      message: `${CONFIG_FILE} already exists. Replace it?`,
       initialValue: false
     });
     if (prompts.isCancel(replace) || !replace) {
-      info("Rien n a ete change.");
+      info("Nothing was changed.");
       return 0;
     }
   }
@@ -525,71 +523,69 @@ async function initCommand(options) {
   const suggested = defaultAliases(guess);
   if (guess === null) {
     warn(
-      `Aucun alias trouve dans tsconfig.json : les composants iront dans ${colors.cyan(suggested.directory)}/ et s importeront entre eux en relatif.`
+      `No alias found in tsconfig.json: the components will go to ${colors.cyan(suggested.directory)}/ and will import each other relatively.`
     );
   } else {
     info(
-      `Alias trouve dans tsconfig.json : ${colors.cyan(`${guess.prefix}/*`)} vers ${colors.cyan(`${guess.directory}/`)}.`
+      `Alias found in tsconfig.json: ${colors.cyan(`${guess.prefix}/*`)} towards ${colors.cyan(`${guess.directory}/`)}.`
     );
   }
   let aliases = suggested;
   let registry = options.registry ?? DEFAULT_REGISTRY;
   if (canAsk(options)) {
     const directory = await prompts.text({
-      message: "Ou ecrire les composants ?",
+      message: "Where should the components be written?",
       initialValue: suggested.directory
     });
     if (prompts.isCancel(directory)) return 0;
     const importPrefix = await prompts.text({
-      message: "Sous quel prefixe les importer ?",
+      message: "Under which prefix should they be imported?",
       initialValue: suggested.import
     });
     if (prompts.isCancel(importPrefix)) return 0;
-    const source = await prompts.text({ message: "Registre ?", initialValue: registry });
+    const source = await prompts.text({ message: "Registry?", initialValue: registry });
     if (prompts.isCancel(source)) return 0;
     aliases = { directory, import: importPrefix };
     registry = source;
   }
   const config = { version: 1, registry, aliases, installed: {} };
   await saveProject(root, config);
-  success(`${CONFIG_FILE} ecrit.`);
+  success(`${CONFIG_FILE} written.`);
   console.log(`  ${colors.dim("destination")}  ${aliases.directory}/`);
   console.log(`  ${colors.dim("imports")}      ${aliases.import}/\u2026`);
-  console.log(`  ${colors.dim("registre")}     ${registry}`);
+  console.log(`  ${colors.dim("registry")}     ${registry}`);
   console.log(`
-  ${colors.cyan("odoro list")} donne le catalogue.
+  ${colors.cyan("odoro list")} gives the catalogue.
 `);
   return 0;
 }
 var ACTION_MARK = {
-  creation: colors.green("+"),
-  remplacement: colors.yellow("~"),
-  inchange: colors.dim("=")
+  create: colors.green("+"),
+  replace: colors.yellow("~"),
+  unchanged: colors.dim("=")
 };
 async function addCommand(options, requested) {
   const { root } = options;
   const config = await requireProject(root);
   if (typeof config === "number") return config;
   if (requested.length === 0) {
-    error('Rien a installer. Donnez un nom, ou "odoro list" pour le catalogue.');
+    error('Nothing to install. Give a name, or "odoro list" for the catalogue.');
     return 1;
   }
   const registry = openRegistry(options.registry ?? config.registry, root);
   const prepared = await prepareInstall(registry, requested);
-  if (!prepared.ok) return fail("Installation impossible :", prepared.problems);
+  if (!prepared.ok) return fail("Install impossible:", prepared.problems);
   const { entries, implied } = prepared;
   if (implied.length > 0) {
-    info(`Dependances ajoutees : ${implied.map((id) => colors.cyan(id)).join(", ")}`);
+    info(`Dependencies added: ${implied.map((id) => colors.cyan(id)).join(", ")}`);
   }
   for (const warning of weighEntries(entries)) warn(warning.message);
   const missing = await missingPackages(root, requiredPackages(entries));
   if (missing.length > 0) {
-    warn(
-      `A installer ensuite : ${missing.map((name) => colors.cyan(name)).join(" ")}`
-    );
+    warn(`To install next: ${missing.map((name) => colors.cyan(name)).join(" ")}`);
   }
   const plan = await planInstall(root, config, entries);
-  const replacing = plan.filter((write) => write.action === "remplacement");
+  const replacing = plan.filter((write) => write.action === "replace");
   console.log("");
   for (const write of plan) {
     console.log(`  ${ACTION_MARK[write.action]} ${write.path}`);
@@ -598,15 +594,15 @@ async function addCommand(options, requested) {
   if (replacing.length > 0 && options.yes !== true) {
     if (!canAsk(options)) {
       return needsConfirmation(
-        `${String(replacing.length)} fichier(s) existant(s) seraient remplaces.`
+        `${String(replacing.length)} existing file(s) would be replaced.`
       );
     }
     const go = await prompts.confirm({
-      message: `${String(replacing.length)} fichier(s) existant(s) seront remplaces. Continuer ?`,
+      message: `${String(replacing.length)} existing file(s) will be replaced. Continue?`,
       initialValue: false
     });
     if (prompts.isCancel(go) || !go) {
-      info("Rien n a ete ecrit.");
+      info("Nothing was written.");
       return 0;
     }
   }
@@ -618,10 +614,10 @@ async function addCommand(options, requested) {
     };
     await saveProject(root, updated);
     const written = String(report.written.length);
-    const skipped = report.skipped.length > 0 ? `, ${String(report.skipped.length)} inchange(s)` : "";
-    success(`${written} fichier(s) ecrit(s)${skipped}.`);
+    const skipped = report.skipped.length > 0 ? `, ${String(report.skipped.length)} unchanged` : "";
+    success(`${written} file(s) written${skipped}.`);
   } catch (cause) {
-    error("Ecriture interrompue : le projet est inchange.", cause);
+    error("Write interrupted: the project is unchanged.", cause);
     return 1;
   }
   warnUndeclared(entries);
@@ -637,7 +633,7 @@ function warnUndeclared(entries) {
         const matched = [...targets].some((target) => target.startsWith(token));
         if (!matched) {
           warn(
-            `${entry.id} importe ${colors.cyan(token)} sans l'avoir declare : signalez-le au registre.`
+            `${entry.id} imports ${colors.cyan(token)} without declaring it: report it to the registry.`
           );
         }
       }
@@ -667,7 +663,7 @@ async function listCommand(options) {
   const installed = loaded.ok ? new Set(Object.keys(loaded.config.installed)) : /* @__PURE__ */ new Set();
   const registry = openRegistry(location, root);
   const index = await registry.index();
-  if (!index.ok) return fail("Catalogue illisible :", index.problems);
+  if (!index.ok) return fail("Catalogue unreadable:", index.problems);
   const byCategory = /* @__PURE__ */ new Map();
   for (const entry of index.value.entries) {
     byCategory.set(entry.category, [...byCategory.get(entry.category) ?? [], entry]);
@@ -689,16 +685,16 @@ async function listCommand(options) {
     console.log("");
   }
   const total = String(index.value.entries.length);
-  const marked = installed.size > 0 ? `, ${colors.green("\u2713")} = deja installe` : "";
-  console.log(`  ${colors.dim(`${total} entree(s)${marked}`)}
+  const marked = installed.size > 0 ? `, ${colors.green("\u2713")} = already installed` : "";
+  console.log(`  ${colors.dim(`${total} entr${total === "1" ? "y" : "ies"}${marked}`)}
 `);
   return 0;
 }
 function stateColor(state) {
   const label = STATE_LABEL[state];
-  if (state === "a-jour") return colors.green(label);
-  if (state === "retouche") return colors.cyan(label);
-  if (state === "absent" || state === "divergence") return colors.red(label);
+  if (state === "up-to-date") return colors.green(label);
+  if (state === "edited") return colors.cyan(label);
+  if (state === "missing" || state === "diverged") return colors.red(label);
   return colors.yellow(label);
 }
 async function diffCommand(options) {
@@ -707,7 +703,7 @@ async function diffCommand(options) {
   if (typeof config === "number") return config;
   const ids = Object.keys(config.installed);
   if (ids.length === 0) {
-    info("Aucun composant installe.");
+    info("No component installed.");
     return 0;
   }
   const registry = openRegistry(options.registry ?? config.registry, root);
@@ -716,16 +712,18 @@ async function diffCommand(options) {
   console.log("");
   for (const report of reports) {
     if (report.orphan) {
-      console.log(`  ${colors.cyan(report.id)} ${colors.dim("\u2014 absent du registre")}`);
+      console.log(
+        `  ${colors.cyan(report.id)} ${colors.dim("\u2014 missing from the registry")}`
+      );
       interesting += 1;
       continue;
     }
     for (const file of report.files) {
-      if (file.state === "a-jour") continue;
+      if (file.state === "up-to-date") continue;
       interesting += 1;
       console.log(`  ${colors.cyan(report.id)} ${colors.dim(file.path)}`);
       console.log(`    ${stateColor(file.state)}`);
-      if (file.local !== null && file.upstream !== null && file.state !== "retouche") {
+      if (file.local !== null && file.upstream !== null && file.state !== "edited") {
         const changes = previewChanges(file.local, file.upstream);
         for (const line of changes.removed)
           console.log(`    ${colors.red(`- ${line.trim()}`)}`);
@@ -736,11 +734,13 @@ async function diffCommand(options) {
     }
   }
   if (interesting === 0) {
-    success(`${String(ids.length)} entree(s) installee(s), toutes a jour.`);
+    success(
+      `${String(ids.length)} entr${ids.length === 1 ? "y" : "ies"} installed, all up to date.`
+    );
     return 0;
   }
   console.log(
-    `  ${colors.dim(`odoro add <nom> r\xE9\xE9crit une entr\xE9e depuis le registre. Vos retouches seraient perdues.`)}
+    `  ${colors.dim(`odoro add <name> rewrites an entry from the registry. Your edits would be lost.`)}
 `
   );
   return 0;
@@ -751,12 +751,12 @@ async function doctorCommand(options) {
   const notes = [];
   const loaded = await loadProject(root);
   if (!loaded.ok) {
-    return loaded.reason === "absent" ? fail("Diagnostic impossible :", [`aucun ${CONFIG_FILE}. Lancez "odoro init".`]) : fail(`${CONFIG_FILE} est illisible :`, loaded.problems);
+    return loaded.reason === "absent" ? fail("Diagnostics impossible:", [`no ${CONFIG_FILE}. Run "odoro init".`]) : fail(`${CONFIG_FILE} is unreadable:`, loaded.problems);
   }
   const config = loaded.config;
-  notes.push(`registre : ${config.registry}`);
+  notes.push(`registry: ${config.registry}`);
   if (!isRemote(config.registry)) {
-    notes.push("registre local : les autres machines de l equipe ne le verront pas.");
+    notes.push("local registry: the other machines of the team will not see it.");
   }
   const { access } = await import('fs/promises');
   try {
@@ -764,49 +764,49 @@ async function doctorCommand(options) {
   } catch {
     if (Object.keys(config.installed).length > 0) {
       troubles.push(
-        `${config.aliases.directory}/ n'existe pas, alors que des entrees y sont notees.`
+        `${config.aliases.directory}/ does not exist, while entries are recorded in it.`
       );
     }
   }
   const registry = openRegistry(options.registry ?? config.registry, root);
   const reports = await inspectAll(root, config, registry);
-  let retouched = 0;
+  let edited = 0;
   for (const report of reports) {
     if (report.orphan) {
-      notes.push(`${report.id} n'est plus servi par le registre.`);
+      notes.push(`${report.id} is no longer served by the registry.`);
       continue;
     }
     for (const file of report.files) {
-      if (file.state === "absent") {
-        troubles.push(`${report.id} : ${file.path} est note comme installe mais absent.`);
+      if (file.state === "missing") {
+        troubles.push(`${report.id}: ${file.path} is recorded as installed but missing.`);
       }
-      if (file.state === "retouche") retouched += 1;
-      if (file.state === "mise-a-jour" || file.state === "divergence") {
-        notes.push(`${report.id} : ${STATE_LABEL[file.state]} (${file.path}).`);
+      if (file.state === "edited") edited += 1;
+      if (file.state === "update-available" || file.state === "diverged") {
+        notes.push(`${report.id}: ${STATE_LABEL[file.state]} (${file.path}).`);
       }
     }
   }
-  if (retouched > 0) {
+  if (edited > 0) {
     notes.push(
-      `${String(retouched)} fichier(s) retouche(s) localement : "odoro add" les reecrirait.`
+      `${String(edited)} file(s) edited locally: "odoro add" would rewrite them.`
     );
   }
   const served = reports.map((report) => report.upstream).filter((entry) => entry !== null);
   for (const name of await missingPackages(root, requiredPackages(served))) {
     troubles.push(
-      `${name} est requis par un composant installe mais absent du package.json.`
+      `${name} is required by an installed component but missing from the package.json.`
     );
   }
   console.log("");
   for (const note of notes) console.log(`  ${colors.dim("\xB7")} ${note}`);
   if (notes.length > 0) console.log("");
   if (troubles.length === 0) {
-    success("Rien a signaler.");
+    success("Nothing to report.");
     return 0;
   }
   for (const trouble of troubles) console.error(`  ${colors.red("\xB7")} ${trouble}`);
   console.log("");
-  error(`${String(troubles.length)} probleme(s).`);
+  error(`${String(troubles.length)} problem(s).`);
   return 1;
 }