@ingcrea/aumic-tailwind-killer 3.1.4

package/README.md

@@ -0,0 +1,97 @@
+# ⚔️ AUM-IC Tailwind Killer
+
+**AUM-IC Tailwind Killer** es un orquestador CLI de alto rendimiento diseñado para **transmutar** proyectos basados en Tailwind CSS en ecosistemas de clases ofuscadas, deterministas y libres de dependencias (Zero-Bloat). 
+
+Desarrollado por el equipo de **Ingeniería Creativa (IngCrea)**, esta herramienta audita, extrae, compila (vía JIT) y purga tu código fuente en segundos gracias a su arquitectura multi-hilos (Piscina) e interceptores AST universales.
+
+---
+
+## ⚡ ¿Por qué usar AUM-IC Tailwind Killer?
+
+1. **Ofuscación y Seguridad Corporativa:** Transforma utilidades legibles (`flex items-center text-red-500`) en hashes seguros (`aumic-component-1b3a4f`), dificultando el scraping y el robo de diseño (UI/UX).
+2. **Independencia del Framework:** Erradica a Tailwind CSS de tu `package.json` y dependencias de build. Tu proyecto pasa a depender únicamente de un archivo `.css` nativo, estándar y ultra-optimizado.
+3. **Rendimiento Extremo (Build Time):** Al purgar el motor de Tailwind de tu flujo de trabajo, los tiempos de compilación de tu framework (Astro, Next.js, Vite) se reducen drásticamente.
+4. **Cero Riesgo de Corrupción:** Cuenta con escudos **Pre-Flight** que auditan los permisos NTFS/POSIX antes de tocar un solo archivo, evitando estados corruptos.
+
+---
+
+## 🚀 Instalación
+
+Puedes ejecutarlo al vuelo usando `npx` (recomendado) o instalarlo globalmente:
+
+```bash
+# Uso al vuelo mediante NPX
+npx @ingcrea/aumic-tailwind-killer -m local -t ./mi-proyecto
+
+# Instalación global
+npm install -g @ingcrea/aumic-tailwind-killer
+```
+
+---
+
+## 🛠 Casos de Uso y Ejemplos de Ejecución
+
+La herramienta opera bajo distintos **modos** de destrucción y auditoría. Asegúrate de estar en una rama de Git limpia (ej. `git checkout -b build-aumic`) antes de realizar mutaciones destructivas.
+
+### 1. Modo Simulación (Dry-Run)
+**Caso de uso:** Quieres auditar tu proyecto, ver cuántas clases de Tailwind usas y visualizar el impacto sin modificar tu código fuente. Ideal para auditorías previas.
+
+```bash
+npx @ingcrea/aumic-tailwind-killer -m simulate -t ./
+```
+* **Qué hace:** Escanea el código mediante el Motor Infrarrojo, extrae las utilidades, genera los hashes en RAM y emite un reporte visual detallado (`aumic-report.html`), pero **no altera** tus archivos.
+
+### 2. Modo Local (Transmutación Destructiva)
+**Caso de uso:** Estás listo para preparar tu código para producción. Deseas reemplazar todo Tailwind por CSS puro, reescribir tus componentes (`.astro`, `.tsx`, `.vue`, `.py`) y eliminar el framework.
+
+```bash
+npx @ingcrea/aumic-tailwind-killer -m local -t ./
+```
+* **Qué hace:** Ejecuta las 5 Fases de AUM-IC. Reescribe físicamente todos los archivos soportados, inyecta el CSS nativo unificado, elimina dependencias en `package.json` y genera un mapa reverso (`aumic-lock.json`).
+
+### 3. Modo Quirúrgico (Surgical Scope)
+**Caso de uso:** Tienes un monorepo gigante y solo quieres ofuscar una carpeta específica (ej. solo el frontend de marketing) ignorando el panel de administración.
+
+```bash
+npx @ingcrea/aumic-tailwind-killer -m local -t ./ -s "src/frontend/**/*.{tsx,astro}"
+```
+* **Qué hace:** Ignora el escáner global de Git y restringe la mutación **estrictamente** al patrón Glob (Regex) definido en el argumento `-s` (Scope).
+
+### 4. Modo Restauración (Rollback)
+**Caso de uso:** Algo falló durante el QA post-mutación o necesitas volver a trabajar con Tailwind en tu entorno local.
+
+```bash
+npx @ingcrea/aumic-tailwind-killer -m restore -t ./
+```
+* **Qué hace:** Lee el mapa criptográfico `aumic-lock.json`, revierte los hashes en tus archivos a sus clases Tailwind originales y restaura el `package.json.aumic-bak`.
+
+---
+
+## ⚙️ Banderas y Variables (CLI Options)
+
+| Bandera Corta | Bandera Larga | Descripción | Obligatorio |
+| :--- | :--- | :--- | :--- |
+| `-m` | `--mode` | Define el comportamiento del orquestador (`simulate`, `local`, `restore`, `clone`). | **Sí** |
+| `-t` | `--target` | Ruta absoluta o relativa al directorio del proyecto a procesar. | **Sí** |
+| `-s` | `--scope` | Patrón de búsqueda Glob para restringir la mutación a archivos específicos. | No |
+
+---
+
+## 🧠 Arquitectura de 5 Fases
+
+1. **Reconocimiento & Pre-Flight:** Validación exhaustiva de permisos W_OK (Anti-Zombie) y escaneo de árbol de dependencias mediante LS-Files de Git (Fast-Path).
+2. **Extracción Paralela (Babel + Regex):** Pool de workers en Node (Piscina) que analizan sintaxis de JSX, TSX y lenguajes agnósticos (Astro, Python, PHP) interceptando atributos de clase (`class`, `className`, `class:list`).
+3. **Criptografía de Nomenclatura:** Asignación de Hashes Deterministas (`aumic-component-[hash]`) optimizando la reusabilidad (deduplicación del 100%).
+4. **Motor JIT Embebido:** Generación virtual en memoria y renderizado de CSS de Tailwind usando compilación "Just In Time", fusionando todo en la base nativa.
+5. **Erradicación Total:** Purga de scripts, inyección del archivo CSS puro resultante y limpieza de configuraciones del framework original.
+
+---
+
+## 🛡 Consideraciones de Seguridad
+
+* **Backup Automático:** Siempre que la herramienta interviene archivos de configuración (`package.json`, `tailwind.config.js`), genera respaldos con la extensión `.aumic-bak`.
+* **Archivos Protegidos:** Por defecto, el motor ignora estrictamente agujeros negros como `node_modules`, `.git`, `dist`, y `.venv`.
+
+---
+
+> Desarrollado bajo la doctrina tecnológica de Ingeniería Creativa. Excelencia, Determinismo y Zero-Trust.

package/bin/aumic-killer.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const https = require('https');
+const { spawnSync } = require('child_process');
+
+// ==========================================
+// AUM-IC NATIVE WRAPPER
+// ==========================================
+const VERSION = require('../package.json').version;
+const GITHUB_REPO = 'ingcrea/aumic-tailwind-killer'; // <-- AJUSTA EL REPOSITORIO AQUÍ SI ES NECESARIO
+
+const PLATFORM_MAP = {
+    win32: 'win',
+    linux: 'linux',
+    darwin: 'macos'
+};
+
+const ARCH_MAP = {
+    x64: 'x64',
+    arm64: 'arm64'
+};
+
+const osName = PLATFORM_MAP[os.platform()];
+const osArch = ARCH_MAP[os.arch()];
+
+if (!osName || !osArch) {
+    console.error(`❌ [AUM-IC] Arquitectura no soportada: ${os.platform()}-${os.arch()}`);
+    process.exit(1);
+}
+
+const ext = osName === 'win' ? '.exe' : '';
+const binName = `aumic-tailwind-killer-v${VERSION}-${osName}-${osArch}${ext}`;
+const binDir = path.join(__dirname, '..', 'vendor');
+const binPath = path.join(binDir, binName);
+
+const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/v${VERSION}/${binName}`;
+
+function downloadBinary(url, dest) {
+    return new Promise((resolve, reject) => {
+        https.get(url, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+                return downloadBinary(res.headers.location, dest).then(resolve).catch(reject);
+            }
+            
+            if (res.statusCode !== 200) {
+                return reject(new Error(`Error HTTP ${res.statusCode} al descargar el binario nativo.`));
+            }
+
+            const file = fs.createWriteStream(dest);
+            res.pipe(file);
+            file.on('finish', () => {
+                file.close(resolve);
+            });
+            file.on('error', (err) => {
+                fs.unlink(dest, () => reject(err));
+            });
+        }).on('error', reject);
+    });
+}
+
+async function main() {
+    if (!fs.existsSync(binPath)) {
+        if (!fs.existsSync(binDir)) {
+            fs.mkdirSync(binDir, { recursive: true });
+        }
+        
+        console.log(`\x1b[36m[AUM-IC]\x1b[0m Descargando motor nativo (v${VERSION}) para ${osName}-${osArch}...`);
+        console.log(`\x1b[90mDescargando desde: ${downloadUrl}\x1b[0m`);
+        
+        try {
+            await downloadBinary(downloadUrl, binPath);
+            if (osName !== 'win') {
+                fs.chmodSync(binPath, 0o755); // Hacer ejecutable en Linux/Mac
+            }
+            console.log(`\x1b[32m✔ Motor nativo instalado con éxito.\x1b[0m\n`);
+        } catch (err) {
+            console.error(`\x1b[33m⚠️ No se pudo descargar el binario nativo: ${err.message}\x1b[0m`);
+            console.log(`\x1b[36m[AUM-IC]\x1b[0m Iniciando modo Fallback (Ejecutando motor de Node/TypeScript)...\n`);
+            require('../dist/index.js');
+            return;
+        }
+    }
+
+    // Ejecutar el binario y pasar todos los argumentos del CLI
+    const args = process.argv.slice(2);
+    const result = spawnSync(binPath, args, { stdio: 'inherit' });
+    
+    if (result.error) {
+        console.error(`\x1b[33m⚠️ Falló la ejecución nativa. Iniciando modo Fallback...\x1b[0m\n`);
+        require('../dist/index.js');
+        return;
+    }
+    
+    process.exit(result.status || 0);
+}
+
+main();

package/dist/ai/provider.js

@@ -0,0 +1,147 @@
+"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);
+    }
+    getDefaultModel(provider) {
+        switch (provider) {
+            case 'openai': return 'gpt-4o-mini';
+            case 'deepseek': return 'deepseek-chat';
+            case 'xai': return 'grok-beta';
+            case 'alibaba': return 'qwen-turbo';
+            case 'claude': return 'claude-3-haiku-20240307';
+            case 'gemini': return 'gemini-1.5-flash';
+            case 'ollama': return 'llama3';
+            default: return 'gpt-4o-mini';
+        }
+    }
+    getProviderBaseUrl(provider) {
+        switch (provider) {
+            case 'openai': return 'https://api.openai.com/v1/chat/completions';
+            case 'deepseek': return 'https://api.deepseek.com/chat/completions';
+            case 'xai': return 'https://api.x.ai/v1/chat/completions';
+            case 'alibaba': return 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions';
+            case 'ollama': return 'http://127.0.0.1:11434/api/generate';
+            default: return '';
+        }
+    }
+    async generateSemanticNames(request) {
+        let systemPrompt = "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-' (ej: 'aumic-btn--primary', 'aumic-card__header'). Responde ÚNICAMENTE con el objeto JSON válido, sin bloques de código markdown ni texto adicional.";
+        if (request.customRules) {
+            systemPrompt += `\n\nREGLAS PERSONALIZADAS DE LA EMPRESA/DESARROLLADOR:\n${request.customRules}\nDEBES DAR PRIORIDAD ABSOLUTA A ESTAS REGLAS EN EL RENOMBRAMIENTO.`;
+        }
+        const userContent = JSON.stringify(request.utilities);
+        let jsonRaw = '';
+        if (['openai', 'deepseek', 'xai', 'alibaba'].includes(this.provider)) {
+            jsonRaw = await this.callOpenAICompatible(systemPrompt, userContent);
+        }
+        else if (this.provider === 'gemini') {
+            jsonRaw = await this.callGemini(systemPrompt, userContent);
+        }
+        else if (this.provider === 'claude') {
+            jsonRaw = await this.callClaude(systemPrompt, userContent);
+        }
+        else if (this.provider === 'ollama') {
+            jsonRaw = await this.callOllama(systemPrompt, userContent);
+        }
+        else {
+            throw new Error(`Proveedor ${this.provider} no implementado.`);
+        }
+        try {
+            // Limpieza agresiva por si la IA devuelve markdown a pesar de las instrucciones
+            const cleanJson = jsonRaw.replace(/```json/g, '').replace(/```/g, '').trim();
+            const parsed = JSON.parse(cleanJson);
+            return { mapping: parsed };
+        }
+        catch (error) {
+            console.error("[IA] Fallo al parsear la respuesta semántica:", jsonRaw);
+            return { mapping: {} };
+        }
+    }
+    async callOpenAICompatible(system, user) {
+        const url = this.getProviderBaseUrl(this.provider);
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    { role: 'system', content: system },
+                    { role: 'user', content: user }
+                ],
+                temperature: 0.1 // Temperatura baja para determinismo
+            })
+        });
+        if (!res.ok)
+            throw new Error(`[IA] Error HTTP ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        return data.choices[0].message.content;
+    }
+    async callGemini(system, user) {
+        const url = `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:generateContent?key=${this.apiKey}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                system_instruction: { parts: { text: system } },
+                contents: [{ parts: [{ text: user }] }],
+                generationConfig: { temperature: 0.1 }
+            })
+        });
+        if (!res.ok)
+            throw new Error(`[IA] Error HTTP ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        return data.candidates[0].content.parts[0].text;
+    }
+    async callClaude(system, user) {
+        const url = 'https://api.anthropic.com/v1/messages';
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+                'anthropic-version': '2023-06-01'
+            },
+            body: JSON.stringify({
+                model: this.model,
+                system: system,
+                messages: [{ role: 'user', content: user }],
+                temperature: 0.1,
+                max_tokens: 4096
+            })
+        });
+        if (!res.ok)
+            throw new Error(`[IA] Error HTTP ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        return data.content[0].text;
+    }
+    async callOllama(system, user) {
+        const url = this.getProviderBaseUrl(this.provider);
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: this.model,
+                system: system,
+                prompt: user,
+                stream: false,
+                options: { temperature: 0.1 }
+            })
+        });
+        if (!res.ok)
+            throw new Error(`[IA] Error Ollama HTTP ${res.status}: Asegúrate de que Ollama esté corriendo en local.`);
+        const data = await res.json();
+        return data.response;
+    }
+}
+exports.AIEngine = AIEngine;

package/dist/ast/parser.js

@@ -0,0 +1,115 @@
+"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;
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const generator_1 = __importDefault(require("@babel/generator"));
+class AstInterceptor {
+    /**
+     * Destripa archivos TSX/JSX, localiza los atributos className/class
+     * e intercepta todos los StringLiterals dentro, sin importar su nivel
+     * de anidación o lógica condicional (ternarios, arrays, etc).
+     */
+    processFrameworkFile(code, fileName, replacerFn) {
+        const ext = fileName.split('.').pop()?.toLowerCase();
+        const jsExtensions = ['jsx', 'tsx', 'js', 'ts'];
+        if (jsExtensions.includes(ext || '')) {
+            return this.processWithBabel(code, replacerFn);
+        }
+        else {
+            return this.processWithUniversalRegex(code, replacerFn);
+        }
+    }
+    processWithUniversalRegex(code, replacerFn) {
+        const extracted = new Set();
+        // Regex letal que captura class="...", className='...', class:list={`...`} en cualquier motor de plantillas (Jinja, Blade, Tera, HTML)
+        const classRegex = /(class|className|class:list)\s*(=|:)\s*(["'`])(.*?)\3/gs;
+        let newCode = code;
+        // Fase 1: Extracción
+        let match;
+        while ((match = classRegex.exec(code)) !== null) {
+            const classString = match[4];
+            const cleanStr = classString.replace(/\s+/g, ' ').trim();
+            if (cleanStr && !cleanStr.includes('aumic-')) {
+                extracted.add(cleanStr);
+            }
+        }
+        // Fase 2: Mutación directa
+        newCode = code.replace(classRegex, (fullMatch, attr, separator, quote, classString) => {
+            const cleanStr = classString.replace(/\s+/g, ' ').trim();
+            if (!cleanStr || cleanStr.includes('aumic-'))
+                return fullMatch;
+            const newClass = replacerFn(cleanStr);
+            return `${attr}${separator}${quote}${newClass}${quote}`;
+        });
+        return { newCode, extractedClasses: Array.from(extracted) };
+    }
+    processWithBabel(code, replacerFn) {
+        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;
+        traverseAst(ast, {
+            CallExpression(path) {
+                const calleeName = path.node.callee.name;
+                if (['clsx', 'cva', 'cn', 'twMerge', 'classNames'].includes(calleeName)) {
+                    path.traverse({
+                        StringLiteral(strPath) {
+                            const originalStr = strPath.node.value;
+                            const cleanStr = originalStr.replace(/\s+/g, ' ').trim();
+                            if (cleanStr && !cleanStr.includes('aumic-')) {
+                                extracted.add(cleanStr);
+                                strPath.node.value = replacerFn(cleanStr);
+                            }
+                        },
+                        TemplateElement(tplPath) {
+                            const originalRaw = tplPath.node.value.raw;
+                            const cleanStr = originalRaw.replace(/\s+/g, ' ').trim();
+                            if (cleanStr && !cleanStr.includes('aumic-')) {
+                                extracted.add(cleanStr);
+                                tplPath.node.value.raw = replacerFn(cleanStr);
+                                tplPath.node.value.cooked = tplPath.node.value.raw;
+                            }
+                        }
+                    });
+                }
+            },
+            JSXAttribute(path) {
+                const attrName = path.node.name.name;
+                if (attrName === 'className' || attrName === 'class') {
+                    path.traverse({
+                        StringLiteral(strPath) {
+                            const originalStr = strPath.node.value;
+                            const cleanStr = originalStr.replace(/\s+/g, ' ').trim();
+                            if (cleanStr && !cleanStr.includes('aumic-')) {
+                                extracted.add(cleanStr);
+                                strPath.node.value = replacerFn(cleanStr);
+                            }
+                        },
+                        TemplateElement(tplPath) {
+                            const originalRaw = tplPath.node.value.raw;
+                            const cleanStr = originalRaw.replace(/\s+/g, ' ').trim();
+                            if (cleanStr && !cleanStr.includes('aumic-')) {
+                                extracted.add(cleanStr);
+                                tplPath.node.value.raw = replacerFn(cleanStr);
+                                tplPath.node.value.cooked = tplPath.node.value.raw;
+                            }
+                        }
+                    });
+                }
+            }
+        });
+        const generateCode = generator_1.default.default || generator_1.default;
+        const output = generateCode(ast, { retainLines: true }, code);
+        return {
+            newCode: output.code,
+            extractedClasses: Array.from(extracted)
+        };
+    }
+}
+exports.AstInterceptor = AstInterceptor;

package/dist/core/scraper.js

@@ -0,0 +1,67 @@
+"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;
+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 {
+    /**
+     * Clona una página web completa (HTML, CSS, JS, Fuentes, Imágenes),
+     * reescribe todas las rutas para que funcionen 100% en local.
+     */
+    static async cloneWebsite(url, outputDir, cloneDepth) {
+        // Limpiar el directorio si ya existe para evitar conflictos de clonación
+        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' }
+            ],
+            // Si es 'site', escanea y descarga recursivamente toda la web. Si es 'page', solo la URL dada y sus assets.
+            recursive: cloneDepth === 'site',
+            maxDepth: cloneDepth === 'site' ? 5 : 1, // Límite táctico para no desbordar el disco
+            ignoreErrors: true
+        };
+        try {
+            await (0, website_scraper_1.default)(options);
+        }
+        catch (error) {
+            console.error(picocolors_1.default.red(`\n[!] Error fatal durante la clonación cibernética: ${error}`));
+            throw error;
+        }
+    }
+    /**
+     * Detecta si la web clonada utiliza Tailwind CSS escaneando sus archivos HTML.
+     */
+    static async isTailwindPowered(outputDir) {
+        const files = await fs_extra_1.default.readdir(outputDir);
+        const htmlFiles = files.filter(f => f.endsWith('.html'));
+        let twScore = 0;
+        const twSignatures = ['flex', 'grid', 'w-full', 'h-full', 'absolute', 'relative', 'bg-', 'text-', 'p-4', 'm-'];
+        for (const file of htmlFiles) {
+            const content = await fs_extra_1.default.readFile(path_1.default.join(outputDir, file), 'utf-8');
+            for (const sig of twSignatures) {
+                if (content.includes(`"${sig}`))
+                    twScore++;
+                if (content.includes(` ${sig}`))
+                    twScore++;
+            }
+        }
+        // Si encontramos múltiples firmas atómicas, confirmamos que es Tailwind
+        return twScore >= 5;
+    }
+}
+exports.WebCloner = WebCloner;