primocode 11.2.0 → 11.3.1

package/lib/projetos-meta.js

@@ -6,7 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const ICONES = ['folder', 'film', 'palette', 'workflow', 'pen', 'home', 'shield', 'bell', 'sliders'];
+const ICONES = ['folder', 'film', 'palette', 'workflow', 'pen', 'home', 'shield', 'bell', 'sliders', 'code', 'rocket', 'cake', 'store', 'clapperboard', 'megaphone', 'graduation-cap', 'heart', 'camera', 'music'];
 const COR_PADRAO = '#22d3ee';
 const hexOk = (h) => /^#[0-9a-f]{6}$/i.test(String(h || ''));
 const cfg = () => require('./config/config');
@@ -36,6 +36,21 @@ function ramoGit(dir) {
     } catch { return { git: false, ramo: '' }; }
 }
 
+/* O "dono/repo" do remoto origin, lido do .git/config (sem rodar o git). Vazio se não há. */
+function remotoGit(dir) {
+    try {
+        const cfg = fs.readFileSync(path.join(dir, '.git', 'config'), 'utf8');
+        const m = /\[remote "origin"\][^\[]*?url\s*=\s*(\S+)/.exec(cfg);
+        const r = m && /[:/]([\w.-]+\/[\w.-]+?)(?:\.git)?$/.exec(m[1]);
+        return r ? r[1] : '';
+    } catch { return ''; }
+}
+
+/* Quantos itens (arquivos e pastas, sem os ocultos) o projeto tem na raiz, e quando mexeram nele por último. */
+function conteudo(dir) {
+    try { return { itens: fs.readdirSync(dir).filter((n) => !n.startsWith('.')).length, atualizado: fs.statSync(dir).mtimeMs }; } catch { return { itens: 0, atualizado: null }; }
+}
+
 function resumo(id) {
     const dir = path.join(raiz(), id);
     const m = lerMeta(dir);
@@ -43,12 +58,14 @@ function resumo(id) {
         id, nome: m.nome || id, descricao: m.descricao || '',
         icone: ICONES.includes(m.icone) ? m.icone : 'folder', cor: hexOk(m.cor) ? m.cor : COR_PADRAO,
         caminho: dir, arquivado: !!m.arquivado, criado: m.criado || null,
-        ...ramoGit(dir),
+        ...ramoGit(dir), remoto: remotoGit(dir), ...conteudo(dir),
     };
 }
 
 function listar({ arquivados = false } = {}) {
-    return cfg().listProjects().map(resumo).filter((p) => arquivados || !p.arquivado);
+    /* O mais recente primeiro (como a lista da barra lateral); empate por nome. */
+    return cfg().listProjects().map(resumo).filter((p) => arquivados || !p.arquivado)
+        .sort((a, b) => String(b.criado || '').localeCompare(String(a.criado || '')) || a.nome.localeCompare(b.nome));
 }
 
 function limpar(c, { criando = false } = {}) {

package/lib/session/runner/act.js

@@ -246,6 +246,17 @@ function ident(profundidade) {
  * duas versões do texto, que o `limparParaOModelo` apaga antes de a conversa
  * seguir. Sem essa limpeza, cada edição mandaria o arquivo inteiro de volta
  * ao modelo — que acabou de escrevê-lo e não aprende nada relendo. */
+/* +N −M de uma escrita ou edição: o diff de verdade (linhas que entraram e saíram). Arquivo
+   novo conta todas as linhas como entradas. Sem as duas versões nem a contagem, null. */
+function contarMudanca(result) {
+    if (!result) return null;
+    if (typeof result._antes === 'string' && typeof result._depois === 'string') {
+        try { return diff.contar(diff.operacoes(result._antes, result._depois)); } catch { return null; }
+    }
+    if (result.created && Number.isFinite(result.linhas)) return { mais: result.linhas, menos: 0 };
+    return null;
+}
+
 function mostrarDiff(result, profundidade) {
     if (!result || typeof result._antes !== 'string' || typeof result._depois !== 'string') return;
     const bloco = diff.desenhar(result._antes, result._depois, {
@@ -287,17 +298,24 @@ function logResult(kind, result, profundidade) {
     }
 
     switch (kind) {
-        case 'write_file':
-            console.log(p + c.muted(`${result.created ? 'criado' : 'atualizado'} · ${tools.fmtBytes(result.bytes)}`));
+        case 'write_file': {
+            const k = contarMudanca(result);
+            if (k) require('../../tui/ui').registrarArquivo(result.path, k.mais, k.menos);
+            console.log(p + c.muted(`${result.created ? 'criado' : 'atualizado'} · ${tools.fmtBytes(result.bytes)}`)
+                + (k ? c.muted(' · ') + c.ok(`+${k.mais}`) + ' ' + c.err(`−${k.menos}`) : ''));
             // Reescrever arquivo que já existia apaga o que estava lá. O
             // número de bytes não conta isso; o bloco embaixo conta.
             mostrarDiff(result, profundidade);
             return;
+        }
         case 'edit_file':
         case 'multi_edit': {
             const delta = result.linhasDepois - result.linhasAntes;
             const sinal = delta > 0 ? c.ok(`+${delta}`) : delta < 0 ? c.err(`${delta}`) : c.muted('±0');
-            console.log(p + c.muted(`${result.substituicoes} troca${result.substituicoes > 1 ? 's' : ''} · `) + sinal + c.muted(' linhas'));
+            const k = contarMudanca(result);
+            if (k) require('../../tui/ui').registrarArquivo(result.path, k.mais, k.menos);
+            console.log(p + c.muted(`${result.substituicoes} troca${result.substituicoes > 1 ? 's' : ''} · `) + sinal + c.muted(' linhas')
+                + (k ? c.muted(' · ') + c.ok(`+${k.mais}`) + ' ' + c.err(`−${k.menos}`) : ''));
             mostrarDiff(result, profundidade);
             return;
         }
@@ -342,6 +360,7 @@ function logResult(kind, result, profundidade) {
             return;
         }
         case 'write_todos': {
+            require('../../tui/ui').estadoSessao.todos = result.todos || [];
             const marca = { completed: c.ok('✔'), in_progress: c.brand('▶'), pending: c.dim('○') };
             for (const t of result.todos || []) {
                 const texto = t.status === 'completed' ? c.dim(t.content) : c.white(t.content);
@@ -2287,7 +2306,7 @@ async function runActInterno(userPrompt, opts) {
     // arquivo de verdade — a memória era descartada nesse caso, sempre.
     // A raiz de trabalho não é projeto: um memory.md solto em ~/primocode
     // era o que um pedido de vídeo (que trabalha na raiz) deixava para trás.
-    if (!subagent && temPasta && require('path').resolve(pastaAtual) !== require('path').resolve(cfg.ROOT_DIR)) {
+    if (!subagent && temPasta && pastaAtual && require('path').resolve(pastaAtual) !== require('path').resolve(cfg.ROOT_DIR)) {
         cfg.appendProjectMemory(pastaAtual, passagemDaParada || `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
     }
 

package/lib/tool/tools.js

@@ -688,6 +688,7 @@ async function despachar(name, args, ctx) {
                     ok: true, created,
                     path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
                     bytes: content.length,
+                    linhas: content.split('\n').length,
                     ...(created ? {} : { _antes: antes, _depois: content }),
                 };
             }

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. */