primocode 9.8.0-beta.5 → 9.8.0-beta.7

package/lib/checkpoint.js

@@ -13,9 +13,18 @@
  * agente só avisa `antesDeMudar(arquivo, pasta)` — o estado fica aqui, no
  * módulo, e o subagente (mesmo processo) cai no mesmo checkpoint.
  *
- * Onde fica: ~/.primocode/checkpoints/<projeto>-<hash>/<id>/
- *   manifest.json   o pedido, a hora e cada arquivo (existia ou não)
- *   0, 1, 2…        a cópia original de cada arquivo que existia
+ * Dois jeitos de guardar, o melhor que a máquina permitir:
+ *   COM git  — no `iniciar`, uma foto do projeto INTEIRO num git sombra
+ *              (lib/checkpoint-git.js). Cobre o que o run_shell apaga, move ou
+ *              gera, que a tool de arquivo nunca vê.
+ *   SEM git  — o de antes: a cópia de cada arquivo que as tools de arquivo
+ *              vão mexer. Também cobre, com git, o que a foto não pega
+ *              (arquivo ignorado, como dist/, e pasta fora do projeto).
+ *
+ * Onde fica: ~/.primocode/checkpoints/<projeto>-<hash>/
+ *   git/            o repositório sombra (só com git)
+ *   <id>/manifest.json   o pedido, a hora, o sha da foto e os arquivos
+ *   <id>/0, 1, 2…        a cópia original de cada arquivo guardado um a um
  * Só os últimos MAXIMO por projeto: é rede de segurança, não arquivo morto.
  */
 
@@ -25,13 +34,20 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
+const foto = require('./checkpoint-git');
 
 const MAXIMO = 20;
 /** As tools de arquivo que mudam o disco. run_shell fica de fora: não dá para
-    saber, antes de rodar, que arquivos um comando vai tocar. */
+    saber, antes de rodar, que arquivos um comando vai tocar — quem cobre o
+    run_shell é a foto do projeto inteiro, tirada antes do pedido. */
 const MUDAM_ARQUIVO = new Set(['write_file', 'edit_file', 'multi_edit']);
 
-let atual = null;   // o pedido em andamento: { pedido, dir, manifest }
+/* O pedido em andamento:
+     { pedido, git: { projectDir, gitDir, dir, manifest } | null,
+               arq: { dir, manifest } | null }
+   `git` é o checkpoint com foto; `arq` é o por arquivo, para o que cai fora
+   da foto (ou para tudo, quando não há git). */
+let atual = null;
 
 /* os.homedir() lido na hora, não no require: o teste troca o HOME. */
 function raiz() { return path.join(os.homedir(), '.primocode', 'checkpoints'); }
@@ -45,46 +61,94 @@ function pastaDoProjeto(projectDir) {
     return path.join(raiz(), `${nome}-${hash}`);
 }
 
-/** Começa o checkpoint de um pedido. Nada vai ao disco ainda: pedido que não
-    mexe em arquivo (uma pergunta, uma pesquisa) não deixa checkpoint vazio. */
-function iniciar(pedido) {
-    atual = { pedido: String(pedido || '').replace(/\s+/g, ' ').trim(), dir: null, manifest: null };
+/** Pasta que merece foto. A casa da pessoa e o ~/primocode sem projeto
+    ficam de fora: fotografar o disco inteiro a cada pedido seria lento,
+    encheria o ~/.primocode e desfaria coisas que não são do pedido. */
+function podeFotografar(projectDir) {
+    if (!projectDir || !foto.temGit()) return false;
+    const abs = path.resolve(projectDir);
+    const casa = path.resolve(os.homedir());
+    if (abs === casa || abs === path.join(casa, 'primocode') || abs === path.parse(abs).root) return false;
+    try { return fs.statSync(abs).isDirectory(); } catch { return false; }
+}
+
+/** Uma pasta de checkpoint nova. O id é sempre maior que o anterior: a
+    ordem dos ids É a ordem dos pedidos. */
+function novoCheckpoint(projectDir, extra) {
+    const base = pastaDoProjeto(projectDir);
+    fs.mkdirSync(base, { recursive: true });
+    const ultimo = fs.readdirSync(base).filter((n) => /^\d+$/.test(n)).reduce((m, n) => Math.max(m, Number(n)), 0);
+    const dir = path.join(base, String(Math.max(Date.now(), ultimo + 1)));
+    fs.mkdirSync(dir);
+    const manifest = { pedido: atual.pedido, quando: new Date().toISOString(),
+        projectDir: path.resolve(projectDir), ...extra, arquivos: [] };
+    const cp = { dir, manifest };
+    gravarManifest(cp);
+    podar(base);
+    return cp;
+}
+
+function gravarManifest(cp) {
+    fs.writeFileSync(path.join(cp.dir, 'manifest.json'), JSON.stringify(cp.manifest, null, 2));
 }
 
-function encerrar() { atual = null; }
+/** Começa o checkpoint de um pedido. Com git e uma pasta de projeto, a foto
+    é tirada AGORA — antes de qualquer tool rodar. Sem git (ou sem pasta),
+    nada vai ao disco ainda: pedido que não mexe em arquivo não deixa rastro. */
+function iniciar(pedido, projectDir) {
+    atual = { pedido: String(pedido || '').replace(/\s+/g, ' ').trim(), git: null, arq: null };
+    if (!podeFotografar(projectDir)) return;
+    try {
+        const abs = path.resolve(projectDir);
+        const gitDir = path.join(pastaDoProjeto(abs), 'git');
+        const sha = foto.fotografar(gitDir, abs, atual.pedido);
+        if (sha) atual.git = { projectDir: abs, gitDir, ...novoCheckpoint(abs, { git: { sha } }) };
+    } catch { /* sem foto, o checkpoint por arquivo segura o pedido */ }
+}
 
-function gravarManifest() {
-    fs.writeFileSync(path.join(atual.dir, 'manifest.json'), JSON.stringify(atual.manifest, null, 2));
+/** Fecha o pedido. Com foto, anota o que mudou (é o que o `/desfazer lista`
+    mostra) — e, se nada mudou, o checkpoint some: uma pergunta não pode
+    ocupar o lugar de um pedido que o /desfazer deveria voltar. */
+function encerrar() {
+    const g = atual && atual.git;
+    atual = null;
+    if (!g) return;
+    try {
+        const m = foto.mudancas(g.gitDir, g.projectDir, g.manifest.git.sha);
+        if (!m.length && !g.manifest.arquivos.length) { fs.rmSync(g.dir, { recursive: true, force: true }); return; }
+        g.manifest.mudancas = m;
+        gravarManifest(g);
+    } catch { /* sem a conta, a lista calcula na hora */ }
 }
 
-/** Chamado pelo loop ANTES de uma tool de arquivo rodar. Guarda o original só
-    na primeira vez que o arquivo é tocado no pedido — a segunda edição do
-    mesmo arquivo não pode sobrescrever o original com a versão já editada. */
+/** Guarda o original de um arquivo no checkpoint `cp`, uma vez só: a segunda
+    edição do mesmo arquivo não pode sobrescrever o original já editado. */
+function guardarOriginal(cp, abs) {
+    if (cp.manifest.arquivos.some((a) => a.caminho === abs)) return;
+    const existia = fs.existsSync(abs) && fs.statSync(abs).isFile();
+    const item = { caminho: abs, existia };
+    if (existia) {
+        item.copia = String(cp.manifest.arquivos.length);
+        fs.copyFileSync(abs, path.join(cp.dir, item.copia));
+    }
+    cp.manifest.arquivos.push(item);
+    gravarManifest(cp);
+}
+
+/** Chamado pelo loop ANTES de uma tool de arquivo rodar. Se a foto do pedido
+    já cobre o arquivo, não há o que fazer; senão, guarda o original. */
 function antesDeMudar(caminhoAbs, projectDir) {
     if (!atual || !caminhoAbs) return;
     try {
-        if (!atual.dir) {
-            const base = pastaDoProjeto(projectDir);
-            fs.mkdirSync(base, { recursive: true });
-            // Sempre maior que o anterior: a ordem dos ids É a ordem dos pedidos.
-            const ultimo = fs.readdirSync(base).filter((n) => /^\d+$/.test(n)).reduce((m, n) => Math.max(m, Number(n)), 0);
-            const id = String(Math.max(Date.now(), ultimo + 1));
-            atual.dir = path.join(base, id);
-            fs.mkdirSync(atual.dir);
-            atual.manifest = { pedido: atual.pedido, quando: new Date().toISOString(),
-                projectDir: path.resolve(projectDir), arquivos: [] };
-            podar(base);
-        }
         const abs = path.resolve(caminhoAbs);
-        if (atual.manifest.arquivos.some((a) => a.caminho === abs)) return;
-        const existia = fs.existsSync(abs) && fs.statSync(abs).isFile();
-        const item = { caminho: abs, existia };
-        if (existia) {
-            item.copia = String(atual.manifest.arquivos.length);
-            fs.copyFileSync(abs, path.join(atual.dir, item.copia));
+        const g = atual.git;
+        if (g && (abs + path.sep).startsWith(g.projectDir + path.sep)) {
+            if (!foto.ignorado(g.gitDir, g.projectDir, abs)) return;
+            guardarOriginal(g, abs);   // dist/, .gitignore: fora da foto, mas com volta
+            return;
         }
-        atual.manifest.arquivos.push(item);
-        gravarManifest();
+        if (!atual.arq) atual.arq = novoCheckpoint(projectDir || path.dirname(abs), {});
+        guardarOriginal(atual.arq, abs);
     } catch { /* checkpoint nunca derruba o trabalho do agente */ }
 }
 
@@ -93,7 +157,23 @@ function podar(base) {
     for (const velho of ids.slice(MAXIMO)) fs.rmSync(path.join(base, velho), { recursive: true, force: true });
 }
 
-/** Os checkpoints do projeto, o mais novo primeiro. */
+const ACAO_DA_FOTO = { A: 'criado', M: 'mudou', D: 'apagado' };
+
+/** O que o pedido mudou, num formato só para os dois jeitos de guardar. */
+function mudancasDe(cp) {
+    const vistos = new Map();
+    let daFoto = cp.mudancas;
+    if (cp.git && !daFoto) {
+        // Pedido interrompido (ou o que está rodando): a conta é feita agora.
+        try { daFoto = foto.mudancas(path.join(path.dirname(cp.dir), 'git'), cp.projectDir, cp.git.sha); } catch { daFoto = []; }
+    }
+    for (const m of daFoto || []) vistos.set(path.join(cp.projectDir, m.rel), ACAO_DA_FOTO[m.status] || 'mudou');
+    for (const a of cp.arquivos || []) if (!vistos.has(a.caminho)) vistos.set(a.caminho, a.existia ? 'mudou' : 'criado');
+    return [...vistos].map(([caminho, acao]) => ({ caminho, acao }));
+}
+
+/** Os checkpoints do projeto, o mais novo primeiro. Cada um traz `mudou`:
+    os arquivos que o pedido criou, mudou ou apagou. */
 function lista(projectDir) {
     const base = pastaDoProjeto(projectDir);
     let ids = [];
@@ -101,34 +181,69 @@ function lista(projectDir) {
     return ids.sort((a, b) => Number(b) - Number(a)).map((id) => {
         try {
             const m = JSON.parse(fs.readFileSync(path.join(base, id, 'manifest.json'), 'utf8'));
-            return { id, dir: path.join(base, id), ...m };
+            const cp = { id, dir: path.join(base, id), ...m };
+            cp.mudou = mudancasDe(cp);
+            return cp;
         } catch { return null; }
     }).filter(Boolean);
 }
 
+/** O que o /desfazer N vai fazer, para a pessoa ler ANTES de confirmar.
+    Com foto, a conta é contra o disco de agora (inclui o que mudou depois do
+    pedido, que a restauração também volta). */
+function previa(projectDir, n = 1) {
+    const cps = lista(projectDir).slice(0, Math.max(1, n));
+    const vistos = new Map();
+    const maisVelhoComFoto = [...cps].reverse().find((cp) => cp.git);
+    if (maisVelhoComFoto) {
+        try {
+            for (const m of foto.mudancas(path.join(path.dirname(maisVelhoComFoto.dir), 'git'),
+                maisVelhoComFoto.projectDir, maisVelhoComFoto.git.sha)) {
+                vistos.set(path.join(maisVelhoComFoto.projectDir, m.rel), m.status === 'A' ? 'apaga (é novo)' : m.status === 'D' ? 'recria (tinha sumido)' : 'volta ao original');
+            }
+        } catch {}
+    }
+    for (const cp of cps) for (const a of cp.arquivos || []) {
+        if (!vistos.has(a.caminho)) vistos.set(a.caminho, a.existia ? 'volta ao original' : 'apaga (era novo)');
+    }
+    return [...vistos].map(([caminho, acao]) => ({ caminho, acao }));
+}
+
 /** Desfaz os N pedidos mais recentes, do mais novo para o mais velho — assim,
     se dois pedidos mexeram no mesmo arquivo, o que sobra é o original do mais
     antigo. Cada checkpoint desfeito é apagado: o próximo /desfazer volta mais
     um pedido, em vez de repetir o mesmo. */
 function desfazer(projectDir, n = 1) {
-    const feitos = [];
+    const feitos = new Map();   // um arquivo, uma linha: vale a última ação
+    const anotar = (caminho, acao, erro) => { feitos.delete(caminho); feitos.set(caminho, erro ? { caminho, acao, erro } : { caminho, acao }); };
     for (const cp of lista(projectDir).slice(0, Math.max(1, n))) {
+        if (cp.git) {
+            try {
+                for (const f of foto.restaurar(path.join(path.dirname(cp.dir), 'git'), cp.projectDir, cp.git.sha)) {
+                    anotar(path.join(cp.projectDir, f.rel), f.acao, f.erro);
+                }
+            } catch (e) { anotar(cp.projectDir, 'falhou', e.message); }
+        }
         for (const a of cp.arquivos) {
             try {
                 if (a.existia) {
                     fs.mkdirSync(path.dirname(a.caminho), { recursive: true });
                     fs.copyFileSync(path.join(cp.dir, a.copia), a.caminho);
-                    feitos.push({ caminho: a.caminho, acao: 'restaurado' });
+                    anotar(a.caminho, 'restaurado');
                 } else {
                     fs.rmSync(a.caminho, { force: true });
-                    feitos.push({ caminho: a.caminho, acao: 'apagado' });
+                    anotar(a.caminho, 'apagado');
                 }
-            } catch (e) { feitos.push({ caminho: a.caminho, acao: 'falhou', erro: e.message }); }
+            } catch (e) { anotar(a.caminho, 'falhou', e.message); }
         }
         fs.rmSync(cp.dir, { recursive: true, force: true });
-        if (atual && atual.dir === cp.dir) atual = null;
+        if (atual && atual.git && atual.git.dir === cp.dir) atual.git = null;
+        if (atual && atual.arq && atual.arq.dir === cp.dir) atual.arq = null;
     }
-    return feitos;
+    return [...feitos.values()];
 }
 
-module.exports = { MAXIMO, MUDAM_ARQUIVO, iniciar, encerrar, antesDeMudar, lista, desfazer, pastaDoProjeto };
+/** Qual jeito de guardar vale nesta pasta — o /desfazer lista conta à pessoa. */
+function modo(projectDir) { return podeFotografar(projectDir) ? 'foto' : 'arquivo'; }
+
+module.exports = { MAXIMO, MUDAM_ARQUIVO, iniciar, encerrar, antesDeMudar, lista, previa, desfazer, modo, pastaDoProjeto };