@sia-ui/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivan Mbella
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# @sia-ui/cli
+
+Installer les composants SIA UI dans une application, comme shadcn/ui.
+
+```bash
+npx sia-ui init
+npx sia-ui add data-table crud-page
+```
+
+```
+init                      écrit sia-ui.json et la feuille de style
+list                      liste les composants, [pkg] = servi par le package
+add <nom...>              installe, avec ses dépendances de registre
+add <nom> --overwrite     écrase une copie existante
+```
+
+Les chemins d'installation viennent de `sia-ui.json` :
+
+```json
+{ "components": "src/components", "lib": "src/lib", "styles": "src/styles/sia-ui.css" }
+```
+
+La CLI copie le fichier source tel quel et **annonce les paquets npm à
+installer** plutôt que de les installer d'office :
+
+```
+add  src/components/DataTable/index.tsx
+add  src/components/DataTable/styles.css
+
+À installer :
+  pnpm add @sia-ui/headless @sia-ui/react @sia-ui/tokens @sia-ui/utils
+```
+
+## Place dans SIA UI
+
+```
+@sia-ui/tokens      valeurs : couleurs, espacements, mouvement, vocabulaire
+@sia-ui/utils       fonctions sans dépendance
+@sia-ui/api         client HTTP — indépendant de l'interface
+@sia-ui/headless    comportement, avec React, sans plateforme
+@sia-ui/react       primitives de runtime DOM
+@sia-ui/react-web   composants DOM
+@sia-ui/react-native  composants natifs, à venir
+```
+
+Une chose s'écrit au niveau le plus bas où elle a du sens, et une seule fois.
+Voir [la documentation](https://github.com/BeatJo/sia-ui/tree/main/docs).
+
+## Licence
+
+MIT

package/dist/diff.mjs

@@ -0,0 +1,91 @@
+/**
+ * Un diff unifié, sans dépendance.
+ *
+ * La règle du dépôt vaut aussi pour l'outillage : SIA UI se branche sur les
+ * librairies d'une application, il n'en impose aucune. Trente lignes de plus
+ * grande sous-séquence commune valent mieux qu'un paquet de plus dans le
+ * `node_modules` de qui installe la CLI.
+ */
+
+/** Les indices appariés entre deux suites, par programmation dynamique. */
+function sousSequenceCommune(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const table = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+
+  for (let i = n - 1; i >= 0; i -= 1) {
+    for (let j = m - 1; j >= 0; j -= 1) {
+      table[i][j] =
+        a[i] === b[j]
+          ? table[i + 1][j + 1] + 1
+          : Math.max(table[i + 1][j], table[i][j + 1]);
+    }
+  }
+
+  const paires = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      paires.push([i, j]);
+      i += 1;
+      j += 1;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      i += 1;
+    } else {
+      j += 1;
+    }
+  }
+  return paires;
+}
+
+/**
+ * Les lignes changées entre deux textes, avec leur contexte.
+ *
+ * Rend une liste de `{ signe, ligne }` où le signe vaut ` `, `-` ou `+`.
+ */
+export function lignesDiff(avant, apres, contexte = 2) {
+  const a = avant.split(/\r?\n/);
+  const b = apres.split(/\r?\n/);
+  const paires = sousSequenceCommune(a, b);
+
+  const marques = [];
+  let i = 0;
+  let j = 0;
+
+  for (const [ia, ib] of [...paires, [a.length, b.length]]) {
+    while (i < ia) marques.push({ signe: "-", ligne: a[i++] });
+    while (j < ib) marques.push({ signe: "+", ligne: b[j++] });
+    if (ia < a.length) {
+      marques.push({ signe: " ", ligne: a[ia] });
+      i = ia + 1;
+      j = ib + 1;
+    }
+  }
+
+  // On ne garde que ce qui entoure un changement : un fichier de trois cents
+  // lignes dont une bouge ne doit pas en afficher trois cents.
+  const garder = new Set();
+  marques.forEach((m, index) => {
+    if (m.signe === " ") return;
+    for (let k = index - contexte; k <= index + contexte; k += 1) {
+      if (k >= 0 && k < marques.length) garder.add(k);
+    }
+  });
+
+  const sortie = [];
+  let trou = false;
+  marques.forEach((m, index) => {
+    if (garder.has(index)) {
+      if (trou) {
+        sortie.push({ signe: "~", ligne: "…" });
+        trou = false;
+      }
+      sortie.push(m);
+    } else if (sortie.length > 0) {
+      trou = true;
+    }
+  });
+
+  return sortie;
+}

package/dist/index.js

@@ -0,0 +1,325 @@
+import { access, cp, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  LOCK_FILE,
+  ecrireLock,
+  empreinte,
+  lireLock,
+  noter,
+} from "./lock.mjs";
+import { diff, doctor, outdated, remove } from "./lifecycle.mjs";
+import { choisirSource } from "./source.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const registryRoot = resolve(here, "registry");
+
+const DEFAULT_CONFIG = {
+  components: "src/components",
+  lib: "src/lib",
+  styles: "src/styles/sia-ui.css",
+};
+
+/**
+ * Les arguments, avec les options à valeur.
+ *
+ * `--registry <url>` en prend une : la traiter comme un drapeau nu ferait
+ * passer l'URL pour un nom de composant, et la CLI répondrait « Composant
+ * inconnu : https://… ».
+ */
+function analyser(argv) {
+  const flags = new Set();
+  const valeurs = {};
+  const args = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const brut = argv[i];
+    if (!brut.startsWith("--")) {
+      args.push(brut);
+      continue;
+    }
+
+    const [nom, valeurCollee] = brut.split(/=(.*)/s);
+    if (nom === "--registry") {
+      valeurs.registry = valeurCollee ?? argv[++i];
+      continue;
+    }
+    flags.add(nom);
+  }
+
+  return { flags, valeurs, args };
+}
+
+const [, , command = "help", ...rest] = process.argv;
+const { flags, valeurs, args } = analyser(rest);
+
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * La configuration du projet, si elle existe.
+ *
+ * `init` l'écrit, `add` la lit : sans ça la CLI installait toujours dans
+ * `src/`, quelle que soit l'arborescence du projet.
+ */
+async function readConfig(cwd) {
+  const path = join(cwd, "sia-ui.json");
+  if (!(await exists(path))) return DEFAULT_CONFIG;
+
+  try {
+    return { ...DEFAULT_CONFIG, ...JSON.parse(await readFile(path, "utf8")) };
+  } catch {
+    console.warn("sia-ui.json est illisible — valeurs par défaut utilisées.");
+    return DEFAULT_CONFIG;
+  }
+}
+
+/**
+ * Où lire le catalogue.
+ *
+ * Du plus explicite au plus implicite : l'option de la ligne de commande, puis
+ * le champ `registry` de `sia-ui.json`, puis la copie embarquée dans la CLI.
+ */
+async function ouvrirSource(config) {
+  return choisirSource({
+    racineLocale: registryRoot,
+    url: valeurs.registry ?? config.registry,
+  });
+}
+
+function resolveItems(registre, names) {
+  const resolved = new Map();
+
+  const visit = (name) => {
+    if (resolved.has(name)) return;
+
+    const item = registre.items.find((candidate) => candidate.name === name);
+    if (!item) throw new Error(`Composant inconnu : ${name}`);
+
+    if (item.status === "removed") {
+      throw new Error(
+        `${name} a été retiré du registre${item.replacedBy ? ` — utiliser ${item.replacedBy}` : ""}.`,
+      );
+    }
+
+    for (const dependency of item.registryDependencies ?? []) visit(dependency);
+    resolved.set(name, item);
+  };
+
+  for (const name of names) visit(name);
+  return [...resolved.values()];
+}
+
+/**
+ * Où va un fichier de l'entrée, selon la configuration du projet.
+ *
+ * Les chemins du registre sont exprimés depuis la racine des sources —
+ * `components/ui/badge.tsx`, `lib/sia-ui.ts` — et sont réancrés ici.
+ */
+function targetFor(file, config) {
+  // Les entrées historiques rangent tout sous `components/ui/`, les entrées du
+  // package sous `components/<Nom>/`. Les deux préfixes désignent le même
+  // dossier chez l'utilisateur.
+  if (file.startsWith("components/ui/")) {
+    return join(config.components, file.slice("components/ui/".length));
+  }
+  if (file.startsWith("components/")) {
+    return join(config.components, file.slice("components/".length));
+  }
+  if (file.startsWith("lib/")) {
+    return join(config.lib, file.slice("lib/".length));
+  }
+  return join("src", file);
+}
+
+/**
+ * Un chemin de projet, écrit pareil partout.
+ *
+ * `sia-ui.lock.json` est versionné dans le dépôt de l'utilisateur : un
+ * `src\components\Button` écrit sous Windows et un `src/components/Button`
+ * écrit sous Linux décriraient le même fichier avec deux clés différentes, et
+ * `doctor` verrait un composant manquant à chaque changement de machine.
+ */
+function cheminUnix(chemin) {
+  return chemin.split(sep).join("/");
+}
+
+async function init(cwd) {
+  const configPath = join(cwd, "sia-ui.json");
+  if (!(await exists(configPath))) {
+    await writeFile(
+      configPath,
+      `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`,
+    );
+    console.log("sia-ui.json créé.");
+  }
+
+  const config = await readConfig(cwd);
+  const styleTarget = join(cwd, config.styles);
+  await mkdir(dirname(styleTarget), { recursive: true });
+
+  if (!(await exists(styleTarget))) {
+    await cp(join(registryRoot, "styles/sia-ui.css"), styleTarget);
+    console.log(`add  ${config.styles}`);
+  }
+
+  console.log("SIA UI initialisé.");
+}
+
+async function add(cwd, names) {
+  if (names.length === 0) {
+    throw new Error("Indiquer au moins un nom de composant.");
+  }
+
+  const overwrite = flags.has("--overwrite");
+  const config = await readConfig(cwd);
+  const source = await ouvrirSource(config);
+  const items = resolveItems(source.registre, names);
+  const npm = new Set();
+  const warnings = [];
+  const lock = await lireLock(cwd);
+
+  if (source.origine !== "embarqué") {
+    console.log(`registre  ${source.origine}\n`);
+  }
+
+  for (const item of items) {
+    if (item.status === "deprecated") {
+      warnings.push(
+        `${item.name} est déprécié${item.replacedBy ? ` — préférer ${item.replacedBy}` : ""}${item.deprecatedReason ? ` (${item.deprecatedReason})` : ""}.`,
+      );
+    }
+
+    for (const dependency of item.dependencies ?? []) npm.add(dependency);
+
+    const empreintes = {};
+    let copieComplete = true;
+
+    for (const file of item.files) {
+      const relative = targetFor(file, config);
+      const target = join(cwd, relative);
+
+      await mkdir(dirname(target), { recursive: true });
+
+      if ((await exists(target)) && !overwrite) {
+        console.log(`skip ${relative} (déjà présent — --overwrite pour écraser)`);
+        // Le verrou ne décrit que ce qui a réellement été écrit : y noter une
+        // empreinte qu'on n'a pas posée ferait mentir `doctor` et `diff`.
+        copieComplete = false;
+        continue;
+      }
+
+      // Le contenu passe par la mémoire plutôt que par une copie de fichier :
+      // c'est ce qui permet à la même boucle de servir une source distante.
+      const contenu = await source.lire(file);
+      await writeFile(target, contenu);
+      empreintes[cheminUnix(relative)] = empreinte(contenu);
+      console.log(`add  ${relative}`);
+    }
+
+    if (copieComplete) noter(lock, item, empreintes);
+  }
+
+  await ecrireLock(cwd, lock);
+  console.log(`\nlock ${LOCK_FILE}`);
+
+  for (const warning of warnings) console.warn(`\n⚠  ${warning}`);
+
+  if (npm.size > 0) {
+    console.log(`\nÀ installer :\n  pnpm add ${[...npm].sort().join(" ")}`);
+  }
+}
+
+function list(registre) {
+  const visibles = registre.items.filter((item) => item.name !== "utils");
+  const largeurNom = Math.max(...visibles.map((item) => item.name.length), 16);
+  const largeurVersion = Math.max(
+    ...visibles.map((item) => (item.version ?? "").length),
+    7,
+  );
+
+  for (const item of visibles) {
+    // Le statut ne s'affiche que lorsqu'il demande une décision : « stable »
+    // sur cent quatre lignes n'apprend rien à personne.
+    const statut =
+      item.status && item.status !== "stable" ? `  [${item.status}]` : "";
+
+    console.log(
+      `${item.name.padEnd(largeurNom)}  ${(item.version ?? "").padEnd(largeurVersion)}  ${item.description}${statut}`,
+    );
+  }
+}
+
+function help() {
+  console.log(
+    [
+      "SIA UI",
+      "",
+      "Commandes :",
+      "  init                      initialiser une application",
+      "  list                      lister les composants disponibles",
+      "  list --outdated           lister ce qui a une version plus récente",
+      "  add <nom...>              installer des composants et leurs dépendances",
+      "  diff [nom...]             comparer les fichiers installés au registre",
+      "  remove <nom...>           retirer des composants installés",
+      "  doctor                    vérifier l'état de ce qui est installé",
+      "",
+      "Options :",
+      "  --overwrite               écraser les fichiers déjà présents",
+      "  --force                   passer outre les avertissements de remove",
+      "  --registry <url>          lire un registre servi en HTTP",
+      "",
+      "Les chemins d'installation viennent de sia-ui.json,",
+      `ce qui est installé de ${LOCK_FILE}.`,
+      "",
+    ].join("\n"),
+  );
+}
+
+/**
+ * Ce dont les commandes de cycle de vie ont besoin, passé explicitement.
+ *
+ * Elles vivent dans un autre module et n'importent rien d'ici : une
+ * dépendance circulaire entre le point d'entrée et ses commandes est un piège
+ * qui ne se voit qu'à l'exécution.
+ */
+async function contexteProjet(cwd) {
+  const config = await readConfig(cwd);
+  const source = await ouvrirSource(config);
+
+  return {
+    cwd,
+    config,
+    registry: source.registre,
+    lireSource: source.lire,
+    // Le verrou écrit ses chemins en barres obliques : la comparaison doit se
+    // faire dans la même écriture, sinon aucun fichier ne se retrouve sous
+    // Windows.
+    cibleDe: (fichier, conf) => cheminUnix(targetFor(fichier, conf)),
+  };
+}
+
+try {
+  const cwd = process.cwd();
+  if (command === "init") await init(cwd);
+  else if (command === "list" && flags.has("--outdated")) {
+    await outdated(await contexteProjet(cwd));
+  } else if (command === "list") {
+    const source = await ouvrirSource(await readConfig(cwd));
+    list(source.registre);
+  } else if (command === "add") await add(cwd, args);
+  else if (command === "diff") await diff(await contexteProjet(cwd), args);
+  else if (command === "remove") {
+    await remove(await contexteProjet(cwd), args, flags);
+  } else if (command === "doctor") await doctor(await contexteProjet(cwd));
+  else help();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+}