odoro 0.1.0

package/dist/commands-FVAHVVVN.js

@@ -0,0 +1,793 @@
+#!/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-G2WW7N4C.js';
+import { colors, info, warn, success, error } from './chunk-JMEHF3KN.js';
+import { readFile, writeFile, mkdir, rm, rename } from 'fs/promises';
+import { join, isAbsolute, resolve, dirname, posix } from 'path';
+import * as prompts from '@clack/prompts';
+import { createHash } from 'crypto';
+
+var CONFIG_FILE = "odoro.json";
+var trackedFileSchema = object({
+  /** Chemin dans le projet, relatif a sa racine, en barres obliques. */
+  path: string().check(_minLength(1)),
+  /** Empreinte du contenu **tel qu'il a ete livre**. */
+  hash: string().check(_minLength(1))
+});
+var installedSchema = object({
+  /** Date d'installation, en ISO 8601. */
+  installedAt: string().check(_minLength(1)),
+  /** Fichiers ecrits par cette entree. */
+  files: array(trackedFileSchema)
+});
+var aliasesSchema = object({
+  /**
+   * Prefixe d'import employe dans le code ecrit, sans barre finale.
+   * Par exemple `@/components/odoro`.
+   */
+  import: string().check(_minLength(1)),
+  /**
+   * Dossier correspondant sur le disque, relatif a la racine du projet.
+   * Par exemple `src/components/odoro`.
+   */
+  directory: string().check(_minLength(1))
+});
+var projectSchema = object({
+  /** Version du format, pour que la CLI sache si elle sait lire. */
+  version: _default(literal(1), 1),
+  /** Adresse du registre : une URL, ou un chemin local pour le developper. */
+  registry: string().check(_minLength(1)),
+  /** Ou ecrire, et sous quel prefixe importer. */
+  aliases: aliasesSchema,
+  /** Ce qui a ete installe, indexe par identifiant de registre. */
+  installed: _default(record(string(), installedSchema), {})
+});
+function fingerprint(content) {
+  const normalised = content.replaceAll("\r\n", "\n");
+  return createHash("sha256").update(normalised, "utf8").digest("hex").slice(0, 16);
+}
+function configPath(root) {
+  return join(root, CONFIG_FILE);
+}
+async function loadProject(root) {
+  let raw;
+  try {
+    raw = await readFile(configPath(root), "utf8");
+  } catch {
+    return { ok: false, reason: "absent", problems: [] };
+  }
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error2) {
+    return {
+      ok: false,
+      reason: "invalide",
+      problems: [`JSON illisible \u2014 ${error2.message}`]
+    };
+  }
+  const parsed = safeParse(projectSchema, value);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      reason: "invalide",
+      problems: parsed.error.issues.map(
+        (issue) => `${issue.path.join(".") || CONFIG_FILE} : ${issue.message}`
+      )
+    };
+  }
+  return { ok: true, config: parsed.data };
+}
+async function saveProject(root, config) {
+  const installed = Object.fromEntries(
+    Object.entries(config.installed).sort(([a], [b]) => a.localeCompare(b))
+  );
+  const ordered = { ...config, installed };
+  await writeFile(configPath(root), `${JSON.stringify(ordered, null, 2)}
+`, "utf8");
+}
+
+// src/add/rewrite.ts
+var REGISTRY_TOKEN = "@registre";
+function rewriteImports(source, importPrefix) {
+  const prefix = importPrefix.replace(/\/$/, "");
+  return source.split(`${REGISTRY_TOKEN}/`).join(`${prefix}/`);
+}
+function usedTokens(source) {
+  const pattern = new RegExp(`${REGISTRY_TOKEN}/([\\w./-]+)`, "g");
+  const found = /* @__PURE__ */ new Set();
+  for (const match of source.matchAll(pattern)) {
+    const path = match[1];
+    if (path !== void 0) found.add(path);
+  }
+  return [...found].sort();
+}
+
+// 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"
+};
+function verdict(local, deliveredHash, upstream) {
+  if (local === null) return "absent";
+  if (upstream === null) return "inconnu";
+  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";
+}
+async function inspectEntry(root, config, id, upstream) {
+  const installed = config.installed[id];
+  if (installed === void 0) {
+    return { id, files: [], orphan: upstream === null, upstream };
+  }
+  const served = /* @__PURE__ */ new Map();
+  if (upstream !== null) {
+    for (const file of upstream.files) {
+      const source = upstream.sources[file.path];
+      if (source !== void 0) {
+        served.set(
+          join(config.aliases.directory, file.target).replaceAll("\\", "/"),
+          rewriteImports(source, config.aliases.import)
+        );
+      }
+    }
+  }
+  const files = [];
+  for (const tracked of installed.files) {
+    let local = null;
+    try {
+      local = await readFile(join(root, tracked.path), "utf8");
+    } catch {
+      local = null;
+    }
+    const upstreamSource = served.get(tracked.path.replaceAll("\\", "/")) ?? null;
+    files.push({
+      path: tracked.path,
+      state: verdict(local, tracked.hash, upstreamSource),
+      local,
+      upstream: upstreamSource
+    });
+  }
+  return { id, files, orphan: upstream === null, upstream };
+}
+async function inspectAll(root, config, registry) {
+  const reports = [];
+  for (const id of Object.keys(config.installed).sort()) {
+    const fetched = await registry.entry(id);
+    reports.push(await inspectEntry(root, config, id, fetched.ok ? fetched.value : null));
+  }
+  return reports;
+}
+function previewChanges(local, upstream, limit = 8) {
+  const localLines = local.replaceAll("\r\n", "\n").split("\n");
+  const upstreamLines = upstream.replaceAll("\r\n", "\n").split("\n");
+  const localSet = new Set(localLines);
+  const upstreamSet = new Set(upstreamLines);
+  return {
+    added: upstreamLines.filter((line) => line.trim() !== "" && !localSet.has(line)).slice(0, limit),
+    removed: localLines.filter((line) => line.trim() !== "" && !upstreamSet.has(line)).slice(0, limit)
+  };
+}
+function isRemote(location) {
+  return /^https?:\/\//.test(location);
+}
+async function readDocument(location, relativePath) {
+  if (isRemote(location)) {
+    const url = `${location.replace(/\/$/, "")}/${relativePath}`;
+    let response;
+    try {
+      response = await fetch(url);
+    } catch (error2) {
+      return {
+        ok: false,
+        problems: [`${url} : injoignable \u2014 ${error2.message}`]
+      };
+    }
+    if (!response.ok) {
+      return { ok: false, problems: [`${url} : reponse ${String(response.status)}.`] };
+    }
+    try {
+      return { ok: true, value: await response.json() };
+    } catch {
+      return { ok: false, problems: [`${url} : la reponse n'est pas du JSON.`] };
+    }
+  }
+  const file = join(location, relativePath);
+  let raw;
+  try {
+    raw = await readFile(file, "utf8");
+  } catch {
+    return { ok: false, problems: [`${file} : introuvable.`] };
+  }
+  try {
+    return { ok: true, value: JSON.parse(raw) };
+  } catch (error2) {
+    return {
+      ok: false,
+      problems: [`${file} : JSON illisible \u2014 ${error2.message}`]
+    };
+  }
+}
+function asIndex(value, origin) {
+  const candidate = value;
+  if (candidate.version !== 1) {
+    return {
+      ok: false,
+      problems: [
+        `${origin} : version de format ${String(candidate.version)} non reconnue. Mettez la CLI a jour.`
+      ]
+    };
+  }
+  if (!Array.isArray(candidate.entries)) {
+    return {
+      ok: false,
+      problems: [`${origin} : l'index ne contient aucune liste d'entrees.`]
+    };
+  }
+  return { ok: true, value: candidate };
+}
+function asEntry(value, id) {
+  const parsed = parseMeta(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.`] };
+  }
+  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.`);
+    }
+  }
+  if (problems.length > 0) return { ok: false, problems };
+  return {
+    ok: true,
+    value: { ...parsed.meta, id, sources: record2 }
+  };
+}
+function openRegistry(location, root) {
+  const resolved = isRemote(location) ? location : isAbsolute(location) ? location : resolve(root, location);
+  return {
+    location: resolved,
+    async index() {
+      const document = await readDocument(resolved, "index.json");
+      if (!document.ok) return document;
+      return asIndex(document.value, `${resolved}/index.json`);
+    },
+    async entry(id) {
+      const document = await readDocument(resolved, `${id}.json`);
+      if (!document.ok) return document;
+      return asEntry(document.value, id);
+    }
+  };
+}
+function indexById(index) {
+  return new Map(index.entries.map((entry) => [entry.id, entry]));
+}
+async function planWrite(root, path, content, owner) {
+  let existing = null;
+  try {
+    existing = await readFile(join(root, path), "utf8");
+  } catch {
+    existing = null;
+  }
+  const action = existing === null ? "creation" : existing.replaceAll("\r\n", "\n") === content.replaceAll("\r\n", "\n") ? "inchange" : "remplacement";
+  return { path, content, action, owner };
+}
+var PENDING = ".odoro-en-cours";
+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 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") {
+        previous.set(entry.path, await readFile(target, "utf8"));
+      } else {
+        previous.set(entry.path, null);
+      }
+      const temporary = `${target}${PENDING}`;
+      await writeFile(temporary, entry.content, "utf8");
+      pending.push(temporary);
+    }
+  } catch (cause) {
+    await Promise.all(pending.map((file) => rm(file, { force: true })));
+    throw cause;
+  }
+  const placed = [];
+  try {
+    for (const entry of todo) {
+      const target = join(root, entry.path);
+      await rename(`${target}${PENDING}`, target);
+      placed.push(entry.path);
+    }
+  } catch (cause) {
+    await restore(root, placed, previous);
+    await Promise.all(pending.map((file) => rm(file, { force: true })));
+    throw cause;
+  }
+  return { written: todo.map((entry) => entry.path), skipped };
+}
+async function restore(root, placed, previous) {
+  for (const path of placed) {
+    const target = join(root, path);
+    const before = previous.get(path);
+    try {
+      if (before === null || before === void 0) {
+        await rm(target, { force: true });
+      } else {
+        await writeFile(target, before, "utf8");
+      }
+    } catch {
+    }
+  }
+}
+
+// src/add/install.ts
+function suggest(unknown, known) {
+  const needle = unknown.toLowerCase();
+  const tail = needle.split("/").pop() ?? needle;
+  return known.filter((id) => {
+    const candidate = id.toLowerCase();
+    return candidate.includes(tail) || (candidate.split("/").pop() ?? "").includes(tail);
+  }).slice(0, 4);
+}
+async function prepareInstall(registry, requested) {
+  const index = await registry.index();
+  if (!index.ok) return { ok: false, problems: index.problems };
+  const catalogue = indexById(index.value);
+  const known = [...catalogue.keys()];
+  const ids = [];
+  const problems = [];
+  for (const asked of requested) {
+    if (catalogue.has(asked)) {
+      ids.push(asked);
+      continue;
+    }
+    const matches = known.filter((id) => (id.split("/").pop() ?? "") === asked);
+    if (matches.length === 1 && matches[0] !== void 0) {
+      ids.push(matches[0]);
+      continue;
+    }
+    if (matches.length > 1) {
+      problems.push(
+        `"${asked}" est ambigu : ${matches.join(", ")}. Precisez la categorie.`
+      );
+      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.`
+    );
+  }
+  if (problems.length > 0) return { ok: false, problems };
+  const resolvable = new Map(
+    [...catalogue].map(([id, entry]) => [
+      id,
+      { id, registryDependencies: entry.registryDependencies }
+    ])
+  );
+  const graph = resolveGraph(ids, resolvable);
+  if (!graph.ok) return { ok: false, problems: graph.problems.map(describeProblem) };
+  const entries = [];
+  for (const id of graph.graph.order) {
+    const entry = await registry.entry(id);
+    if (!entry.ok) return { ok: false, problems: entry.problems };
+    entries.push(entry.value);
+  }
+  return { ok: true, entries, implied: graph.graph.implied };
+}
+function targetPath(config, target) {
+  return posix.join(config.aliases.directory, target);
+}
+async function planInstall(root, config, entries) {
+  const plan = [];
+  for (const entry of entries) {
+    for (const file of entry.files) {
+      const source = entry.sources[file.path];
+      if (source === void 0) continue;
+      plan.push(
+        await planWrite(
+          root,
+          targetPath(config, file.target),
+          rewriteImports(source, config.aliases.import),
+          entry.id
+        )
+      );
+    }
+  }
+  return plan;
+}
+function recordInstall(previous, entries, plan, now) {
+  const installed = { ...previous };
+  for (const entry of entries) {
+    installed[entry.id] = {
+      installedAt: now.toISOString(),
+      files: plan.filter((write) => write.owner === entry.id).map((write) => ({ path: write.path, hash: fingerprint(write.content) }))
+    };
+  }
+  return installed;
+}
+
+// src/add/weight.ts
+var BACKEND_WEIGHT = {
+  /** Scene 3D minimale : geometrie, materiau standard, lumiere directionnelle. */
+  three: 130,
+  /** Rendu plein ecran : contexte, programme, triangle. */
+  ogl: 13
+};
+function weighEntries(entries) {
+  const byBackend = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const backend = entry.perf.backend;
+    if (backend === false) continue;
+    const list = byBackend.get(backend) ?? [];
+    list.push(entry.id);
+    byBackend.set(backend, list);
+  }
+  const warnings = [];
+  for (const [backend, ids] of byBackend) {
+    const kilobytes = BACKEND_WEIGHT[backend];
+    const which = ids.length === 1 ? ids[0] : `${String(ids.length)} composants`;
+    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.`
+    });
+  }
+  return warnings.sort((a, b) => b.kilobytes - a.kilobytes);
+}
+function requiredPackages(entries) {
+  const packages = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    for (const dependency of entry.dependencies) packages.add(dependency);
+    if (entry.engine.gl !== false || entry.engine.gsap.length > 0) {
+      packages.add("@odoro-cli/engine");
+    }
+  }
+  return [...packages].sort();
+}
+
+// src/add/commands.ts
+var DEFAULT_REGISTRY = "https://register.odoro.dev";
+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.`
+  );
+  return 1;
+}
+function fail(title, problems) {
+  error(title);
+  for (const problem of problems) console.error(`  ${colors.dim("\xB7")} ${problem}`);
+  return 1;
+}
+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.`);
+    return 1;
+  }
+  return fail(`${CONFIG_FILE} est illisible :`, 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.`);
+    }
+    const replace = await prompts.confirm({
+      message: `${CONFIG_FILE} existe deja. Le remplacer ?`,
+      initialValue: false
+    });
+    if (prompts.isCancel(replace) || !replace) {
+      info("Rien n a ete change.");
+      return 0;
+    }
+  }
+  const guess = await guessAlias(root);
+  const suggested = defaultAliases(guess);
+  if (guess === null) {
+    warn(
+      `Aucun alias trouve dans tsconfig.json : les imports seront ecrits en ${colors.cyan(suggested.import)}.`
+    );
+  } else {
+    info(
+      `Alias trouve dans tsconfig.json : ${colors.cyan(`${guess.prefix}/*`)} vers ${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 ?",
+      initialValue: suggested.directory
+    });
+    if (prompts.isCancel(directory)) return 0;
+    const importPrefix = await prompts.text({
+      message: "Sous quel prefixe les importer ?",
+      initialValue: suggested.import
+    });
+    if (prompts.isCancel(importPrefix)) return 0;
+    const source = await prompts.text({ message: "Registre ?", 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.`);
+  console.log(`  ${colors.dim("destination")}  ${aliases.directory}/`);
+  console.log(`  ${colors.dim("imports")}      ${aliases.import}/\u2026`);
+  console.log(`  ${colors.dim("registre")}     ${registry}`);
+  console.log(`
+  ${colors.cyan("odoro list")} donne le catalogue.
+`);
+  return 0;
+}
+var ACTION_MARK = {
+  creation: colors.green("+"),
+  remplacement: colors.yellow("~"),
+  inchange: 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.');
+    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);
+  const { entries, implied } = prepared;
+  if (implied.length > 0) {
+    info(`Dependances ajoutees : ${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(" ")}`
+    );
+  }
+  const plan = await planInstall(root, config, entries);
+  const replacing = plan.filter((write) => write.action === "remplacement");
+  console.log("");
+  for (const write of plan) {
+    console.log(`  ${ACTION_MARK[write.action]} ${write.path}`);
+  }
+  console.log("");
+  if (replacing.length > 0 && options.yes !== true) {
+    if (!canAsk(options)) {
+      return needsConfirmation(
+        `${String(replacing.length)} fichier(s) existant(s) seraient remplaces.`
+      );
+    }
+    const go = await prompts.confirm({
+      message: `${String(replacing.length)} fichier(s) existant(s) seront remplaces. Continuer ?`,
+      initialValue: false
+    });
+    if (prompts.isCancel(go) || !go) {
+      info("Rien n a ete ecrit.");
+      return 0;
+    }
+  }
+  try {
+    const report = await applyPlan(root, plan);
+    const updated = {
+      ...config,
+      installed: recordInstall(config.installed, entries, plan, /* @__PURE__ */ new Date())
+    };
+    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}.`);
+  } catch (cause) {
+    error("Ecriture interrompue : le projet est inchange.", cause);
+    return 1;
+  }
+  warnUndeclared(entries);
+  return 0;
+}
+function warnUndeclared(entries) {
+  const targets = new Set(
+    entries.flatMap((entry) => entry.files.map((file) => file.target))
+  );
+  for (const entry of entries) {
+    for (const source of Object.values(entry.sources)) {
+      for (const token of usedTokens(source)) {
+        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.`
+          );
+        }
+      }
+    }
+  }
+}
+async function missingPackages(root, required) {
+  if (required.length === 0) return [];
+  let manifest;
+  try {
+    manifest = JSON.parse(
+      await readFile(join(root, "package.json"), "utf8")
+    );
+  } catch {
+    return [...required];
+  }
+  const present = /* @__PURE__ */ new Set([
+    ...Object.keys(manifest.dependencies ?? {}),
+    ...Object.keys(manifest.devDependencies ?? {})
+  ]);
+  return required.filter((name) => !present.has(name));
+}
+async function listCommand(options) {
+  const { root } = options;
+  const loaded = await loadProject(root);
+  const location = options.registry ?? (loaded.ok ? loaded.config.registry : DEFAULT_REGISTRY);
+  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);
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const entry of index.value.entries) {
+    byCategory.set(entry.category, [...byCategory.get(entry.category) ?? [], entry]);
+  }
+  console.log(`
+  ${colors.dim(registry.location)}
+`);
+  for (const [category, entries] of [...byCategory].sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    console.log(`  ${colors.bold(category)}`);
+    for (const entry of entries) {
+      const mark = installed.has(entry.id) ? colors.green("\u2713") : " ";
+      const cost = entry.backend === false ? "" : colors.yellow(` (${entry.backend}, ${entry.tier})`);
+      console.log(
+        `   ${mark} ${colors.cyan(entry.name.padEnd(22))} ${entry.description}${cost}`
+      );
+    }
+    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}`)}
+`);
+  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);
+  return colors.yellow(label);
+}
+async function diffCommand(options) {
+  const { root } = options;
+  const config = await requireProject(root);
+  if (typeof config === "number") return config;
+  const ids = Object.keys(config.installed);
+  if (ids.length === 0) {
+    info("Aucun composant installe.");
+    return 0;
+  }
+  const registry = openRegistry(options.registry ?? config.registry, root);
+  const reports = await inspectAll(root, config, registry);
+  let interesting = 0;
+  console.log("");
+  for (const report of reports) {
+    if (report.orphan) {
+      console.log(`  ${colors.cyan(report.id)} ${colors.dim("\u2014 absent du registre")}`);
+      interesting += 1;
+      continue;
+    }
+    for (const file of report.files) {
+      if (file.state === "a-jour") 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") {
+        const changes = previewChanges(file.local, file.upstream);
+        for (const line of changes.removed)
+          console.log(`    ${colors.red(`- ${line.trim()}`)}`);
+        for (const line of changes.added)
+          console.log(`    ${colors.green(`+ ${line.trim()}`)}`);
+      }
+      console.log("");
+    }
+  }
+  if (interesting === 0) {
+    success(`${String(ids.length)} entree(s) installee(s), toutes a jour.`);
+    return 0;
+  }
+  console.log(
+    `  ${colors.dim(`odoro add <nom> r\xE9\xE9crit une entr\xE9e depuis le registre. Vos retouches seraient perdues.`)}
+`
+  );
+  return 0;
+}
+async function doctorCommand(options) {
+  const { root } = options;
+  const troubles = [];
+  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);
+  }
+  const config = loaded.config;
+  notes.push(`registre : ${config.registry}`);
+  if (!isRemote(config.registry)) {
+    notes.push("registre local : les autres machines de l equipe ne le verront pas.");
+  }
+  const { access } = await import('fs/promises');
+  try {
+    await access(join(root, config.aliases.directory));
+  } catch {
+    if (Object.keys(config.installed).length > 0) {
+      troubles.push(
+        `${config.aliases.directory}/ n'existe pas, alors que des entrees y sont notees.`
+      );
+    }
+  }
+  const registry = openRegistry(options.registry ?? config.registry, root);
+  const reports = await inspectAll(root, config, registry);
+  let retouched = 0;
+  for (const report of reports) {
+    if (report.orphan) {
+      notes.push(`${report.id} n'est plus servi par le registre.`);
+      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 === "retouche") retouched += 1;
+      if (file.state === "mise-a-jour" || file.state === "divergence") {
+        notes.push(`${report.id} : ${STATE_LABEL[file.state]} (${file.path}).`);
+      }
+    }
+  }
+  if (retouched > 0) {
+    notes.push(
+      `${String(retouched)} fichier(s) retouche(s) localement : "odoro add" les reecrirait.`
+    );
+  }
+  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.`
+    );
+  }
+  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.");
+    return 0;
+  }
+  for (const trouble of troubles) console.error(`  ${colors.red("\xB7")} ${trouble}`);
+  console.log("");
+  error(`${String(troubles.length)} probleme(s).`);
+  return 1;
+}
+
+export { DEFAULT_REGISTRY, addCommand, diffCommand, doctorCommand, initCommand, listCommand };