guford-ui 0.1.0

package/bin.mjs

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+// @ts-check
+/**
+ * guford-ui — CLI maison (façon shadcn) pour installer des composants/utils
+ * en copiant leur code source dans un projet Angular cible.
+ *
+ * Le registry peut être lu :
+ *   - en LOCAL (quand on exécute la CLI depuis le dépôt guford-ui), ou
+ *   - à DISTANCE via une URL (fetch) — pour `npx guford-ui ...` depuis n'importe quel projet.
+ *
+ * Commandes :
+ *   guford-ui init                 Installe le theming (tokens + preset Tailwind) + config projet
+ *   guford-ui list                 Liste les items disponibles
+ *   guford-ui info <name>          Détaille un item (fichiers + dépendances)
+ *   guford-ui add  <name...>       Copie un/des item(s) (+ ses registryDependencies) dans le projet
+ *
+ * Options communes :
+ *   --cwd <path>        Projet cible (défaut: répertoire courant)
+ *   --dir <path>        Racine d'installation dans le projet (défaut: guford-ui.json puis "src")
+ *   --registry <url>    Base distante du registry (sinon $GUFORD_UI_REGISTRY, sinon local, sinon défaut)
+ *   --overwrite         Écrase les fichiers existants sans demander
+ *   --dry-run           Affiche ce qui serait fait sans rien écrire
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname, basename, join, resolve, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..'); // racine du dépôt guford-ui (mode local)
+const CONFIG_FILE = 'guford-ui.json';
+
+// Base distante par défaut (à adapter après publication : GitHub raw, host statique…).
+const DEFAULT_REMOTE = 'https://raw.githubusercontent.com/bekmarc/guford-ui/main';
+
+// --- couleurs ANSI ---------------------------------------------------------
+const c = {
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+};
+
+function fail(msg) {
+  console.error(c.red(`✖ ${msg}`));
+  process.exit(1);
+}
+
+// --- source du registry (local FS ou URL distante) -------------------------
+/**
+ * @param {{registry?: string}} flags
+ * @returns {{remote: boolean, base: string}}
+ */
+function resolveSource(flags) {
+  const explicit = flags.registry || process.env.GUFORD_UI_REGISTRY;
+  if (explicit) return { remote: true, base: explicit.replace(/\/+$/, '') };
+  if (existsSync(join(ROOT, 'registry.json'))) return { remote: false, base: ROOT };
+  return { remote: true, base: DEFAULT_REMOTE };
+}
+
+/** Lit un fichier texte du registry (chemin relatif à la racine, ex: 'registry.json'). */
+async function readText(source, rel) {
+  if (source.remote) {
+    const url = `${source.base}/${rel}`;
+    const res = await fetch(url);
+    if (!res.ok) fail(`Téléchargement échoué (${res.status}) : ${url}`);
+    return await res.text();
+  }
+  const path = join(source.base, rel);
+  if (!existsSync(path)) fail(`Fichier introuvable: ${path}`);
+  return readFileSync(path, 'utf8');
+}
+
+/** Lit un fichier (texte ou binaire) du registry → Buffer. */
+async function readBuffer(source, rel) {
+  if (source.remote) {
+    const url = `${source.base}/${rel}`;
+    const res = await fetch(url);
+    if (!res.ok) fail(`Téléchargement échoué (${res.status}) : ${url}`);
+    return Buffer.from(await res.arrayBuffer());
+  }
+  const path = join(source.base, rel);
+  if (!existsSync(path)) fail(`Fichier introuvable: ${path}`);
+  return readFileSync(path);
+}
+
+async function loadRegistry(source) {
+  /** @type {{ name: string, items: any[], styles?: { files: string[] } }} */
+  const reg = JSON.parse(await readText(source, 'registry.json'));
+  return reg;
+}
+
+function findItem(reg, name) {
+  return reg.items.find((it) => it.name === name);
+}
+
+/** Résout récursivement un item + ses registryDependencies (deps avant l'item). */
+function resolveWithDeps(reg, name, acc = new Map()) {
+  if (acc.has(name)) return acc;
+  const item = findItem(reg, name);
+  if (!item) fail(`Item inconnu: "${name}". Lance "guford-ui list" pour voir les items dispo.`);
+  for (const dep of item.registryDependencies ?? []) resolveWithDeps(reg, dep, acc);
+  acc.set(name, item);
+  return acc;
+}
+
+/** Config projet guford-ui.json (toujours dans le projet cible local). */
+function loadProjectConfig(cwd) {
+  const path = resolve(process.cwd(), cwd, CONFIG_FILE);
+  if (existsSync(path)) {
+    try {
+      return JSON.parse(readFileSync(path, 'utf8'));
+    } catch {
+      fail(`${CONFIG_FILE} illisible (JSON invalide): ${path}`);
+    }
+  }
+  return null;
+}
+
+// --- parseur d'arguments ---------------------------------------------------
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = { cwd: '.', dir: undefined, overwrite: false, dryRun: false, registry: undefined };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--overwrite') flags.overwrite = true;
+    else if (a === '--dry-run') flags.dryRun = true;
+    else if (a === '--cwd') flags.cwd = argv[++i];
+    else if (a === '--dir') flags.dir = argv[++i];
+    else if (a === '--registry') flags.registry = argv[++i];
+    else if (a.startsWith('--')) fail(`Option inconnue: ${a}`);
+    else positionals.push(a);
+  }
+  return { positionals, flags };
+}
+
+function sourceLabel(source) {
+  return source.remote ? c.dim(`(registry distant: ${source.base})`) : c.dim('(registry local)');
+}
+
+// --- commandes -------------------------------------------------------------
+async function cmdList(flags) {
+  const source = resolveSource(flags);
+  const reg = await loadRegistry(source);
+  console.log(c.bold(`\n  ${reg.name} — ${reg.items.length} items disponibles `) + sourceLabel(source) + '\n');
+  for (const it of reg.items) {
+    const tag = it.type.replace('registry:', '');
+    console.log(`  ${c.green(it.name.padEnd(18))} ${c.dim('[' + tag + ']')}`);
+    console.log(`  ${' '.repeat(18)} ${c.dim(it.description ?? '')}\n`);
+  }
+  console.log(c.dim(`  → guford-ui add <name>\n`));
+}
+
+async function cmdInfo(name, flags) {
+  if (!name) fail('Usage: guford-ui info <name>');
+  const source = resolveSource(flags);
+  const reg = await loadRegistry(source);
+  const it = findItem(reg, name);
+  if (!it) fail(`Item inconnu: "${name}"`);
+  console.log(c.bold(`\n  ${it.name}  ${c.dim('[' + it.type + ']')}`));
+  console.log(`  ${it.description ?? ''}\n`);
+  console.log(c.cyan('  Fichiers:'));
+  for (const f of it.files) console.log(`    ${f.path}  ${c.dim('→ ' + f.target)}`);
+  console.log(c.cyan('\n  Dépendances npm:'));
+  console.log(`    ${(it.dependencies ?? []).join(', ') || c.dim('aucune')}`);
+  console.log(c.cyan('\n  Dépendances registry:'));
+  console.log(`    ${(it.registryDependencies ?? []).join(', ') || c.dim('aucune')}\n`);
+}
+
+/** Écrit un fichier sur disque avec gestion skip/overwrite/dry-run. Retourne 'written'|'skipped'. */
+function writeFileSafe(dest, buffer, flags, log = []) {
+  const exists = existsSync(dest);
+  if (exists && !flags.overwrite) {
+    log.push(`  ${c.yellow('~ skip')}  ${relative(process.cwd(), dest)} ${c.dim('(--overwrite pour forcer)')}`);
+    return 'skipped';
+  }
+  if (!flags.dryRun) {
+    mkdirSync(dirname(dest), { recursive: true });
+    writeFileSync(dest, buffer);
+  }
+  log.push(`  ${c.green(exists ? '↻ over' : '+ add ')}  ${relative(process.cwd(), dest)}`);
+  return 'written';
+}
+
+async function cmdAdd(names, flags) {
+  if (!names.length)
+    fail('Usage: guford-ui add <name...> [--cwd .] [--dir src] [--registry <url>] [--overwrite] [--dry-run]');
+  const source = resolveSource(flags);
+  const reg = await loadRegistry(source);
+
+  const resolved = new Map();
+  for (const n of names) resolveWithDeps(reg, n, resolved);
+
+  const config = loadProjectConfig(flags.cwd);
+  const dir = flags.dir ?? config?.dir ?? 'src';
+  const targetRoot = resolve(process.cwd(), flags.cwd, dir);
+
+  console.log(
+    c.bold(`\n  Installation de ${[...resolved.keys()].map(c.green).join(', ')}`) +
+      (flags.dryRun ? c.yellow('  (dry-run)') : '') +
+      ' ' +
+      sourceLabel(source),
+  );
+  if (config) console.log(c.dim(`  config ${CONFIG_FILE} détectée (dir="${dir}")`));
+  console.log(c.dim(`  cible: ${targetRoot}\n`));
+
+  const npmDeps = new Set();
+  const log = [];
+  let written = 0;
+  let skipped = 0;
+
+  for (const item of resolved.values()) {
+    for (const dep of item.dependencies ?? []) npmDeps.add(dep);
+    for (const file of item.files) {
+      const buffer = await readBuffer(source, `registry/${file.path}`);
+      const dest = join(targetRoot, file.target);
+      const r = writeFileSafe(dest, buffer, flags, log);
+      r === 'written' ? written++ : skipped++;
+    }
+  }
+
+  console.log(log.join('\n'));
+  console.log('');
+  if (npmDeps.size) {
+    console.log(c.cyan('  Dépendances npm à installer dans le projet cible:'));
+    console.log(`    ${c.bold('npm install ' + [...npmDeps].join(' '))}\n`);
+  }
+  console.log(
+    c.dim(
+      `  ${written} fichier(s) ${flags.dryRun ? 'seraient écrits' : 'écrits'}` +
+        (skipped ? `, ${skipped} ignoré(s)` : '') +
+        '.\n',
+    ),
+  );
+}
+
+async function cmdInit(flags) {
+  const source = resolveSource(flags);
+  const reg = await loadRegistry(source);
+  const dir = flags.dir ?? 'src';
+  const projectRoot = resolve(process.cwd(), flags.cwd);
+  const stylesDest = join(projectRoot, dir, 'styles');
+
+  console.log(
+    c.bold('\n  Initialisation du theming guford-ui') +
+      (flags.dryRun ? c.yellow('  (dry-run)') : '') +
+      ' ' +
+      sourceLabel(source),
+  );
+  console.log(c.dim(`  projet: ${projectRoot}\n`));
+
+  const styleFiles = reg.styles?.files ?? [
+    'styles/tokens.css',
+    'styles/tailwind.preset.cjs',
+    'styles/inter/Inter-roman.var.woff2',
+    'styles/inter/Inter-italic.var.woff2',
+  ];
+
+  const log = [];
+  let written = 0;
+  let skipped = 0;
+
+  // Mappe chaque fichier de theming vers son emplacement dans le projet cible.
+  for (const sf of styleFiles) {
+    const name = basename(sf);
+    let dest;
+    if (name === 'tokens.css') dest = join(stylesDest, 'guford-ui-tokens.css');
+    else if (name.endsWith('.cjs')) dest = join(projectRoot, name); // preset à la racine
+    else if (sf.includes('/inter/')) dest = join(stylesDest, 'inter', name);
+    else dest = join(stylesDest, name);
+
+    const buffer = await readBuffer(source, `registry/${sf}`);
+    const r = writeFileSafe(dest, buffer, flags, log);
+    r === 'written' ? written++ : skipped++;
+  }
+
+  // guford-ui.json (config projet)
+  const configDest = join(projectRoot, CONFIG_FILE);
+  if (existsSync(configDest) && !flags.overwrite) {
+    skipped++;
+    log.push(`  ${c.yellow('~ skip')}  ${relative(process.cwd(), configDest)} ${c.dim('(existe déjà)')}`);
+  } else {
+    const cfg = {
+      $schema: 'https://guford-ui/schema.json',
+      dir,
+      aliases: { components: 'components', lib: 'lib', directives: 'directives', utils: 'lib' },
+    };
+    if (!flags.dryRun) writeFileSync(configDest, JSON.stringify(cfg, null, 2) + '\n');
+    written++;
+    log.push(`  ${c.green('+ add ')}  ${relative(process.cwd(), configDest)}`);
+  }
+
+  console.log(log.join('\n'));
+  console.log(c.cyan('\n  Étapes de câblage:'));
+  console.log(`    1. Styles globaux — ajoutez:  ${c.bold(`@import './styles/guford-ui-tokens.css';`)}`);
+  console.log(`       ${c.dim(`(dans ${dir}/styles.scss ou ${dir}/styles.css)`)}`);
+  console.log(`    2. tailwind.config.js — ajoutez:  ${c.bold(`presets: [require('./tailwind.preset.cjs')]`)}`);
+  console.log(`    3. Peer-deps de base:  ${c.bold('npm install clsx tailwind-merge')}`);
+  console.log(`       ${c.dim('(certains composants requièrent aussi @coreui/angular — voir `info <name>`)')}`);
+  console.log(
+    c.dim(
+      `\n  ${written} fichier(s) ${flags.dryRun ? 'seraient écrits' : 'écrits'}` +
+        (skipped ? `, ${skipped} ignoré(s)` : '') +
+        `. Ensuite: guford-ui add <composant>\n`,
+    ),
+  );
+}
+
+function help() {
+  console.log(`
+  ${c.bold('guford-ui')} — registry de composants Angular (façon shadcn)
+
+  ${c.cyan('Commandes:')}
+    init                 Installe le theming (tokens + preset) + config projet
+    list                 Liste les items disponibles
+    info <name>          Détaille un item
+    add  <name...>       Copie un/des item(s) dans le projet cible
+
+  ${c.cyan('Options:')}
+    --cwd <path>         Projet cible (défaut: .)
+    --dir <path>         Racine d'installation (défaut: guford-ui.json puis src)
+    --registry <url>     Base distante du registry (sinon $GUFORD_UI_REGISTRY, sinon local)
+    --overwrite          Écrase les fichiers existants
+    --dry-run            Simule sans écrire
+`);
+}
+
+// --- entrée ----------------------------------------------------------------
+async function main() {
+  const [, , command, ...rest] = process.argv;
+  const { positionals, flags } = parseArgs(rest);
+
+  switch (command) {
+    case 'init':
+      await cmdInit(flags);
+      break;
+    case 'list':
+      await cmdList(flags);
+      break;
+    case 'info':
+      await cmdInfo(positionals[0], flags);
+      break;
+    case 'add':
+      await cmdAdd(positionals, flags);
+      break;
+    case undefined:
+    case '-h':
+    case '--help':
+    case 'help':
+      help();
+      break;
+    default:
+      fail(`Commande inconnue: "${command}". Lance "guford-ui --help".`);
+  }
+}
+
+main().catch((err) => fail(err?.message ?? String(err)));

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "guford-ui",
+  "version": "0.1.0",
+  "description": "CLI pour installer les composants du registry guford-ui (façon shadcn).",
+  "type": "module",
+  "bin": {
+    "guford-ui": "./bin.mjs"
+  },
+  "files": ["bin.mjs"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}