@getparallel/parx 0.0.0-stage → 0.4.1

package/dist/ui.js

@@ -0,0 +1,287 @@
+import { animacion, c, capacidades, SIMBOLOS } from "./marca.js";
+import { t } from "./textos.js";
+import { trozos } from "./diff.js";
+import { anchoDe, envolver, recortar, recortarMedio, rellenar, sinColor } from "./texto.js";
+import { anchoUtil, bloqueDeCierre, bloqueDeLinea, bloqueDeTexto, filaDeTrabajo, MARGEN, nuevoTrabajo, opcionesDePregunta, ponerTextoDeTrabajo, } from "./tui.js";
+export function leerRespuesta(texto, tipo = 'normal') {
+    const r = texto.trim().toLowerCase();
+    const o = opcionesDePregunta(tipo);
+    if (r === '' || r === 'n' || r === 'no')
+        return 'no';
+    const n = Number(r);
+    if (Number.isInteger(n) && n >= 1 && n <= o.valores.length)
+        return o.valores[n - 1];
+    if ((r === 'y' || r === 'yes') && tipo !== 'credencial')
+        return 'si';
+    if ((r === 'a' || r === 'always') && o.valores.includes('siempre'))
+        return 'siempre';
+    return null;
+}
+function anchoDeVerbo() {
+    return Math.max(...['herr.leer', 'herr.listar', 'herr.buscar', 'herr.escribir', 'herr.editar', 'herr.ejecutar'].map((k) => anchoDe(t(k)))) + 2;
+}
+function sangriaDeDetalle() {
+    return 2 + anchoDeVerbo();
+}
+export function bloqueDeAccion(verbo, objeto, nota = '') {
+    objeto = objeto.replace(/\s*\r?\n\s*/g, ' ↵ ');
+    return (ancho) => {
+        const util = anchoUtil(ancho);
+        const v = rellenar(c.claro(verbo), anchoDeVerbo());
+        const punto = c.violeta(SIMBOLOS.punto);
+        const notaW = nota ? anchoDe(nota) + 2 : 0;
+        const libre = util - 2 - anchoDeVerbo();
+        const conNota = libre - notaW >= Math.min(16, anchoDe(objeto));
+        const espacio = conNota ? libre - notaW : libre;
+        const obj = anchoDe(objeto) > espacio ? (/[\\/]/.test(sinColor(objeto)) && !/\s/.test(sinColor(objeto)) ? recortarMedio(sinColor(objeto), espacio) : recortar(objeto, espacio)) : objeto;
+        return [`${' '.repeat(MARGEN)}${punto} ${v}${obj}${conNota && nota ? `  ${c.gris(nota)}` : ''}`];
+    };
+}
+export class Pantalla {
+    rl;
+    superficie = null;
+    esperaActiva = null;
+    trabajoEnLinea = null;
+    carril;
+    tty;
+    constructor(rl, tty = Boolean(process.stdout.isTTY && process.stdin.isTTY), carril = null) {
+        this.rl = rl;
+        this.tty = tty;
+        this.carril = carril;
+    }
+    fijarLectora(rl) {
+        this.rl = rl;
+    }
+    fijarSuperficie(s) {
+        this.superficie = s;
+    }
+    conCarril(b) {
+        const k = this.carril;
+        if (!k)
+            return b;
+        return (ancho) => {
+            const marca = `${c.claro(String(k.numero))}${c.violeta(capacidades().unicode ? '│' : '|')}`;
+            return b(Math.max(20, ancho - 3))
+                .filter((l) => l.trim() !== '')
+                .map((l) => `${' '.repeat(MARGEN)}${marca} ${l.startsWith(' '.repeat(MARGEN)) ? l.slice(MARGEN) : l}`);
+        };
+    }
+    bloque(b) {
+        const bc = this.conCarril(b);
+        if (this.superficie) {
+            this.superficie.anadir(bc);
+            return;
+        }
+        const enLinea = this.esperaActiva !== null;
+        if (enLinea)
+            process.stdout.write('\r\x1b[2K');
+        const ancho = Math.max(20, process.stdout.columns || capacidades().ancho || 80);
+        for (const l of bc(ancho))
+            process.stdout.write(`${l}\n`);
+        if (enLinea)
+            this.pintarEnLinea();
+    }
+    escribir(linea = '') {
+        this.bloque(bloqueDeTexto(linea.replace(/^ {1,2}/, '')));
+    }
+    lecturas = null;
+    accion(verbo, objeto, nota = '') {
+        if (this.superficie && verbo === t('herr.leer')) {
+            const l = this.lecturas;
+            if (l && this.superficie.ultimoBloque() === l.bloque) {
+                l.objetos.push(objeto);
+                const b = this.conCarril(bloqueDeAccion(verbo, l.objetos.join(', '), `${l.objetos.length} files`));
+                l.bloque = b;
+                this.superficie.reemplazarUltimo(b);
+                return;
+            }
+            const b = this.conCarril(bloqueDeAccion(verbo, objeto, nota));
+            this.lecturas = { bloque: b, objetos: [objeto] };
+            this.superficie.anadir(b);
+            return;
+        }
+        this.bloque(bloqueDeAccion(verbo, objeto, nota));
+    }
+    salidaDeComando(salida, maxLineas = 3) {
+        const lineas = salida.replace(/\r/g, '').trimEnd().split('\n').filter((l) => l.trim() !== '');
+        if (!lineas.length)
+            return;
+        const ultimas = lineas.slice(-maxLineas);
+        const sobran = lineas.length - ultimas.length;
+        this.bloque((ancho) => {
+            const s = sangriaDeDetalle();
+            const util = anchoUtil(ancho) - s;
+            const out = [];
+            if (sobran > 0)
+                out.push(`${' '.repeat(MARGEN + s)}${c.tenue(c.gris(`… ${sobran.toLocaleString('en-US')} +`))}`);
+            for (const l of ultimas)
+                out.push(`${' '.repeat(MARGEN + s)}${c.tenue(recortar(sinColor(l).replace(/\t/g, '  '), util))}`);
+            return out;
+        });
+    }
+    detalle(texto, error = false) {
+        this.bloque((ancho) => [`${' '.repeat(MARGEN + sangriaDeDetalle())}${recortar(error ? c.error(`${SIMBOLOS.falla} ${texto}`) : c.gris(texto), anchoUtil(ancho) - sangriaDeDetalle())}`]);
+    }
+    aviso(texto) {
+        this.bloque(bloqueDeTexto(`${c.aviso('!')} ${texto}`, '  '));
+    }
+    error(texto) {
+        this.bloque(bloqueDeTexto(`${c.error(SIMBOLOS.falla)} ${texto}`, '  '));
+    }
+    cierre(texto) {
+        this.bloque(bloqueDeCierre(texto, c.ok(SIMBOLOS.hecho)));
+    }
+    trabajoPropio() {
+        return this.carril ? this.carril.trabajo : this.trabajoEnLinea;
+    }
+    espera(texto = null, anim = 'ruta', vivo = anim === 'tren') {
+        if (this.carril) {
+            ponerTextoDeTrabajo(this.carril.trabajo, texto, anim, vivo);
+            this.superficie?.actualizarCarriles();
+            return;
+        }
+        if (this.superficie) {
+            this.superficie.textoDeTrabajo(texto, anim, vivo);
+            return;
+        }
+        if (!this.tty)
+            return;
+        this.trabajoEnLinea ??= nuevoTrabajo();
+        ponerTextoDeTrabajo(this.trabajoEnLinea, texto, anim, vivo);
+        if (!this.esperaActiva) {
+            this.pintarEnLinea();
+            this.esperaActiva = setInterval(() => {
+                if (this.trabajoEnLinea)
+                    this.trabajoEnLinea.paso++;
+                this.pintarEnLinea();
+            }, 110);
+            this.esperaActiva.unref?.();
+        }
+    }
+    pintarEnLinea() {
+        if (!this.trabajoEnLinea)
+            return;
+        const ancho = Math.max(20, process.stdout.columns || 80);
+        process.stdout.write(`\r\x1b[2K${' '.repeat(MARGEN)}${recortar(filaDeTrabajo(this.trabajoEnLinea, Date.now()), ancho - MARGEN - 2)}`);
+    }
+    progreso(acciones) {
+        if (this.carril) {
+            this.carril.trabajo.acciones = acciones;
+            this.superficie?.actualizarCarriles();
+            return;
+        }
+        if (this.superficie) {
+            this.superficie.progreso(acciones);
+            return;
+        }
+        if (this.trabajoEnLinea)
+            this.trabajoEnLinea.acciones = acciones;
+    }
+    pararEspera() {
+        if (this.superficie || this.carril)
+            return;
+        if (this.esperaActiva) {
+            clearInterval(this.esperaActiva);
+            this.esperaActiva = null;
+            process.stdout.write('\r\x1b[2K');
+        }
+        this.trabajoEnLinea = null;
+    }
+    pausarLinea() {
+        if (this.esperaActiva) {
+            clearInterval(this.esperaActiva);
+            this.esperaActiva = null;
+            process.stdout.write('\r\x1b[2K');
+        }
+    }
+    diff(lineas, max = 40) {
+        const visibles = trozos(lineas);
+        this.bloque((ancho) => {
+            const s = sangriaDeDetalle();
+            const util = anchoUtil(ancho) - s;
+            const pre = ' '.repeat(MARGEN + s);
+            const out = [];
+            let pintadas = 0;
+            for (const l of visibles) {
+                if (pintadas >= max) {
+                    out.push(`${pre}${c.tenue(`… ${visibles.length - max} +`)}`);
+                    break;
+                }
+                pintadas++;
+                if (l === null) {
+                    out.push(`${pre}${c.tenue('⋮')}`);
+                    continue;
+                }
+                const num = String(l.despues ?? l.antes ?? '').padStart(4);
+                const texto = recortar(l.texto.replace(/\t/g, '  '), Math.max(4, util - 7));
+                if (l.tipo === '+')
+                    out.push(`${pre}${c.tenue(num)} ${c.mas(`+ ${texto}`)}`);
+                else if (l.tipo === '-')
+                    out.push(`${pre}${c.tenue(num)} ${c.menos(`- ${texto}`)}`);
+                else
+                    out.push(`${pre}${c.tenue(num)}   ${c.tenue(texto)}`);
+            }
+            return out;
+        });
+    }
+    async preguntar(pregunta, o = {}) {
+        const tipo = o.tipo ?? 'normal';
+        if (o.aviso)
+            this.aviso(o.aviso);
+        const texto = this.carril ? `${t('carriles.carril', { n: this.carril.numero })}: ${pregunta}` : pregunta;
+        if (this.superficie)
+            return this.superficie.preguntar(texto, tipo);
+        this.pausarLinea();
+        if (!this.tty || !this.rl) {
+            this.aviso(`${texto} → ${t('aviso.rechazado')}`);
+            return 'no';
+        }
+        const opciones = opcionesDePregunta(tipo);
+        const lista = opciones.opciones.map((e, i) => `${i + 1} ${e}`).join(' · ');
+        for (;;) {
+            const r = leerRespuesta(await this.rl.question(`${' '.repeat(MARGEN)}${c.marca(texto)} ${c.gris(lista)} ${c.claro(SIMBOLOS.flecha)} `), tipo);
+            if (r)
+                return r;
+            this.escribir(c.gris(t('pregunta.respuesta')));
+        }
+    }
+    texto(md) {
+        const lineas = md.replace(/\r/g, '').split('\n');
+        this.bloque((ancho) => {
+            const util = anchoUtil(ancho);
+            const pre = ' '.repeat(MARGEN);
+            const out = [];
+            let enBloque = false;
+            for (const linea of lineas) {
+                if (/^```/.test(linea.trim())) {
+                    enBloque = !enBloque;
+                    continue;
+                }
+                if (enBloque) {
+                    out.push(`${pre}  ${c.marca(recortar(linea.replace(/\t/g, '  '), util - 2))}`);
+                    continue;
+                }
+                const titulo = /^#{1,6}\s+(.*)$/.exec(linea);
+                if (titulo) {
+                    for (const l of envolver(c.negrita(titulo[1]), util))
+                        out.push(`${pre}${l}`);
+                    continue;
+                }
+                let l = linea;
+                let sangria = '';
+                const lista = /^(\s*)([-*]|\d+[.)])\s+/.exec(l);
+                if (lista) {
+                    const marca = /\d/.test(lista[2]) ? lista[2] : SIMBOLOS.punto === '●' ? '·' : '-';
+                    l = `${lista[1]}${c.claro(marca)} ${l.slice(lista[0].length)}`;
+                    sangria = ' '.repeat(anchoDe(lista[1]) + anchoDe(marca) + 1);
+                }
+                l = l.replace(/\*\*([^*]+)\*\*/g, (_m, x) => c.negrita(x));
+                l = l.replace(/`([^`]+)`/g, (_m, x) => c.marca(x));
+                for (const p of envolver(l, util, sangria))
+                    out.push(`${pre}${p}`);
+            }
+            return out;
+        });
+    }
+}
+export { bloqueDeLinea };

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@getparallel/parx",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.1",
+  "description": "parx: the coding agent of Parallel in your terminal. Reads and edits your project, runs commands and tests, and does coding tasks end to end. Mac, Windows and Linux.",
+  "keywords": [
+    "parx",
+    "parallel",
+    "getparallel",
+    "ai",
+    "agent",
+    "coding-agent",
+    "cli",
+    "terminal",
+    "developer-tools",
+    "automation"
+  ],
+  "homepage": "https://getparallel.net/docs/apps/parx",
+  "bugs": {
+    "url": "https://getparallel.net/docs/apps/parx"
+  },
+  "author": "Parallel (https://getparallel.net)",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "parx": "dist/cli.js",
+    "parallel-code": "dist/cli.js",
+    "pcode": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "node scripts/limpiar.mjs && tsc -p tsconfig.json && node scripts/ejecutable.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test --experimental-strip-types --no-warnings test/*.test.ts",
+    "verify": "npm run typecheck && npm run test && npm run build",
+    "prepack": "npm run verify",
+    "release": "node scripts/release.mjs",
+    "release:dry": "node scripts/release.mjs --dry-run",
+    "instaladores": "node scripts/instaladores.mjs",
+    "formula": "node scripts/formula.mjs"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@types/node": "^22.10.7"
+  }
+}