@ingcrea/aumic-tailwind-killer 4.1.4 → 4.1.6

package/README.es.md

@@ -380,3 +380,15 @@ Para organizaciones con monorepos de gran escala, **INGENIERÍA CREATIVA Y DESAR
 ---
 
 > Desarrollado bajo la estándar tecnológica de **INGENIERÍA CREATIVA Y DESARROLLOS TECNOLÓGICOS S.A.S.** Excelencia, Determinismo y Zero-Trust.
+
+
+### 🛡️ Seguridad Zero-Trust y Arquitectura AUM-IC (v4.1.6)
+A partir de la versión 4.1.5, el compilador AUM-IC Tailwind Killer ha sido reescrito desde cero utilizando nuestra propia **Arquitectura Cósmica AUM-IC (Átomos a Galaxias)**. 
+- **Desintegración del Monolito:** El núcleo ha sido purificado en 6 capas de abstracción (Átomos, Moléculas, Células, Organismos, Ecosistemas y Galaxias), promoviendo mantenibilidad y separación de responsabilidades a niveles fractales.
+- **Modelo de Ejecución Zero-Trust:** Hemos erradicado TODAS las instancias de child_process.exec y execSync. Ahora, toda ejecución nativa opera estrictamente bajo spawn/spawnSync puro, pasando los argumentos como arreglos inmutables y deshabilitando intérpretes de shell. Esto cierra definitivamente cualquier vector de Command Injection (OWASP A03:2021) en la herramienta. AUM-IC es intrínsecamente seguro por diseño.
+
+
+### 🛡️ Seguridad Zero-Trust y Arquitectura AUM-IC (v4.1.6)
+A partir de la versión 4.1.5, el compilador AUM-IC Tailwind Killer ha sido reescrito desde cero utilizando nuestra propia **Arquitectura Cósmica AUM-IC (Átomos a Galaxias)**. 
+- **Desintegración del Monolito:** El núcleo ha sido purificado en 6 capas de abstracción (Átomos, Moléculas, Células, Organismos, Ecosistemas y Galaxias), promoviendo mantenibilidad y separación de responsabilidades a niveles fractales.
+- **Modelo de Ejecución Zero-Trust:** Hemos erradicado TODAS las instancias de child_process.exec y execSync. Ahora, toda ejecución nativa opera estrictamente bajo spawn/spawnSync puro, pasando los argumentos como arreglos inmutables y deshabilitando intérpretes de shell. Esto cierra definitivamente cualquier vector de Command Injection (OWASP A03:2021) en la herramienta. AUM-IC es intrínsecamente seguro por diseño.

package/README.md

@@ -422,3 +422,15 @@ For organizations with large-scale monorepos, **INGENIERÍA CREATIVA Y DESARROLL
 ---
 
 > Developed under the technological standard of **INGENIERÍA CREATIVA Y DESARROLLOS TECNOLÓGICOS S.A.S.** Excellence, Determinism and Zero-Trust.
+
+
+### 🛡️ Seguridad Zero-Trust y Arquitectura AUM-IC (v4.1.6)
+A partir de la versión 4.1.5, el compilador AUM-IC Tailwind Killer ha sido reescrito desde cero utilizando nuestra propia **Arquitectura Cósmica AUM-IC (Átomos a Galaxias)**. 
+- **Desintegración del Monolito:** El núcleo ha sido purificado en 6 capas de abstracción (Átomos, Moléculas, Células, Organismos, Ecosistemas y Galaxias), promoviendo mantenibilidad y separación de responsabilidades a niveles fractales.
+- **Modelo de Ejecución Zero-Trust:** Hemos erradicado TODAS las instancias de child_process.exec y execSync. Ahora, toda ejecución nativa opera estrictamente bajo spawn/spawnSync puro, pasando los argumentos como arreglos inmutables y deshabilitando intérpretes de shell. Esto cierra definitivamente cualquier vector de Command Injection (OWASP A03:2021) en la herramienta. AUM-IC es intrínsecamente seguro por diseño.
+
+
+### 🛡️ Seguridad Zero-Trust y Arquitectura AUM-IC (v4.1.6)
+A partir de la versión 4.1.5, el compilador AUM-IC Tailwind Killer ha sido reescrito desde cero utilizando nuestra propia **Arquitectura Cósmica AUM-IC (Átomos a Galaxias)**. 
+- **Desintegración del Monolito:** El núcleo ha sido purificado en 6 capas de abstracción (Átomos, Moléculas, Células, Organismos, Ecosistemas y Galaxias), promoviendo mantenibilidad y separación de responsabilidades a niveles fractales.
+- **Modelo de Ejecución Zero-Trust:** Hemos erradicado TODAS las instancias de child_process.exec y execSync. Ahora, toda ejecución nativa opera estrictamente bajo spawn/spawnSync puro, pasando los argumentos como arreglos inmutables y deshabilitando intérpretes de shell. Esto cierra definitivamente cualquier vector de Command Injection (OWASP A03:2021) en la herramienta. AUM-IC es intrínsecamente seguro por diseño.

package/dist/1_atoms/constants.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * [EN] Immutable constants that form the AUM-IC transmutation vocabulary.
+ * [ES] Constantes inmutables que forman el vocabulario de transmutación AUM-IC.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEVEL_PREFIX = exports.COMPONENT_ALIASES = exports.TAILWIND_SNIPER_REGEX = void 0;
+/** [EN] O(n) pre-filter: quickly confirms Tailwind presence before invoking the Babel AST pipeline. [ES] Pre-filtro O(n): confirma rápidamente la presencia de Tailwind antes de invocar el pipeline AST Babel. */
+exports.TAILWIND_SNIPER_REGEX = /(class(Name)?=|className:|\b(sm:|md:|lg:|xl:|2xl:|hover:|focus:|active:|disabled:|dark:|flex\b|grid\b|block\b|hidden\b|absolute\b|relative\b|bg-[a-z]+-\d{1,3}|text-[a-z]+-\d{1,3}|p[xytrbl]?-\d|m[xytrbl]?-\d|w-\d|h-\d|gap-\d|border|rounded|shadow|z-\d0|opacity-\d{2}|leading-|tracking-)|@apply|@tailwind)/;
+/** [EN] Maps component file names to AUM-IC abbreviated identifiers for class generation. [ES] Mapea nombres de archivo de componentes a identificadores abreviados AUM-IC para la generación de clases. */
+exports.COMPONENT_ALIASES = {
+    button: 'btn', icon: 'icon', input: 'input', badge: 'badge',
+    link: 'link', label: 'lbl', card: 'card', form: 'form',
+    dropdown: 'drop', menu: 'menu', list: 'list', modal: 'modal',
+    header: 'header', footer: 'footer', sidebar: 'sidebar', hero: 'hero',
+    table: 'table', nav: 'nav', main: 'main', section: 'section',
+    article: 'article', page: 'page', layout: 'layout', index: 'page',
+    pricing: 'pricing', trust: 'trust', features: 'features', ecosystem: 'eco',
+    teaser: 'teaser', banner: 'banner', toast: 'toast', chip: 'chip',
+    avatar: 'avatar', tag: 'tag',
+};
+/** [EN] Maps AUM-IC structural categories to their class name prefixes. [ES] Mapea categorías estructurales AUM-IC a sus prefijos de nombre de clase. */
+exports.LEVEL_PREFIX = {
+    atoms: 'atom', molecules: 'molecule', organisms: 'organism',
+    ecosystems: 'ecosystem', galaxies: 'galaxy',
+};

package/dist/1_atoms/hash.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHash = getHash;
+exports.escapeCssSelector = escapeCssSelector;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * [EN] Deterministic 6-char hex hash for reproducible AUM-IC class identifiers.
+ * [ES] Hash hex determinista de 6 chars para identificadores de clase AUM-IC reproducibles.
+ */
+function getHash(str) {
+    return crypto_1.default.createHash('shake256', { outputLength: 3 }).update(str).digest('hex');
+}
+/**
+ * [EN] Escapes a string for safe use as a CSS class selector.
+ * [ES] Escapa un string para uso seguro como selector de clase CSS.
+ */
+function escapeCssSelector(className) {
+    return className.replace(/[^a-zA-Z0-9_-]/g, '\\$&');
+}

package/dist/1_atoms/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * [EN] Core type definitions — the most primitive building blocks.
+ * [ES] Definiciones de tipos fundamentales — los bloques de construcción más primitivos.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/2_molecules/classifier.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyComponent = classifyComponent;
+/**
+ * [EN] Component classifier: maps a file name to its AUM-IC structural tier.
+ * [ES] Clasificador de componentes: mapea un nombre de archivo a su nivel estructural AUM-IC.
+ */
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../1_atoms/constants");
+/** [EN] Classifies a file into its AUM-IC tier using alias lookup then regex patterns. [ES] Clasifica un archivo en su nivel AUM-IC usando búsqueda de alias y luego patrones regex. */
+function classifyComponent(fileName) {
+    const name = path_1.default.basename(fileName, path_1.default.extname(fileName)).toLowerCase();
+    if (constants_1.COMPONENT_ALIASES[name]) {
+        const comp = constants_1.COMPONENT_ALIASES[name];
+        if (/(button|icon|input|badge|link|label)/.test(name))
+            return { category: 'atoms', component: comp };
+        if (/(card|form|dropdown|menu|list|modal)/.test(name))
+            return { category: 'molecules', component: comp };
+        if (/(header|footer|sidebar|hero|table|nav)/.test(name))
+            return { category: 'organisms', component: comp };
+        return { category: 'ecosystems', component: comp };
+    }
+    const comp = name.replace(/[^a-z0-9]/g, '').slice(0, 8) || 'comp';
+    if (/(button|btn|icon|input|badge|link|label|chip|tag|avatar)/.test(name))
+        return { category: 'atoms', component: comp };
+    if (/(card|form|dropdown|drop|menu|list|modal|toast|banner)/.test(name))
+        return { category: 'molecules', component: comp };
+    if (/(header|footer|sidebar|hero|table|nav|pricing|trust|features|teaser|rmm|cta)/.test(name))
+        return { category: 'organisms', component: comp };
+    if (/(main|section|article|page|layout|index)/.test(name))
+        return { category: 'ecosystems', component: comp };
+    if (/(app|root|core|galaxy|global|provider)/.test(name))
+        return { category: 'galaxies', component: comp };
+    return { category: 'molecules', component: comp };
+}

package/dist/2_molecules/concurrency.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runConcurrent = runConcurrent;
+/**
+ * [EN] Bounded concurrent task runner. Processes items in parallel up to the configured worker limit.
+ * [ES] Ejecutor de tareas concurrentes acotado. Procesa ítems en paralelo hasta el límite configurado.
+ */
+async function runConcurrent(items, concurrency, task) {
+    const results = [];
+    const iterator = items.entries();
+    const workers = Array(concurrency).fill(iterator).map(async (iter) => {
+        for (const [index, item] of iter) {
+            results[index] = await task(item);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/dist/3_cells/AiEngine.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIEngine = void 0;
+class AIEngine {
+    provider;
+    apiKey;
+    model;
+    constructor(provider, apiKey, model) {
+        this.provider = provider;
+        this.apiKey = apiKey;
+        this.model = model || this.getDefaultModel(provider);
+    }
+    /** [EN] Canonical default model for each provider. [ES] Modelo predeterminado canónico por proveedor. */
+    getDefaultModel(provider) {
+        const map = {
+            openai: 'gpt-4o-mini', deepseek: 'deepseek-chat', xai: 'grok-beta',
+            alibaba: 'qwen-turbo', claude: 'claude-3-haiku-20240307',
+            gemini: 'gemini-1.5-flash', ollama: 'llama3',
+        };
+        return map[provider] || 'gpt-4o-mini';
+    }
+    /** [EN] Base endpoint URL per provider. [ES] URL de endpoint base por proveedor. */
+    getProviderBaseUrl(provider) {
+        const map = {
+            openai: 'https://api.openai.com/v1/chat/completions',
+            deepseek: 'https://api.deepseek.com/chat/completions',
+            xai: 'https://api.x.ai/v1/chat/completions',
+            alibaba: 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions',
+            ollama: 'http://127.0.0.1:11434/api/generate',
+        };
+        return map[provider] || '';
+    }
+    /**
+     * [EN] Dispatches the naming request to the correct provider and returns a normalized mapping.
+     * [ES] Despacha la solicitud de nombrado al proveedor correcto y devuelve un mapeo normalizado.
+     */
+    async generateSemanticNames(request) {
+        let sys = "Eres un Arquitecto CSS AUM-IC. Te daré un array JSON de cadenas de utilidades de Tailwind. Devuelve un objeto JSON donde la clave es la cadena exacta de Tailwind, y el valor es un nombre de clase semántico BEM corto que empiece con 'aumic-'. Responde ÚNICAMENTE con el objeto JSON válido.";
+        if (request.customRules)
+            sys += `\n\nREGLAS PERSONALIZADAS:\n${request.customRules}\nDEBES DAR PRIORIDAD ABSOLUTA A ESTAS REGLAS.`;
+        const user = JSON.stringify(request.utilities);
+        let raw = '';
+        if (['openai', 'deepseek', 'xai', 'alibaba'].includes(this.provider))
+            raw = await this.callOpenAICompatible(sys, user);
+        else if (this.provider === 'gemini')
+            raw = await this.callGemini(sys, user);
+        else if (this.provider === 'claude')
+            raw = await this.callClaude(sys, user);
+        else if (this.provider === 'ollama')
+            raw = await this.callOllama(sys, user);
+        else
+            throw new Error(`Proveedor ${this.provider} no implementado.`);
+        try {
+            // [EN] Strip markdown fences — some LLMs ignore the plain-JSON instruction.
+            // [ES] Eliminar bloques markdown — algunos LLMs ignoran la instrucción de JSON plano.
+            return { mapping: JSON.parse(raw.replace(/```json/g, '').replace(/```/g, '').trim()) };
+        }
+        catch {
+            return { mapping: {} };
+        }
+    }
+    /** [EN] Adapter for OpenAI-compatible REST APIs. [ES] Adaptador para APIs REST compatibles con OpenAI. */
+    async callOpenAICompatible(sys, user) {
+        const res = await fetch(this.getProviderBaseUrl(this.provider), {
+            method: 'POST', headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` },
+            body: JSON.stringify({ model: this.model, messages: [{ role: 'system', content: sys }, { role: 'user', content: user }], temperature: 0.1 })
+        });
+        if (!res.ok)
+            throw new Error(`[IA] HTTP ${res.status}: ${await res.text()}`);
+        return (await res.json()).choices[0].message.content;
+    }
+    /** [EN] Adapter for Google Gemini. [ES] Adaptador para Google Gemini. */
+    async callGemini(sys, user) {
+        const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${this.model}:generateContent?key=${this.apiKey}`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ system_instruction: { parts: { text: sys } }, contents: [{ parts: [{ text: user }] }], generationConfig: { temperature: 0.1 } })
+        });
+        if (!res.ok)
+            throw new Error(`[IA] HTTP ${res.status}: ${await res.text()}`);
+        return (await res.json()).candidates[0].content.parts[0].text;
+    }
+    /** [EN] Adapter for Anthropic Claude. [ES] Adaptador para Anthropic Claude. */
+    async callClaude(sys, user) {
+        const res = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST', headers: { 'Content-Type': 'application/json', 'x-api-key': this.apiKey, 'anthropic-version': '2023-06-01' },
+            body: JSON.stringify({ model: this.model, system: sys, messages: [{ role: 'user', content: user }], temperature: 0.1, max_tokens: 4096 })
+        });
+        if (!res.ok)
+            throw new Error(`[IA] HTTP ${res.status}: ${await res.text()}`);
+        return (await res.json()).content[0].text;
+    }
+    /** [EN] Adapter for self-hosted Ollama. [ES] Adaptador para Ollama auto-hospedado. */
+    async callOllama(sys, user) {
+        const res = await fetch(this.getProviderBaseUrl(this.provider), {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ model: this.model, system: sys, prompt: user, stream: false, options: { temperature: 0.1 } })
+        });
+        if (!res.ok)
+            throw new Error(`[IA] Ollama HTTP ${res.status}: ¿Está corriendo Ollama?`);
+        return (await res.json()).response;
+    }
+}
+exports.AIEngine = AIEngine;

package/dist/3_cells/DuckDbCache.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryL1Cache = queryL1Cache;
+/**
+ * [EN] Queries the bundled DuckDB lexicon. Unresolved classes are forwarded to the L2 JIT compiler.
+ * [ES] Consulta el léxico DuckDB incluido. Las clases no resueltas se reenvían al compilador JIT L2.
+ */
+async function queryL1Cache(classes, version, dbPath) {
+    const duckdb = require('duckdb');
+    const db = new duckdb.Database(dbPath);
+    let css = '';
+    const unresolved = new Set();
+    await Promise.all(classes.map(cls => new Promise(resolve => {
+        db.all('SELECT css FROM tw_lexicon WHERE version = ? AND class = ?', [version, cls], (err, rows) => {
+            if (err || rows.length === 0)
+                unresolved.add(cls);
+            else
+                css += `\n/* tw: ${cls} (L1) */\n.${cls} { ${rows[0].css} }\n`;
+            resolve();
+        });
+    })));
+    db.close();
+    return { css, unresolved };
+}

package/dist/3_cells/WebCloner.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebCloner = void 0;
+/**
+ * [EN] Web Cloner cell: network I/O handler for Forensic Mode.
+ * [ES] Célula Clonador Web: manejador I/O de red para el Modo Forense.
+ */
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+// @ts-ignore
+const website_scraper_1 = __importDefault(require("website-scraper"));
+const picocolors_1 = __importDefault(require("picocolors"));
+class WebCloner {
+    /**
+     * [EN] Downloads and mirrors a URL. Rewrites all asset paths for offline use.
+     * [ES] Descarga y espeja una URL. Reescribe rutas de assets para uso offline.
+     */
+    static async cloneWebsite(url, outputDir, cloneDepth) {
+        if (await fs_extra_1.default.pathExists(outputDir))
+            await fs_extra_1.default.emptyDir(outputDir);
+        const options = {
+            urls: [url], directory: outputDir,
+            sources: [
+                { selector: 'img', attr: 'src' }, { selector: 'link[rel="stylesheet"]', attr: 'href' },
+                { selector: 'script', attr: 'src' }, { selector: 'source', attr: 'src' },
+                { selector: 'source', attr: 'srcset' }, { selector: 'img', attr: 'srcset' }
+            ],
+            recursive: cloneDepth === 'site', maxDepth: cloneDepth === 'site' ? 5 : 1, ignoreErrors: true
+        };
+        try {
+            await (0, website_scraper_1.default)(options);
+        }
+        catch (error) {
+            console.error(picocolors_1.default.red(`\n[!] Error durante la clonación: ${error}`));
+            throw error;
+        }
+    }
+    /**
+     * [EN] Scans HTML files for Tailwind atomic signatures. Returns true on confirmation.
+     * [ES] Escanea archivos HTML en busca de firmas atómicas Tailwind. Devuelve true al confirmar.
+     */
+    static async isTailwindPowered(outputDir) {
+        const files = (await fs_extra_1.default.readdir(outputDir)).filter(f => f.endsWith('.html'));
+        const sigs = ['flex', 'grid', 'w-full', 'h-full', 'absolute', 'relative', 'bg-', 'text-', 'p-4', 'm-'];
+        let score = 0;
+        for (const file of files) {
+            const c = await fs_extra_1.default.readFile(path_1.default.join(outputDir, file), 'utf-8');
+            for (const sig of sigs) {
+                if (c.includes(`"${sig}`))
+                    score++;
+                if (c.includes(` ${sig}`))
+                    score++;
+            }
+        }
+        return score >= 5;
+    }
+}
+exports.WebCloner = WebCloner;

package/dist/4_organisms/AstParser.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstInterceptor = void 0;
+/**
+ * [EN] AST Interception Organism — the core transmutation engine.
+ *      Routes files through Babel AST (JSX/TSX) or Universal Regex (HTML/templates).
+ *      Supports forward (Tailwind→AUM-IC) and reverse (rollback) passes.
+ * [ES] Organismo de Intercepción AST — el motor principal de transmutación.
+ *      Enruta archivos por Babel AST (JSX/TSX) o Regex Universal (HTML/plantillas).
+ *      Soporta pases directo (Tailwind→AUM-IC) e inverso (rollback).
+ */
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const generator_1 = __importDefault(require("@babel/generator"));
+class AstInterceptor {
+    /**
+     * [EN] Public router: delegates to Babel or Regex based on file extension.
+     *      `replacerFn` receives a class string and returns the replacement.
+     *      Set `isRestore = true` to enable reverse (rollback) mode.
+     * [ES] Enrutador público: delega a Babel o Regex según la extensión del archivo.
+     *      `replacerFn` recibe un string de clase y devuelve el reemplazo.
+     *      Establece `isRestore = true` para el modo inverso (rollback).
+     */
+    processFrameworkFile(code, fileName, replacerFn, isRestore = false) {
+        const ext = fileName.split('.').pop()?.toLowerCase();
+        return ['jsx', 'tsx', 'js', 'ts'].includes(ext || '')
+            ? this.processWithBabel(code, replacerFn, isRestore)
+            : this.processWithUniversalRegex(code, replacerFn, isRestore);
+    }
+    /**
+     * [EN] Universal Regex engine for non-JS templates.
+     *      Phase 1 extracts class strings; Phase 2 mutates via replacerFn callback.
+     * [ES] Motor Regex Universal para plantillas no-JS.
+     *      La Fase 1 extrae strings de clase; la Fase 2 muta mediante el callback replacerFn.
+     */
+    processWithUniversalRegex(code, replacerFn, isRestore) {
+        const extracted = new Set();
+        const classRegex = /(class|className|class:list)\s*(=|:)\s*(["'`])(.*?)\3/gs;
+        let match;
+        while ((match = classRegex.exec(code)) !== null) {
+            const clean = match[4].replace(/\s+/g, ' ').trim();
+            if (clean && (isRestore || !clean.includes('aumic-')))
+                extracted.add(clean);
+        }
+        const newCode = code.replace(classRegex, (full, attr, sep, q, cls) => {
+            const clean = cls.replace(/\s+/g, ' ').trim();
+            if (!clean || (!isRestore && clean.includes('aumic-')))
+                return full;
+            return `${attr}${sep}${q}${replacerFn(clean)}${q}`;
+        });
+        return { newCode, extractedClasses: Array.from(extracted) };
+    }
+    /**
+     * [EN] Babel AST engine for JSX/TSX. Visits JSXAttribute nodes (className/class)
+     *      and CallExpression nodes (clsx, cva, cn, twMerge). Preserves original line numbers.
+     * [ES] Motor AST Babel para JSX/TSX. Visita nodos JSXAttribute (className/class)
+     *      y CallExpression (clsx, cva, cn, twMerge). Preserva números de línea originales.
+     */
+    processWithBabel(code, replacerFn, isRestore) {
+        const ast = (0, parser_1.parse)(code, { sourceType: 'module', plugins: ['jsx', 'typescript'] });
+        const extracted = new Set();
+        const traverseAst = traverse_1.default.default || traverse_1.default;
+        const fn = replacerFn; // Capture outside Babel visitors to avoid closure loss
+        traverseAst(ast, {
+            CallExpression(path) {
+                if (['clsx', 'cva', 'cn', 'twMerge', 'classNames'].includes(path.node.callee.name)) {
+                    path.traverse({
+                        StringLiteral(p) {
+                            const c = p.node.value.replace(/\s+/g, ' ').trim();
+                            if (c && (isRestore || !c.includes('aumic-'))) {
+                                extracted.add(c);
+                                p.node.value = fn(c);
+                            }
+                        },
+                        TemplateElement(p) {
+                            const c = p.node.value.raw.replace(/\s+/g, ' ').trim();
+                            if (c && (isRestore || !c.includes('aumic-'))) {
+                                extracted.add(c);
+                                p.node.value.raw = fn(c);
+                                p.node.value.cooked = p.node.value.raw;
+                            }
+                        }
+                    });
+                }
+            },
+            JSXAttribute(path) {
+                if (['className', 'class'].includes(path.node.name.name)) {
+                    path.traverse({
+                        StringLiteral(p) {
+                            const c = p.node.value.replace(/\s+/g, ' ').trim();
+                            if (c && (isRestore || !c.includes('aumic-'))) {
+                                extracted.add(c);
+                                p.node.value = fn(c);
+                            }
+                        },
+                        TemplateElement(p) {
+                            const c = p.node.value.raw.replace(/\s+/g, ' ').trim();
+                            if (c && (isRestore || !c.includes('aumic-'))) {
+                                extracted.add(c);
+                                p.node.value.raw = fn(c);
+                                p.node.value.cooked = p.node.value.raw;
+                            }
+                        }
+                    });
+                }
+            }
+        });
+        const genCode = generator_1.default.default || generator_1.default;
+        const out = genCode(ast, { retainLines: true }, code);
+        return { newCode: out.code, extractedClasses: Array.from(extracted) };
+    }
+}
+exports.AstInterceptor = AstInterceptor;

package/dist/5_ecosystems/RestoreEcosystem.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRestoreEcosystem = runRestoreEcosystem;
+/**
+ * [EN] Restore Ecosystem: orchestrates a full rollback of an AUM-IC transmutation.
+ *      Reads the aumic-lock.json manifest, restores original class strings via AST,
+ *      reinstates original package.json and Tailwind config files, and re-runs npm install.
+ * [ES] Ecosistema de Restauración: orquesta el rollback completo de una transmutación AUM-IC.
+ *      Lee el manifiesto aumic-lock.json, restaura los strings de clase originales vía AST,
+ *      restablece el package.json y los archivos de config de Tailwind originales, y re-ejecuta npm install.
+ */
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const ora_1 = __importDefault(require("ora"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const glob_1 = require("glob");
+const child_process_1 = require("child_process");
+const AstParser_1 = require("../4_organisms/AstParser");
+const astEngine = new AstParser_1.AstInterceptor();
+/**
+ * [EN] Entry point for the restore pipeline. Validates lock file existence,
+ *      runs the AST reverse pass on all source files, and restores project dependencies.
+ * [ES] Punto de entrada del pipeline de restauración. Valida la existencia del lock file,
+ *      ejecuta el pase inverso AST en todos los archivos fuente, y restaura las dependencias del proyecto.
+ */
+async function runRestoreEcosystem(targetDir) {
+    const lockPath = path_1.default.join(targetDir, 'aumic-lock.json');
+    if (!fs_extra_1.default.existsSync(lockPath)) {
+        console.log(picocolors_1.default.red('\n[X] Error: No se encontró aumic-lock.json. Imposible restaurar.\n'));
+        return;
+    }
+    const spinner = (0, ora_1.default)('Modo Restauración: Leyendo aumic-lock.json...').start();
+    const lockData = await fs_extra_1.default.readJson(lockPath);
+    spinner.start('Restaurando clases en archivos fuente...');
+    const files = await (0, glob_1.glob)('**/*.{astro,tsx,jsx,html,py,rs,php,go,erb,svelte,vue}', {
+        cwd: targetDir, absolute: true,
+        ignore: ['node_modules/**', 'dist/**', '.git/**', 'target/**', '__pycache__/**', 'venv/**'],
+    });
+    let restoredCount = 0;
+    for (const file of files) {
+        const content = await fs_extra_1.default.readFile(file, 'utf-8');
+        try {
+            // [EN] Split multi-hash strings before lookup to handle concatenated hashes.
+            // [ES] Dividir strings con múltiples hashes antes de la búsqueda para manejar hashes concatenados.
+            const { newCode } = astEngine.processFrameworkFile(content, file, (twClass) => {
+                return twClass.split(' ').map(c => lockData[c] || c).join(' ');
+            }, true);
+            if (newCode !== content) {
+                await fs_extra_1.default.writeFile(file, newCode, 'utf-8');
+                restoredCount++;
+            }
+        }
+        catch { /* [EN] Skip unreadable or binary files silently. [ES] Ignorar silenciosamente archivos ilegibles o binarios. */ }
+    }
+    spinner.succeed(`Clases originales restauradas en ${restoredCount} archivos.`);
+    spinner.start('Restaurando dependencias y configuraciones...');
+    try {
+        // [EN] Restore package.json backup if it exists.
+        // [ES] Restaurar el respaldo de package.json si existe.
+        const pkgBak = path_1.default.join(targetDir, 'package.json.aumic-bak');
+        if (fs_extra_1.default.existsSync(pkgBak)) {
+            fs_extra_1.default.copyFileSync(pkgBak, path_1.default.join(targetDir, 'package.json'));
+            fs_extra_1.default.removeSync(pkgBak);
+        }
+        // [EN] Restore Tailwind config file backups.
+        // [ES] Restaurar los respaldos de archivos de configuración de Tailwind.
+        for (const conf of ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.cjs', 'tailwind.config.mjs']) {
+            const bak = path_1.default.join(targetDir, `${conf}.aumic-bak`);
+            if (fs_extra_1.default.existsSync(bak))
+                fs_extra_1.default.renameSync(bak, path_1.default.join(targetDir, conf));
+        }
+        // [EN] Spawn npm install as a direct binary — no shell interpolation (Zero-Trust execution).
+        // [ES] Levantar npm install como binario directo — sin interpolación de shell (ejecución Zero-Trust).
+        (0, child_process_1.spawnSync)(os_1.default.platform() === 'win32' ? 'npm.cmd' : 'npm', ['install'], { cwd: targetDir, stdio: 'ignore' });
+        spinner.succeed('Tailwind rehidratado. Dependencias y configuraciones restauradas.');
+    }
+    catch {
+        spinner.warn('Problema reinstalando dependencias desde el package.json restaurado.');
+    }
+    console.log(picocolors_1.default.green(picocolors_1.default.bold('\n[✔] PROYECTO RESTAURADO CON ÉXITO A SU ESTADO ORIGINAL.\n')));
+}