@ingcrea/aumic-tailwind-killer 4.1.4 → 4.1.5

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')));
+}