@getparallel/parx 0.4.4 → 0.6.0

package/dist/config.js

@@ -96,6 +96,10 @@ export function leerAjustes(dir = carpetaDeConfiguracion()) {
             out.raton = a.raton;
         if (typeof a.animacion === 'boolean')
             out.animacion = a.animacion;
+        if (typeof a.autoactualizar === 'boolean')
+            out.autoactualizar = a.autoactualizar;
+        if (typeof a.remoto === 'boolean')
+            out.remoto = a.remoto;
         const k = a.consejos;
         if (k && typeof k === 'object') {
             const n = (x) => (typeof x === 'number' && Number.isFinite(x) && x >= 0 ? Math.floor(x) : 0);

package/dist/consejos.js

@@ -1,6 +1,6 @@
 import { capacidades } from "./marca.js";
 import { t } from "./textos.js";
-export const CONSEJOS = ['menu', 'modo', 'una', 'bash', 'imagen', 'historial', 'pegar', 'deshacer', 'modelo', 'carriles', 'parar', 'cola', 'bandeja', 'raton', 'informe', 'mision', 'ensenar', 'saldo', 'cuenta', 'agents'];
+export const CONSEJOS = ['menu', 'modo', 'una', 'bash', 'imagen', 'historial', 'pegar', 'deshacer', 'modelo', 'carriles', 'parar', 'cola', 'bandeja', 'raton', 'informe', 'mision', 'ensenar', 'saldo', 'cuenta', 'agents', 'arroba'];
 export function consejo(id) {
     const u = capacidades().unicode;
     const tecla = {
@@ -24,6 +24,7 @@ export function consejo(id) {
         bash: '!',
         bandeja: '/inbox',
         raton: 'Click',
+        arroba: '@',
     };
     return { tecla: tecla[id], texto: t(`tip.${id}`) };
 }

package/dist/estimacion.js

@@ -0,0 +1,118 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { carpetaDeConfiguracion } from "./config.js";
+import { MODELOS, ORDEN_DE_MODELOS, nombreDeModelo } from "./modelos.js";
+import { t } from "./textos.js";
+export const PERFILES = {
+    pregunta: { vueltas: 2, crecimiento: 700, salidaPorVuelta: 80, salidaFinal: 350 },
+    pequena: { vueltas: 4, crecimiento: 900, salidaPorVuelta: 350, salidaFinal: 200 },
+    media: { vueltas: 8, crecimiento: 1200, salidaPorVuelta: 550, salidaFinal: 250 },
+    grande: { vueltas: 16, crecimiento: 1500, salidaPorVuelta: 650, salidaFinal: 350 },
+};
+const GRANDE = /\b(refactor|refactoriz|migrat|migra[r]?\b|rewrite|reescrib|rework|whole (project|app|codebase|repo)|entire|todo el (proyecto|código|repo)|toda la (app|aplicación)|all (the )?files|todos los ficheros|architecture|arquitectura|from scratch|desde cero|full[- ]stack|authentication|autenticaci|database|base de datos|deploy|despliega|integrat|integra[r]?\b|test suite|end[- ]to[- ]end|e2e|multi[- ]?page|varias páginas|dashboard|backend|api rest|microservic)/i;
+const CREA = /\b(create|build|make|write|generate|implement|crea[r]?|construye|monta|escribe|genera|implementa|haz(me)?|new|nuev[oa])\b/i;
+const SUSTANCIAL = /\b(page|página|pagina|website|web ?site|site|web|app|form|formulario|component|componente|feature|funcionalidad|endpoint|screen|pantalla|module|módulo|modulo|api|script|server|servidor|service|servicio|table|tabla|model|modelo|view|vista)\b/i;
+const PEQUENA = /\b(typo|errata|rename|renombra|one[- ]line|una línea|small|pequeñ|minor|mínim|quick|rápid|simple|sencill|tiny|just|solo|sólo|only|fix the|arregla el|arregla la|change the|cambia el|cambia la|add a |añade un|añade una|remove the|quita el|quita la|update the|actualiza el)\b/i;
+const PREGUNTA = /^(what|why|how|where|which|who|when|is|are|does|do|can|could|should|explain|describe|tell me|show me|list|qué|que|por qué|cómo|como|dónde|donde|cuál|cual|quién|quien|cuándo|explica|describe|dime|enséñame|lista|hay)\b/i;
+function palabras(s) {
+    return s.trim().split(/\s+/).filter(Boolean).length;
+}
+export function clasificarTarea(pedido) {
+    const s = pedido.replace(/\s+/g, ' ').trim();
+    const n = palabras(s);
+    if (!s)
+        return 'pequena';
+    if (GRANDE.test(s) || n > 90)
+        return 'grande';
+    const pregunta = PREGUNTA.test(s) || (s.endsWith('?') && !CREA.test(s));
+    if (pregunta && !CREA.test(s))
+        return 'pregunta';
+    const creaAlgo = CREA.test(s) || SUSTANCIAL.test(s);
+    if (n <= 10 && !creaAlgo)
+        return 'pequena';
+    if (PEQUENA.test(s) && !creaAlgo)
+        return 'pequena';
+    return 'media';
+}
+export function tokensDe(texto) {
+    const chars = typeof texto === 'number' ? texto : texto.length;
+    return Math.ceil(chars / 3.8);
+}
+export function accionesEnBruto(clase, baseTokens, tarifa) {
+    const p = PERFILES[clase];
+    let entrada = 0;
+    let salida = 0;
+    for (let i = 0; i < p.vueltas; i++) {
+        entrada += baseTokens + i * p.crecimiento;
+        salida += i === p.vueltas - 1 ? p.salidaFinal : p.salidaPorVuelta;
+    }
+    return (entrada * tarifa.entrada + salida * tarifa.salida) / 1000;
+}
+export function redondear(n) {
+    if (n < 1)
+        return 1;
+    if (n < 10)
+        return Math.round(n);
+    const magnitud = 10 ** (Math.floor(Math.log10(n)) - 1);
+    return Math.round(n / magnitud) * magnitud;
+}
+export function estimarTarea(e) {
+    const clase = clasificarTarea(e.pedido);
+    const base = tokensDe(e.contextoChars) + tokensDe(e.pedido);
+    const acciones = {};
+    for (const m of ORDEN_DE_MODELOS) {
+        const bruto = accionesEnBruto(clase, base, e.tarifas[MODELOS[m].servidor]);
+        acciones[m] = redondear(bruto * factorDeCalibracion(e.calibracion, clase, m));
+    }
+    return { clase, acciones };
+}
+export function lineaDeEstimacion(est, modelo) {
+    const actual = est.acciones[modelo];
+    let sugerido = null;
+    if (modelo === 'summit' && est.clase !== 'grande')
+        sugerido = 'stride';
+    if ((modelo === 'summit' || modelo === 'stride') && (est.clase === 'pregunta' || est.clase === 'pequena'))
+        sugerido = 'swift';
+    if (sugerido && est.acciones[sugerido] <= actual * 0.6 && actual >= 5) {
+        return t('estimacion.con', { n: actual.toLocaleString('en-US'), modelo: nombreDeModelo(sugerido).replace(/ \d+(\.\d+)?$/, ''), otro: est.acciones[sugerido].toLocaleString('en-US') });
+    }
+    return t('estimacion.linea', { n: actual.toLocaleString('en-US') });
+}
+const FICHERO = 'estimaciones.json';
+const PESO = 0.3;
+export function leerCalibracion(dir = carpetaDeConfiguracion()) {
+    try {
+        const c = JSON.parse(readFileSync(join(dir, FICHERO), 'utf8'));
+        return c && typeof c === 'object' ? c : {};
+    }
+    catch {
+        return {};
+    }
+}
+function guardarCalibracion(c, dir) {
+    try {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        writeFileSync(join(dir, FICHERO), JSON.stringify(c, null, 2), { mode: 0o600 });
+    }
+    catch {
+    }
+}
+export function factorDeCalibracion(c, clase, modelo) {
+    const f = c?.[clase]?.[modelo]?.factor;
+    if (typeof f !== 'number' || !Number.isFinite(f) || f <= 0)
+        return 1;
+    return Math.min(2, Math.max(0.5, f));
+}
+export function aprenderDeLaTarea(o) {
+    const dir = o.dir ?? carpetaDeConfiguracion();
+    const c = o.calibracion ?? leerCalibracion(dir);
+    if (!(o.estimada > 0) || !(o.real > 0))
+        return c;
+    const ratio = Math.min(4, Math.max(0.25, o.real / o.estimada));
+    const antes = c[o.clase]?.[o.modelo];
+    const factor = antes ? antes.factor * (1 - PESO) + ratio * PESO : ratio;
+    c[o.clase] = { ...(c[o.clase] ?? {}), [o.modelo]: { factor: Number(factor.toFixed(3)), n: (antes?.n ?? 0) + 1 } };
+    guardarCalibracion(c, dir);
+    return c;
+}

package/dist/firmas.js

@@ -0,0 +1,55 @@
+import { createHash, createVerify } from 'node:crypto';
+export const CLAVES_DE_NPM = [
+    {
+        keyid: 'SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U',
+        key: 'MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY6Ya7W++7aUPzvMTrezH6Ycx3c+HOKYCcNGybJZSCJq/fd7Qa8uuAKtdIkUQtQiEKERhAmE5lMMJhP8OkDOa2g==',
+    },
+];
+const REGISTRO_DE_NPM = 'https://registry.npmjs.org';
+export function keyidDe(spkiBase64) {
+    return `SHA256:${createHash('sha256').update(Buffer.from(spkiBase64, 'base64')).digest('base64').replace(/=+$/, '')}`;
+}
+export function clavesDeConfianza(env = process.env) {
+    const claves = [...CLAVES_DE_NPM];
+    const registro = (env.PARX_REGISTRY ?? '').replace(/\/+$/, '');
+    if (registro && registro !== REGISTRO_DE_NPM && env.PARX_CLAVES_DE_FIRMA) {
+        for (const k of env.PARX_CLAVES_DE_FIRMA.split(',').map((x) => x.trim()).filter(Boolean))
+            claves.push({ keyid: keyidDe(k), key: k });
+    }
+    return claves;
+}
+export function mensajeFirmado(nombre, version, integrity) {
+    return `${nombre}@${version}:${integrity}`;
+}
+export function firmaValida(d, claves = CLAVES_DE_NPM) {
+    if (!Array.isArray(d.firmas) || !d.firmas.length)
+        return false;
+    if (!/^sha512-[A-Za-z0-9+/]+={0,2}$/.test(d.integrity))
+        return false;
+    const mensaje = mensajeFirmado(d.nombre, d.version, d.integrity);
+    for (const f of d.firmas) {
+        if (!f || typeof f !== 'object')
+            continue;
+        const { keyid, sig } = f;
+        if (typeof keyid !== 'string' || typeof sig !== 'string')
+            continue;
+        const clave = claves.find((k) => k.keyid === keyid);
+        if (!clave)
+            continue;
+        try {
+            const v = createVerify('SHA256');
+            v.update(mensaje);
+            if (v.verify(`-----BEGIN PUBLIC KEY-----\n${clave.key}\n-----END PUBLIC KEY-----`, sig, 'base64'))
+                return true;
+        }
+        catch {
+        }
+    }
+    return false;
+}
+export function integridadDe(contenido) {
+    return `sha512-${createHash('sha512').update(contenido).digest('base64')}`;
+}
+export function integridadCoincide(contenido, integrity) {
+    return integridadDe(contenido) === integrity;
+}

package/dist/marca.js

@@ -125,27 +125,64 @@ export function logo() {
     const tonos = [c.marca, c.claro, c.claro, c.violeta];
     return filas.map((f, i) => tonos[i](f));
 }
-export const ANCHO_DE_PAR = 6;
-export function cabezaDePar() {
-    return caps.unicode ? c.claro('▗▄▄▄▄▖') : c.claro(' .--. ');
+export const ANCHO_DE_PAR = 8;
+function miniPar(gesto) {
+    const ojo = gesto === 'error' ? 'R' : 'E';
+    const fila1 = ['.', '.', 'B', 'B', '.', 'B', 'B', '.'];
+    if (gesto === 'pregunta') {
+        fila1.splice(0, 8, '.', '.', ojo, ojo, '.', ojo, ojo, '.');
+    }
+    else if (gesto !== 'parpadeo') {
+        const izquierda = gesto === 1 || gesto === 2;
+        const a = izquierda ? 2 : 3;
+        fila1[a] = ojo;
+        fila1[a + 3] = ojo;
+    }
+    return [
+        ['.', '.', '.', 'B', 'B', '.', 'B', 'B'],
+        fila1,
+        ['.', 'B', 'B', '.', 'B', 'B', '.', '.'],
+        ['B', 'B', '.', 'B', 'B', '.', '.', '.'],
+    ];
 }
-export function caraDePar(gesto = 'quieto') {
-    const u = caps.unicode;
-    const ojos = gesto === 'parpadeo'
-        ? u ? ' ── ' : ' -- '
-        : gesto === 'pregunta'
-            ? u ? ' •• ' : ' oo '
-            : gesto === 'error'
-                ? u ? ' ×× ' : ' xx '
-                : typeof gesto === 'number'
-                    ?
-                        (u ? ['╱╱  ', ' ╱╱ ', '  ╱╱', ' ╱╱ '] : ['//  ', ' // ', '  //', ' // '])[gesto]
-                    : u ? ' ╱╱ ' : ' // ';
-    if (caps.color) {
-        const fondo = caps.color === 3 ? '\x1b[48;2;139;112;255m' : caps.color === 2 ? '\x1b[48;5;141m' : '\x1b[45m';
-        return `${fondo}\x1b[1;97m ${ojos} \x1b[22;39;49m`;
+const RGB_DE_PAR = { B: [139, 112, 255], E: [246, 243, 255], R: [255, 107, 107] };
+const C256_DE_PAR = { B: 141, E: 255, R: 203 };
+function filaDePar(arriba, abajo) {
+    let out = '';
+    for (let x = 0; x < ANCHO_DE_PAR; x++) {
+        const a = arriba[x];
+        const b = abajo[x];
+        if (!caps.unicode || !caps.color) {
+            const hay = a !== '.' || b !== '.';
+            const ojo = a === 'E' || a === 'R' || b === 'E' || b === 'R';
+            out += ojo ? 'o' : hay ? (caps.unicode ? '█' : '/') : ' ';
+            continue;
+        }
+        if (a === '.' && b === '.') {
+            out += ' ';
+            continue;
+        }
+        const fg = a === '.' ? null : a;
+        const bg = b === '.' ? null : b;
+        const color = (p, fondo) => caps.color === 3 ? `\x1b[${fondo ? 48 : 38};2;${RGB_DE_PAR[p].join(';')}m` : caps.color === 2 ? `\x1b[${fondo ? 48 : 38};5;${C256_DE_PAR[p]}m` : p === 'B' ? `\x1b[${fondo ? 45 : 35}m` : p === 'R' ? `\x1b[${fondo ? 41 : 31}m` : `\x1b[${fondo ? 47 : 97}m`;
+        if (fg && bg && fg === bg)
+            out += `${color(fg, false)}█\x1b[39m`;
+        else if (fg && bg)
+            out += `${color(fg, false)}${color(bg, true)}▀\x1b[39;49m`;
+        else if (fg)
+            out += `${color(fg, false)}▀\x1b[39m`;
+        else
+            out += `${color(bg, false)}▄\x1b[39m`;
     }
-    return u ? `▐${ojos}▌` : `[${ojos}]`;
+    return out;
+}
+export function cabezaDePar(gesto = 'quieto') {
+    const p = miniPar(gesto);
+    return filaDePar(p[0], p[1]);
+}
+export function caraDePar(gesto = 'quieto') {
+    const p = miniPar(gesto);
+    return filaDePar(p[2], p[3]);
 }
 export const ANCHO_DE_ANIMACION = 8;
 export function animacion(tipo, paso) {

package/dist/menciones.js

@@ -0,0 +1,85 @@
+export const LARGO_MAXIMO_CONSULTA = 30;
+export function normalizar(texto) {
+    return texto.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+}
+export function detectarArroba(texto, cursor) {
+    if (cursor < 1 || cursor > texto.length)
+        return null;
+    const antes = texto.slice(0, cursor);
+    const arroba = antes.lastIndexOf('@');
+    if (arroba < 0)
+        return null;
+    const previo = arroba === 0 ? '' : antes[arroba - 1];
+    if (previo !== '' && !/\s/.test(previo))
+        return null;
+    const consulta = antes.slice(arroba + 1);
+    if (consulta.length > LARGO_MAXIMO_CONSULTA)
+        return null;
+    if (/\n|\s\s|^\s/.test(consulta))
+        return null;
+    return { inicio: arroba, consulta };
+}
+export function mencionTerminada(consulta, conexiones) {
+    if (!/\s$/.test(consulta))
+        return false;
+    const q = normalizar(consulta.trim());
+    return conexiones.some((c) => normalizar(c.nombre) === q || normalizar(c.provider) === q);
+}
+export function filtrarConexiones(conexiones, consulta) {
+    return puntuar(conexiones, consulta)
+        .sort((a, b) => a.p - b.p || a.c.nombre.localeCompare(b.c.nombre))
+        .map((x) => x.c);
+}
+function puntuar(conexiones, consulta) {
+    const q = normalizar(consulta.trim());
+    const puntuados = [];
+    for (const c of conexiones) {
+        const nombre = normalizar(c.nombre);
+        const clave = normalizar(c.provider);
+        let p = -1;
+        if (!q || nombre.startsWith(q) || clave.startsWith(q))
+            p = 0;
+        else if (nombre.split(/[\s._-]+/).some((w) => w.startsWith(q)) || clave.split('_').some((w) => w.startsWith(q)))
+            p = 1;
+        else if (nombre.includes(q) || clave.includes(q))
+            p = 2;
+        if (p >= 0)
+            puntuados.push({ c, p });
+    }
+    return puntuados;
+}
+export function conexionesQueSalen(conexiones, consulta, max = 40) {
+    return puntuar(conexiones, consulta)
+        .sort((a, b) => a.p - b.p || Number(b.c.conectada) - Number(a.c.conectada) || a.c.nombre.localeCompare(b.c.nombre))
+        .slice(0, max)
+        .map((x) => x.c);
+}
+export function mencionEnLaCaja(unidades, cursor) {
+    if (unidades[0] === '!')
+        return null;
+    const antes = unidades.slice(0, Math.max(0, Math.min(cursor, unidades.length)));
+    let arroba = -1;
+    for (let i = antes.length - 1; i >= 0; i--) {
+        const u = antes[i];
+        if (u === '@') {
+            arroba = i;
+            break;
+        }
+        if (u.length !== 1 || antes.length - i > LARGO_MAXIMO_CONSULTA + 1)
+            return null;
+    }
+    if (arroba < 0)
+        return null;
+    const previo = arroba === 0 ? '' : antes[arroba - 1];
+    if (previo !== '' && (previo.length !== 1 || !/\s/.test(previo)))
+        return null;
+    const consulta = antes.slice(arroba + 1).join('');
+    return detectarArroba(`@${consulta}`, consulta.length + 1) ? { inicio: arroba, consulta } : null;
+}
+export function insertarMencion(unidades, inicio, cursor, nombre) {
+    const despues = unidades.slice(cursor);
+    const separador = despues[0] === ' ' ? [] : [' '];
+    const etiqueta = [...Array.from(`@${nombre}`), ...separador];
+    const nuevas = [...unidades.slice(0, inicio), ...etiqueta, ...despues];
+    return { unidades: nuevas, cursor: inicio + etiqueta.length + (separador.length ? 0 : 1) };
+}