@mimi-ng/cli 0.1.0

package/dist/ui/index.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AVAILABLE = void 0;
+exports.ui = ui;
+const schematics_1 = require("@angular-devkit/schematics");
+const utility_1 = require("@schematics/angular/utility");
+const paths_1 = require("../init/paths");
+const registry_1 = require("../registry");
+const project_1 = require("../utils/project");
+const write_files_1 = require("../utils/write-files");
+/** Componentes que se pueden agregar: los ítems `component` del registro. */
+exports.AVAILABLE = Object.entries(registry_1.registry.items)
+    .filter(([, item]) => item.type === 'component')
+    .map(([name]) => name)
+    .sort();
+/**
+ * `ng g mimi button input form-field`: copia los componentes y sus dependencias del registro a la
+ * carpeta de mimi.json. Sin nombres, pregunta (x-prompt de selección múltiple).
+ *
+ * Requiere init (mimi.json). Archivos existentes: igual → nada; distinto → se omite con aviso;
+ * --overwrite → se reemplaza. Guarda la copia original en .mimi/base/ y la versión de cada
+ * componente en mimi.json. Instala las dependencias que falten con el gestor del proyecto.
+ */
+function ui(options) {
+    return (tree) => {
+        const plan = inspect(tree, options);
+        const report = (0, write_files_1.emptyReport)();
+        return (0, schematics_1.chain)([
+            (0, write_files_1.writeTemplates)({
+                files: plan.items.flatMap((item) => registry_1.registry.items[item].files),
+                componentsDir: plan.componentsDir,
+                overwrite: options.overwrite ?? false,
+                version: registry_1.registry.version,
+                report,
+            }),
+            updateMimiConfig(plan, report),
+            ...Object.entries(plan.newPackages).map(([name, version]) => (0, utility_1.addDependency)(name, version, {
+                type: utility_1.DependencyType.Default,
+                existing: utility_1.ExistingBehavior.Skip,
+                install: utility_1.InstallBehavior.Auto,
+            })),
+            summary(plan, report),
+        ]);
+    };
+}
+// ── Verificaciones (sin escribir) ─────────────────────────────────────────────────────
+function inspect(tree, options) {
+    const config = (0, project_1.readJson)(tree, 'mimi.json');
+    if (!config) {
+        throw new schematics_1.SchematicsException('Mimi no está configurado en este proyecto (falta mimi.json). Ejecuta primero:\n' +
+            '  ng add @mimi-ng/cli');
+    }
+    const requested = [...new Set((options.components ?? []).map((name) => name.trim()))].filter(Boolean);
+    if (requested.length === 0) {
+        throw new schematics_1.SchematicsException(`Indica qué componentes agregar, por ejemplo: ng g mimi button\nDisponibles: ${exports.AVAILABLE.join(', ')}.`);
+    }
+    const unknown = requested.filter((name) => !exports.AVAILABLE.includes(name));
+    if (unknown.length > 0) {
+        const lines = unknown.map((name) => {
+            const suggestion = closest(name);
+            return `"${name}" no es un componente de Mimi.${suggestion ? ` ¿Quisiste decir ${suggestion}?` : ''}`;
+        });
+        throw new schematics_1.SchematicsException(`${lines.join('\n')}\nDisponibles: ${exports.AVAILABLE.join(', ')}.`);
+    }
+    const items = [];
+    for (const name of requested) {
+        for (const item of (0, registry_1.resolveItems)(name))
+            if (!items.includes(item))
+                items.push(item);
+    }
+    const pkg = (0, project_1.readJson)(tree, 'package.json');
+    const installed = (0, project_1.allDependencies)(pkg);
+    const angularRange = installed['@angular/core'];
+    const newPackages = {};
+    for (const item of items) {
+        for (const [name, version] of Object.entries(registry_1.registry.items[item].dependencies ?? {})) {
+            if (!installed[name])
+                newPackages[name] = version;
+        }
+        // peerDependencies: solo si el proyecto no las tiene. Las de Angular, con el rango de
+        // @angular/core del proyecto, para que no queden desalineadas.
+        for (const [name, version] of Object.entries(registry_1.registry.items[item].peerDependencies ?? {})) {
+            if (installed[name])
+                continue;
+            newPackages[name] = name.startsWith('@angular/') && angularRange ? angularRange : version;
+        }
+    }
+    const componentsDir = (0, paths_1.normalizePath)(config.aliases?.components ?? 'src/app/components/ui');
+    return { componentsDir, config, items, newPackages };
+}
+/** El componente más parecido (distancia de edición ≤ 2, o que empiece igual). */
+function closest(name) {
+    const lower = name.toLowerCase();
+    let best = null;
+    for (const candidate of exports.AVAILABLE) {
+        const distance = candidate.startsWith(lower) ? 1 : editDistance(lower, candidate);
+        if (distance <= 2 && (!best || distance < best.distance))
+            best = { name: candidate, distance };
+    }
+    return best?.name ?? null;
+}
+function editDistance(a, b) {
+    const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let previous = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const current = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+            previous = current;
+        }
+    }
+    return row[b.length];
+}
+// ── mimi.json ─────────────────────────────────────────────────────────────────────────
+/**
+ * Registra la versión de cada componente cuyos archivos quedaron iguales a la plantilla. Si
+ * alguno se omitió por estar modificado, se conserva lo que había.
+ */
+function updateMimiConfig(plan, report) {
+    return (tree) => {
+        const skipped = new Set(report.skipped);
+        const components = { ...plan.config.components };
+        for (const item of plan.items) {
+            if (registry_1.registry.items[item].type !== 'component')
+                continue;
+            if (registry_1.registry.items[item].files.some((file) => skipped.has(file)))
+                continue;
+            components[item] = { version: registry_1.registry.version };
+        }
+        const next = { ...plan.config, components };
+        const text = `${JSON.stringify(next, null, 2)}\n`;
+        if (tree.readText('mimi.json') !== text)
+            tree.overwrite('mimi.json', text);
+    };
+}
+// ── Mensaje final ─────────────────────────────────────────────────────────────────────
+function summary(plan, report) {
+    return (_tree, context) => {
+        const log = context.logger;
+        const path = (file) => `${plan.componentsDir}/${(0, write_files_1.projectPathOf)(file)}`;
+        if (report.created.length > 0) {
+            log.info('Agregado:');
+            for (const file of report.created)
+                log.info(`  + ${path(file)}`);
+        }
+        if (report.overwritten.length > 0) {
+            log.info('Reemplazado (--overwrite):');
+            for (const file of report.overwritten)
+                log.info(`  ~ ${path(file)}`);
+        }
+        const itemOf = (file) => plan.items.find((item) => registry_1.registry.items[item].files.includes(file)) ?? file;
+        for (const message of (0, write_files_1.updatedMessages)(report, itemOf, registry_1.registry.version))
+            log.info(message);
+        for (const file of report.skipped) {
+            log.warn(`Omitido: ${path(file)} ya existe con otro contenido (usa --overwrite para reemplazarlo).`);
+        }
+        if (!(0, write_files_1.hasFileChanges)(report) && report.skipped.length === 0) {
+            log.info('Nada que hacer: los archivos ya están al día.');
+        }
+        const packages = Object.entries(plan.newPackages);
+        if (packages.length > 0) {
+            log.info('Dependencias que se instalan:');
+            for (const [name, version] of packages)
+                log.info(`  ${name}@${version}`);
+        }
+        if ((0, write_files_1.hasFileChanges)(report)) {
+            log.info(`Guarda la carpeta ${write_files_1.BASE_DIR.split('/')[0]}/ en git: Mimi la usa para actualizar tus ` +
+                'componentes sin perder tus cambios.');
+        }
+    };
+}

package/dist/ui/schema.json

@@ -0,0 +1,75 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "MimiUi",
+  "title": "Mimi ui",
+  "type": "object",
+  "properties": {
+    "components": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Componentes que se agregan (varios a la vez: button input form-field).",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": {
+        "message": "¿Qué componentes quieres agregar?",
+        "type": "list",
+        "multiselect": true,
+        "items": [
+          {
+            "value": "avatar",
+            "label": "avatar"
+          },
+          {
+            "value": "badge",
+            "label": "badge"
+          },
+          {
+            "value": "button",
+            "label": "button"
+          },
+          {
+            "value": "card",
+            "label": "card"
+          },
+          {
+            "value": "checkbox",
+            "label": "checkbox"
+          },
+          {
+            "value": "form-field",
+            "label": "form-field"
+          },
+          {
+            "value": "input",
+            "label": "input"
+          },
+          {
+            "value": "separator",
+            "label": "separator"
+          },
+          {
+            "value": "skeleton",
+            "label": "skeleton"
+          },
+          {
+            "value": "switch",
+            "label": "switch"
+          },
+          {
+            "value": "textarea",
+            "label": "textarea"
+          }
+        ]
+      }
+    },
+    "overwrite": {
+      "type": "boolean",
+      "default": false,
+      "description": "Reemplaza los archivos que ya existan con otro contenido."
+    }
+  }
+}

package/dist/utils/project.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIMI_COLLECTION = void 0;
+exports.readJson = readJson;
+exports.allDependencies = allDependencies;
+exports.majorOf = majorOf;
+const schematics_1 = require("@angular-devkit/schematics");
+/** Nombre de esta colección (el paquete). */
+exports.MIMI_COLLECTION = '@mimi-ng/cli';
+function readJson(tree, path) {
+    if (!tree.exists(path))
+        return null;
+    try {
+        return JSON.parse(tree.readText(path));
+    }
+    catch {
+        throw new schematics_1.SchematicsException(`${path} no es un JSON válido.`);
+    }
+}
+/** Dependencias y devDependencies juntas. */
+function allDependencies(pkg) {
+    return { ...pkg?.devDependencies, ...pkg?.dependencies };
+}
+/** `^22.1.0`, `~22.0.0`, `>=22`, `22.1.0` → 22. `latest` → null. */
+function majorOf(range) {
+    const match = range ? /(\d+)/.exec(range) : null;
+    return match ? Number(match[1]) : null;
+}

package/dist/utils/write-files.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasFileChanges = exports.emptyReport = exports.MANIFEST = exports.BASE_DIR = void 0;
+exports.projectPathOf = projectPathOf;
+exports.basePathOf = basePathOf;
+exports.writeTemplates = writeTemplates;
+exports.compareVersions = compareVersions;
+exports.updatedMessages = updatedMessages;
+const schematics_1 = require("@angular-devkit/schematics");
+/** Carpeta de las copias originales, en la raíz del workspace. Debe quedar en git. */
+exports.BASE_DIR = '.mimi/base';
+/** Versión de Mimi con la que se escribió la base de cada archivo. */
+exports.MANIFEST = '.mimi/manifest.json';
+const emptyReport = () => ({
+    created: [],
+    overwritten: [],
+    updated: [],
+    unchanged: [],
+    skipped: [],
+});
+exports.emptyReport = emptyReport;
+/** ¿El reporte tiene cambios en archivos del proyecto? */
+const hasFileChanges = (report) => report.created.length + report.overwritten.length + report.updated.length > 0;
+exports.hasFileChanges = hasFileChanges;
+/**
+ * Ruta de un archivo de las plantillas dentro de la carpeta de componentes del proyecto. Los
+ * componentes pierden `components/` para que `@/components/ui/button` apunte a
+ * `<carpeta>/button` (`components/button/button.ts` → `button/button.ts`); utils y tema
+ * conservan su carpeta (`utils/cn.ts`, `theme/theme-base.css`).
+ */
+function projectPathOf(file) {
+    return file.replace(/^components\//, '');
+}
+/** Copia original en .mimi/base, con la misma estructura (`.mimi/base/button/button.ts`). */
+function basePathOf(file) {
+    return `${exports.BASE_DIR}/${projectPathOf(file)}`;
+}
+function readManifest(tree) {
+    if (!tree.exists(exports.MANIFEST))
+        return { files: {} };
+    try {
+        const parsed = JSON.parse(tree.readText(exports.MANIFEST));
+        return { files: { ...parsed.files } };
+    }
+    catch {
+        return { files: {} };
+    }
+}
+/**
+ * Copia archivos de las plantillas del paquete (`dist/templates`, rutas relativas a esa
+ * carpeta) a `componentsDir`, revisando el árbol antes de escribir. Si el archivo ya existe:
+ *
+ * - igual a la plantilla → al día;
+ * - igual a su base en `.mimi/base/` → el usuario no lo tocó. Si la base es de esta versión,
+ *   la diferencia con la plantilla es solo de formato (la CLI de Angular pasa el Prettier del
+ *   proyecto por lo que escriben los schematics): al día. Si es de una versión anterior, se
+ *   actualiza;
+ * - distinto de su base, o sin base → modificado por el usuario: se omite (o se reemplaza con
+ *   `overwrite`).
+ *
+ * Nunca deja que mergeWith encuentre un archivo existente ("merge conflicted"). Guarda la base
+ * y su versión en `.mimi/manifest.json` siempre que el archivo quede igual a la plantilla; si se
+ * omitió por estar modificado, su base no cambia.
+ */
+function writeTemplates(options) {
+    const files = new Set(options.files);
+    return (tree) => {
+        const manifest = readManifest(tree);
+        let manifestChanged = false;
+        const writeBase = (file, content) => {
+            const base = basePathOf(file);
+            if (!tree.exists(base))
+                tree.create(base, content);
+            else if (tree.readText(base) !== content)
+                tree.overwrite(base, content);
+            const key = projectPathOf(file);
+            if (manifest.files[key] !== options.version) {
+                manifest.files[key] = options.version;
+                manifestChanged = true;
+            }
+        };
+        const copy = (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)('../templates'), [
+            (0, schematics_1.filter)((path) => files.has(path.replace(/^\//, ''))),
+            (0, schematics_1.forEach)((entry) => {
+                const file = entry.path.replace(/^\//, '');
+                const target = `${options.componentsDir}/${projectPathOf(file)}`;
+                const base = basePathOf(file);
+                const content = entry.content.toString('utf8');
+                if (!tree.exists(target)) {
+                    tree.create(target, content);
+                    options.report.created.push(file);
+                    writeBase(file, content);
+                    return null;
+                }
+                const current = tree.readText(target);
+                if (current === content) {
+                    options.report.unchanged.push(file);
+                    writeBase(file, content);
+                }
+                else if (tree.exists(base) && tree.readText(base) === current) {
+                    const from = manifest.files[projectPathOf(file)] ?? null;
+                    if (from === options.version) {
+                        // Mismo contenido que escribió Mimi, solo con otro formato.
+                        options.report.unchanged.push(file);
+                    }
+                    else {
+                        tree.overwrite(target, content);
+                        options.report.updated.push({ file, from });
+                        writeBase(file, content);
+                    }
+                }
+                else if (options.overwrite) {
+                    tree.overwrite(target, content);
+                    options.report.overwritten.push(file);
+                    writeBase(file, content);
+                }
+                else {
+                    options.report.skipped.push(file);
+                }
+                // Todo se escribe arriba, en el árbol del proyecto: nada llega a mergeWith.
+                return null;
+            }),
+        ]));
+        const saveManifest = (t) => {
+            if (!manifestChanged)
+                return;
+            const sorted = Object.fromEntries(Object.entries(manifest.files).sort());
+            const text = `${JSON.stringify({ files: sorted }, null, 2)}\n`;
+            if (t.exists(exports.MANIFEST))
+                t.overwrite(exports.MANIFEST, text);
+            else
+                t.create(exports.MANIFEST, text);
+        };
+        return (0, schematics_1.chain)([copy, saveManifest]);
+    };
+}
+/** Compara versiones `x.y.z` numéricamente (`0.10.0` > `0.9.0`). `null` es la más vieja. */
+function compareVersions(a, b) {
+    if (a === b)
+        return 0;
+    if (a === null)
+        return -1;
+    if (b === null)
+        return 1;
+    const pa = a.split(/[.-]/).map((n) => Number.parseInt(n, 10) || 0);
+    const pb = b.split(/[.-]/).map((n) => Number.parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+/**
+ * «button actualizado de 0.1.0 a 0.2.0», uno por ítem (con la versión más vieja de sus
+ * archivos). `itemOf` dice a qué ítem del registro pertenece cada archivo.
+ */
+function updatedMessages(report, itemOf, version) {
+    const oldest = new Map();
+    for (const { file, from } of report.updated) {
+        const item = itemOf(file);
+        const previous = oldest.get(item);
+        if (!oldest.has(item) || compareVersions(from, previous ?? null) < 0)
+            oldest.set(item, from);
+    }
+    return [...oldest].map(([item, from]) => `${item} actualizado de ${from ?? 'una versión anterior'} a ${version}`);
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@mimi-ng/cli",
+  "version": "0.1.0",
+  "description": "Angular + Tailwind CSS 4 UI components that a CLI copies into your project, so you own the code. Schematics for ng add and ng generate.",
+  "keywords": [
+    "angular",
+    "angular-components",
+    "tailwind",
+    "tailwindcss",
+    "tailwindcss-v4",
+    "ui",
+    "ui-components",
+    "component-library",
+    "design-system",
+    "schematics",
+    "ng-add",
+    "shadcn",
+    "mimi"
+  ],
+  "homepage": "https://ng.mimiworks.dev",
+  "bugs": {
+    "url": "https://github.com/nuki23/mimi-ng/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nuki23/mimi-ng.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "Ariel O (https://github.com/nuki23)",
+  "type": "commonjs",
+  "engines": {
+    "node": "^22.22.3 || ^24.15.0 || >=26.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "schematics": "./dist/collection.json",
+  "ng-add": {
+    "save": "devDependencies"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "dependencies": {
+    "@angular-devkit/core": "^22.0.0",
+    "@angular-devkit/schematics": "^22.0.0",
+    "@schematics/angular": "^22.0.0"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs"
+  }
+}