primocode 11.2.0 → 11.3.0

package/lib/tui/entrada.js

@@ -162,11 +162,11 @@ function quebrar(texto, w) {
  * @returns {{linhas: string[], cursorLinha: number, cursorColuna: number}}
  */
 function montar(e) {
-    const colunas = Math.max(24, Math.min(e.colunas || 80, 200));
+    const colunas = Math.max(24, Math.min(e.colunas || 80, 500));
     /* Na ABERTURA (nada mandado ainda) a caixa é estreita e centrada embaixo
        do logo, como a home do OpenCode; depois do primeiro pedido ela ocupa a
        largura toda. `recuo` é a margem da esquerda, que entra em toda linha. */
-    const largura = e.centro ? Math.min(colunas - 1, 80) : colunas - 1;   // a última coluna
+    const largura = e.centro ? Math.min(colunas - 1, Math.max(80, Math.min(Math.round(colunas * 0.6), 160))) : colunas - 1;   // a última coluna
                                     // fica livre: escrever nela faz o terminal quebrar a linha
     const recuo = e.centro ? Math.max(0, Math.floor((colunas - largura) / 2)) : 0;
     const w = Math.max(8, largura - PREFIXO);
@@ -237,15 +237,20 @@ function montar(e) {
     // ── a linha de baixo: pasta à esquerda, atalhos à direita ────────────
     if (st.linhas) {
         for (const linha of st.linhas) out.push(' ' + truncate(linha, largura - 2));
-    } else {
+    } else if (!e.centro) {
         /* Uma linha vazia entre o painel e o rodapé. Colado, o rodapé parecia
            SOBREPOSTO ao painel em terminais de entrelinha apertada (o Orca):
            o fundo do painel encostava nas letras da pasta. */
         out.push('');
         const esq = st.esquerda || '';
-        const dir = st.direita || '';
+        let dir = st.direita || '';
+        /* Sem espaço para tudo, ficam os ATALHOS (é o que a pessoa não sabe que existe) e a pasta
+           encolhe; antes disto a linha perdia os atalhos e ficava só a pasta. */
+        if (largura - 2 - visibleWidth(esq) - visibleWidth(dir) < 2 && st.atalhos) dir = st.atalhos;
         const sobra = largura - 2 - visibleWidth(esq) - visibleWidth(dir);
-        out.push(' ' + (sobra >= 2 ? esq + ' '.repeat(sobra) + dir : truncate(esq, largura - 2)));
+        out.push(' ' + (sobra >= 2 ? esq + ' '.repeat(sobra) + dir
+            : visibleWidth(dir) + 14 <= largura - 2 ? truncate(esq, largura - 2 - visibleWidth(dir) - 2) + '  ' + dir
+                : truncate(esq, largura - 2)));
     }
 
     // ── o menu dos comandos ──────────────────────────────────────────────
@@ -296,7 +301,7 @@ function montar(e) {
 
 /** O pedido que foi mandado, como fica no histórico da tela: um painel. */
 function pedidoNaTela(texto, colunas, guardados = []) {
-    const largura = Math.max(24, Math.min(colunas || 80, 200)) - 1;
+    const largura = Math.max(24, Math.min(colunas || 80, 500)) - 1;
     const barra = `${COR.barra}┃${COR.reset}`;
     const linhas = quebrar(texto, Math.max(8, largura - PREFIXO))
         .map((l) => painel(barra + '   ' + pintarEtiquetas(c.white(l.texto)), largura));
@@ -338,6 +343,12 @@ class Entrada extends EventEmitter {
         this.cheia = !!(op.telaCheia && this.tty);
         this.conversa = [];
         this.rolagem = 0;
+        // Diálogo aberto (paleta, modelo, agente, sessões, tema), o aviso do canto e a barra da direita.
+        this.dialogo = null;
+        this.toastAtual = null;
+        this.lateralOculta = false;
+        this._lider = false;
+        this._modoCor = tela.modoDeCor();
     }
 
     // ── ciclo de vida ────────────────────────────────────────────────────
@@ -360,7 +371,7 @@ class Entrada extends EventEmitter {
         this._aoTeclar = (ch, key) => this._tecla(ch, key);
         process.stdin.on('keypress', this._aoTeclar);
 
-        this._aoRedimensionar = () => { if (this.cheia) { this._quadroAnterior = null; this._pintar(); } else if (this.desenhado) this._redesenhar(); };
+        this._aoRedimensionar = () => { if (this.cheia) { if (this._naTela) this.escreverCru('\x1b[2J'); this._quadroAnterior = null; this._pintar(); } else if (this.desenhado) this._redesenhar(); };
         process.stdout.on('resize', this._aoRedimensionar);
 
         /* Todo `console.log` do programa passa a apagar a caixa antes de
@@ -384,6 +395,7 @@ class Entrada extends EventEmitter {
                 return true;
             }
             eu._apagar();
+            if (eu._modoCor === 'none') texto = tela.adaptarCor(texto, 'none');
             const r = eu._stdoutOriginal.call(this, texto, ...resto);
             /* ── O TEXTO QUE CHEGA EM PEDAÇOS ────────────────────────────
                A resposta do chat sai em fluxo: dezenas de `write` pequenos,
@@ -495,7 +507,7 @@ class Entrada extends EventEmitter {
             this._colunasReais = process.stdout.columns || 80;
             Object.defineProperty(process.stdout, 'columns', {
                 configurable: true,
-                get() { return eu._naTela ? tela.larguraDaConversa(eu._colunasReais) : eu._colunasReais; },
+                get() { return eu._naTela ? tela.larguraDaConversa(eu._colunasReais, eu.lateralOculta) : eu._colunasReais; },
                 set(v) { eu._colunasReais = v; },   // o Node escreve aqui quando a janela muda
             });
         }
@@ -530,16 +542,15 @@ class Entrada extends EventEmitter {
         const quadro = Date.now() / 140;
         /* O topo da barra da direita: o logo do PrimoCode (que anima enquanto
            ele trabalha) e o ESTADO — trabalhando, há quanto tempo, no quê. */
-        const topo = this.op.logoAnimado ? this.op.logoAnimado(quadro, trabalhando) : [];
-        topo.push('');
+        const pe = this.op.logoAnimado ? this.op.logoAnimado(quadro, trabalhando) : [];
         if (trabalhando) {
             const giro = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'][Math.floor(quadro) % 10];
-            topo.push(c.warn(giro + ' Trabalhando') + (this._desde ? c.dim(` · ${Math.floor((Date.now() - this._desde) / 1000)}s`) : ''));
+            pe.push(c.warn(giro + ' Trabalhando') + (this._desde ? c.dim(` · ${Math.floor((Date.now() - this._desde) / 1000)}s`) : ''));
             const agora = this.op.agora ? this.op.agora() : '';
-            if (agora) topo.push(c.muted(agora));
-            if (this.spinnerTexto) topo.push(c.dim(stripAnsiLocal(this.spinnerTexto).replace(/^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s*/, '')));
+            const detalhe = agora || (this.spinnerTexto ? stripAnsiLocal(this.spinnerTexto).replace(/^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s*/, '') : '');
+            if (detalhe) pe.push(c.dim(detalhe));
         } else {
-            topo.push(c.brand('● ') + c.muted('Pronto') + c.dim(' · esperando você'));
+            pe.push(c.brand('● ') + c.muted('Pronto') + c.dim(' · esperando você'));
         }
         if (trabalhando && !this._animando) {
             // Enquanto trabalha, a barra se redesenha sozinha (o logo anima
@@ -554,10 +565,16 @@ class Entrada extends EventEmitter {
             rolagem: this.rolagem,
             home: !this.mandou && !conversa && !this.painelTexto,
             caixa: (colunas, centro) => montar({ ...this._estado(), colunas, centro, menuAcima: true }),
-            lateral: { titulo: this.titulo, topo, ...(this.op.lateral ? this.op.lateral() : {}) },
+            lateral: { titulo: this.titulo, pe, ...(this.op.lateral ? this.op.lateral() : {}) },
+            lateralOculta: this.lateralOculta,
+            dialogo: this._dialogoParaTela(),
+            toast: this.toastAtual,
             painel: this.painelTexto,
             versao: this.op.versao || '',
+            plano: this.op.plano ? this.op.plano() : '',
+            comandosHome: this.op.comandosHome,
             logo: this.op.logo,
+            logoSimples: this.op.logoSimples,
             pasta: this.op.pasta ? this.op.pasta() : '',
         });
     }
@@ -575,7 +592,7 @@ class Entrada extends EventEmitter {
         let corpo = '';
         q.linhas.forEach((l, i) => {
             if (mesmoTamanho && antes.linhas[i] === l) return;
-            corpo += `\x1b[${i + 1};1H${l}\x1b[0m\x1b[K`;
+            corpo += `\x1b[${i + 1};1H${tela.adaptarCor(l, this._modoCor)}\x1b[0m\x1b[K`;
         });
         const mesmoCursor = antes && antes.cursor.linha === q.cursor.linha && antes.cursor.coluna === q.cursor.coluna;
         this._quadroAnterior = { linhas: q.linhas, cursor: q.cursor };
@@ -816,6 +833,9 @@ class Entrada extends EventEmitter {
             return;
         }
 
+        if (this.dialogo) return this._teclaDialogo(ch, key);
+        if (this._lider) { this._lider = false; if (key && !key.ctrl && key.name !== 'escape') return this._atalhoDoLider(key); }
+
         if (!key) { if (ch) this.write(ch); return; }
 
         // Esc Esc e o resto das teclas de fora: quem escuta decide. A caixa
@@ -935,16 +955,121 @@ class Entrada extends EventEmitter {
                 if (this.cheia) { this.conversa = []; this.rolagem = 0; return this._pintar(); }
                 this._apagar(); this.escreverCru('\x1b[2J\x1b[H'); return this._desenhar();
             case 'j': return this._novaLinha();
-            // Ctrl+P abre os comandos, como no OpenCode: o mesmo menu do "/".
+            // Ctrl+P abre a paleta de comandos, como no OpenCode (a lista com busca no meio da tela).
             case 'p':
+                if (this.cheia && this.op.paleta) return this.abrirDialogo({ titulo: 'Comandos', itens: this.op.paleta(), aoEscolher: (it) => this._rodarItem(it) });
                 if (this.line && !this.line.startsWith('/')) return;
                 if (!this.line) { this.line = '/'; this.cursor = 1; }
                 this._filtrarMenu();
                 return this._redesenhar();
+            // Ctrl+X é o "líder" do OpenCode: a tecla seguinte escolhe (n nova, m modelo, a agente, l sessões, t tema, b barra).
+            case 'x':
+                if (!this.cheia) return;
+                this._lider = true;
+                clearTimeout(this._liderTempo);
+                this._liderTempo = setTimeout(() => { this._lider = false; }, 2500);
+                if (this._liderTempo.unref) this._liderTempo.unref();
+                this.toast('ctrl+x  n nova · m modo · a agentes · l sessões · t tema · b barra', 'info', 2400);
+                return;
             default: return;
         }
     }
 
+    // ── diálogos, paleta e avisos (o `dialog-*` e o toast do OpenCode) ────
+
+    /**
+     * Abre uma lista com busca no meio da tela.
+     * @param {{titulo:string, itens:Array<{nome,desc,tecla,secao}>|(()=>Array), aoEscolher:(item:object)=>void}} def
+     */
+    abrirDialogo(def) {
+        this.menu = null;
+        this.dialogo = { ...def, filtro: '', sel: 0 };
+        this._pintar();
+    }
+
+    /** Volta à home: conversa, título e tarefas zeradas (o /clear e o ctrl+x n). */
+    novaConversa() {
+        this.conversa = []; this.rolagem = 0; this.titulo = ''; this.mandou = false;
+        this._quadroAnterior = null;
+        if (this.cheia) this._pintar();
+    }
+
+    fecharDialogo() { this.dialogo = null; this._quadroAnterior = null; this._pintar(); }
+
+    _itensDoDialogo() {
+        const d = this.dialogo;
+        const todos = typeof d.itens === 'function' ? d.itens() : (d.itens || []);
+        const sem = (t) => String(t || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+        const q = sem(d.filtro).trim();
+        if (!q) return todos;
+        return todos.filter((it) => q.split(/\s+/).every((p) => sem(`${it.nome} ${stripAnsiLocal(it.desc || '')} ${it.secao || ''}`).includes(p)));
+    }
+
+    _dialogoParaTela() {
+        if (!this.dialogo) return null;
+        const itens = this._itensDoDialogo();
+        this.dialogo.sel = Math.max(0, Math.min(this.dialogo.sel, itens.length - 1));
+        return { titulo: this.dialogo.titulo, filtro: this.dialogo.filtro, itens, sel: this.dialogo.sel, vazio: this.dialogo.vazio };
+    }
+
+    _teclaDialogo(ch, key) {
+        const d = this.dialogo;
+        const seq = (key && key.sequence) || ch || '';
+        const n = this._itensDoDialogo().length;
+        const mover = (p) => { d.sel = Math.max(0, Math.min(n - 1, d.sel + p)); this._pintar(); };
+        if (key && key.name === 'escape') return this.fecharDialogo();
+        if (key && key.ctrl && key.name === 'c') return this.fecharDialogo();
+        if (key && (key.name === 'up' || (key.ctrl && key.name === 'p'))) return mover(-1);
+        if (key && (key.name === 'down' || (key.ctrl && key.name === 'n'))) return mover(1);
+        if (key && key.name === 'pageup') return mover(-8);
+        if (key && key.name === 'pagedown') return mover(8);
+        if (key && (key.name === 'return' || key.name === 'enter')) {
+            const item = this._itensDoDialogo()[d.sel];
+            this.dialogo = null; this._quadroAnterior = null;
+            this._pintar();
+            if (item && d.aoEscolher) d.aoEscolher(item, this);
+            return;
+        }
+        if (key && key.name === 'backspace') { d.filtro = d.filtro.slice(0, -1); d.sel = 0; return this._pintar(); }
+        if (seq && !(key && (key.ctrl || key.meta)) && seq >= ' ' && seq !== '\x7f') { d.filtro += seq; d.sel = 0; this._pintar(); }
+    }
+
+    /** Roda um item da paleta: comando de barra vai como se tivesse sido digitado; função é chamada. */
+    _rodarItem(it) {
+        if (!it) return;
+        if (typeof it.acao === 'function') return it.acao(this);
+        const cmd = it.cmd || it.nome;
+        if (it.preencher) { this.line = cmd; this.cursor = cmd.length; return this._redesenhar(); }
+        this.line = cmd; this.cursor = cmd.length;
+        this._enviar();
+    }
+
+    /** A tecla depois do ctrl+x. */
+    _atalhoDoLider(key) {
+        const d = this.op.dialogos || {};
+        const abrir = (nome) => { if (d[nome]) Promise.resolve(d[nome](this)).then((def) => { if (def) this.abrirDialogo(def); }); };
+        switch (key.name) {
+            case 'n': return this._rodarItem({ cmd: '/clear' });
+            case 'p': return this._rodarItem({ cmd: '/projects' });
+            case 's': return this._rodarItem({ cmd: '/estudio' });
+            case 'm': return abrir('modelo');
+            case 'a': return abrir('agente');
+            case 'l': return abrir('sessoes');
+            case 't': return abrir('tema');
+            case 'b': this.lateralOculta = !this.lateralOculta; this._quadroAnterior = null; return this._pintar();
+            default: return;
+        }
+    }
+
+    /** Um aviso no canto de cima por alguns segundos. tipo: info · ok · aviso · erro. */
+    toast(texto, tipo = 'info', ms = 3000) {
+        this.toastAtual = { texto: String(texto || ''), tipo };
+        clearTimeout(this._toastTempo);
+        this._toastTempo = setTimeout(() => { this.toastAtual = null; this._quadroAnterior = null; this._agendar(); }, ms);
+        if (this._toastTempo.unref) this._toastTempo.unref();
+        if (this.cheia) this._agendar();
+    }
+
     _novaLinha() {
         this.line = this.line.slice(0, this.cursor) + '\n' + this.line.slice(this.cursor);
         this.cursor++;
@@ -1010,7 +1135,7 @@ class Entrada extends EventEmitter {
             // painel da caixa, com a barra, e um respiro em cima e embaixo.
             if (this.cheia) {
                 const W = this._colunasReais || 80;
-                const mainW = W >= tela.LATERAL_MIN ? W - tela.LATERAL_W : W;
+                const mainW = W - tela.larguraLateral(W, this.lateralOculta);
                 this.rolagem = 0;
                 /* Uma linha em branco antes e outra depois do pedido: cada
                    troca (pedido, resposta) é um bloco separado na tela. */