@fabioforest/openclaw 3.0.0 → 3.4.0

package/lib/cli/init.js

@@ -10,19 +10,42 @@
 
 const fs = require("fs");
 const path = require("path");
+const readline = require("readline");
 const { initConfigDefaults, writeJsonSafe } = require("../config");
+const { detectContext, getAuditHeader } = require("../context");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
 
+function ask(q) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((res) => rl.question(q, (ans) => { rl.close(); res(ans.trim()); }));
+}
+
+function safeRel(targetPath, p) {
+    return path.relative(targetPath, p);
+}
+
+function writeAudit(targetPath, lines, flags) {
+    if (flags.audit === false) return;
+    const auditDir = path.join(targetPath, ".agent", "audit");
+    if (!fs.existsSync(auditDir)) {
+        // Tenta criar apenas se estivermos em modo apply, mas aqui já devemos estar
+        try { fs.mkdirSync(auditDir, { recursive: true }); } catch (e) { }
+    }
+    const filename = `init-${new Date().toISOString().replace(/[:.]/g, "-")}.md`;
+    const auditPath = path.join(auditDir, filename);
+    try {
+        fs.writeFileSync(auditPath, lines.join("\n") + "\n", "utf8");
+    } catch (e) {
+        console.error("⚠️  Falha ao gravar auditoria:", e.message);
+    }
+}
+
 /**
- * Copia diretório recursivamente.
- * @param {string} src — diretório fonte
- * @param {string} dest — diretório destino
- * @param {object} [stats] — contador de arquivos copiados
- * @returns {object} stats com { files, dirs }
+ * Copia diretório recursivamente (Utilitário mantido)
  */
-function copyDirRecursive(src, dest, stats = { files: 0, dirs: 0 }) {
+function copyDirRecursive(src, dest, stats = { files: 0, dirs: 0, skipped: 0 }, merge = false) {
     if (!fs.existsSync(dest)) {
         fs.mkdirSync(dest, { recursive: true });
         stats.dirs++;
@@ -35,110 +58,143 @@ function copyDirRecursive(src, dest, stats = { files: 0, dirs: 0 }) {
         const destPath = path.join(dest, entry.name);
 
         if (entry.isDirectory()) {
-            copyDirRecursive(srcPath, destPath, stats);
+            copyDirRecursive(srcPath, destPath, stats, merge);
         } else {
-            fs.copyFileSync(srcPath, destPath);
-            stats.files++;
+            if (merge && fs.existsSync(destPath)) {
+                stats.skipped++;
+            } else {
+                fs.copyFileSync(srcPath, destPath);
+                stats.files++;
+            }
         }
     }
-
     return stats;
 }
 
 /**
- * Executa o comando init.
- * @param {object} options
- * @param {string} options.targetPath — diretório alvo
- * @param {object} options.flags — flags do CLI (force, quiet)
+ * Executa o comando init com segurança.
  */
 async function run({ targetPath, flags }) {
     const agentDir = path.join(targetPath, ".agent");
     const configPath = path.join(targetPath, "openclaw.json");
+    const ctx = detectContext(targetPath);
 
-    // Verificar se já existe
-    if (fs.existsSync(agentDir) && !flags.force) {
-        console.error("❌ Diretório .agent/ já existe.");
-        console.error("   Use --force para sobrescrever ou 'openclaw update' para atualizar.");
-        process.exit(1);
-    }
+    // Default: Plan Mode (read-only), exceto se --apply for passado
+    const planMode = !flags.apply;
+
+    const actions = [];
+    const audit = [getAuditHeader(ctx, "init", flags)];
+    const errors = [];
 
-    // Verificar se templates existem
+    // 1. Validar Templates
     if (!fs.existsSync(TEMPLATES_DIR)) {
-        console.error("❌ Templates não encontrados. Pacote pode estar corrompido.");
+        console.error("❌ Templates não encontrados. Pacote corrompido.");
         process.exit(1);
     }
 
-    if (!flags.quiet) {
-        console.log("🦀 OpenClaw — Inicializando projeto...\n");
-    }
-
-    // Se --force e já existe, alertar
-    if (fs.existsSync(agentDir) && flags.force) {
-        if (!flags.quiet) {
-            console.log("⚠️  --force: substituindo .agent/ existente\n");
+    // 2. Construir Plano
+    if (fs.existsSync(agentDir)) {
+        if (!flags.force && !flags.merge) {
+            console.error("❌ Diretório .agent/ já existe.");
+            console.error("   Use --merge (seguro) ou --force (destrutivo).");
+            process.exit(1);
         }
-        fs.rmSync(agentDir, { recursive: true, force: true });
+        if (flags.force) {
+            actions.push({ type: "DELETE_DIR", path: agentDir, reason: "--force requested" });
+            actions.push({ type: "CREATE_DIR", path: agentDir });
+            actions.push({ type: "COPY_DIR", from: TEMPLATES_DIR, to: agentDir });
+        } else if (flags.merge) {
+            actions.push({ type: "MERGE_DIR", from: TEMPLATES_DIR, to: agentDir, reason: "--merge requested" });
+        }
+    } else {
+        actions.push({ type: "CREATE_DIR", path: agentDir });
+        actions.push({ type: "COPY_DIR", from: TEMPLATES_DIR, to: agentDir });
     }
 
-    // Copiar templates
-    const stats = copyDirRecursive(TEMPLATES_DIR, agentDir);
+    if (!fs.existsSync(configPath)) {
+        actions.push({ type: "CREATE_FILE", path: configPath, reason: "Default config" });
+    } else {
+        actions.push({ type: "NOOP", path: configPath, reason: "Config exists" });
+    }
 
-    if (!flags.quiet) {
-        console.log(`✅ .agent/ instalado com sucesso!`);
-        console.log(`   📁 ${stats.dirs} diretórios criados`);
-        console.log(`   📄 ${stats.files} arquivos copiados\n`);
+    // 3. Exibir Plano
+    console.log(`\n🧭 Plano de Execução (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
+    console.log(`   Contexto: ${ctx.env} | IDE: ${ctx.ide}\n`);
+
+    for (const a of actions) {
+        if (a.type === "DELETE_DIR") console.log(`  🔥 DELETE  ${safeRel(targetPath, a.path)} (${a.reason})`);
+        if (a.type === "CREATE_DIR") console.log(`  📁 CREATE  ${safeRel(targetPath, a.path)}`);
+        if (a.type === "COPY_DIR") console.log(`  📦 COPY    templates -> ${safeRel(targetPath, a.to)}`);
+        if (a.type === "MERGE_DIR") console.log(`  🔄 MERGE   templates -> ${safeRel(targetPath, a.to)} (Preservando existentes)`);
+        if (a.type === "CREATE_FILE") console.log(`  📝 CREATE  ${safeRel(targetPath, a.path)}`);
+        if (a.type === "NOOP") console.log(`  ✅ KEEP    ${safeRel(targetPath, a.path)}`);
     }
 
-    // Criar openclaw.json com defaults (se não existir)
-    if (!fs.existsSync(configPath)) {
-        const defaults = initConfigDefaults({});
-        writeJsonSafe(configPath, defaults);
+    if (planMode) {
+        console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
+        console.log("   Para aplicar, rode: npx openclaw init --apply [--merge|--force]");
+        return;
+    }
 
-        if (!flags.quiet) {
-            console.log("📋 openclaw.json criado com configurações padrão\n");
+    // 4. Confirmação
+    if (!flags.yes) {
+        if (actions.some(a => a.type === "DELETE_DIR")) {
+            console.log("\n⚠️  PERIGO: Operação destrutiva detectada (--force).");
+            const phrase = await ask("Digite 'DELETE .agent' para confirmar: ");
+            if (phrase !== "DELETE .agent") {
+                console.log("⏹️  Cancelado.");
+                return;
+            }
+        } else {
+            const ok = await ask("\nAplicar este plano? (y/N): ");
+            if (ok.toLowerCase() !== "y") {
+                console.log("⏹️  Cancelado.");
+                return;
+            }
         }
-    } else if (!flags.quiet) {
-        console.log("📋 openclaw.json já existe — mantido\n");
     }
 
-    // Resumo final
-    if (!flags.quiet) {
-        console.log("📂 Estrutura instalada:");
-        listInstalledStructure(agentDir, "   ");
+    // 5. Execução
+    try {
+        console.log("\n🚀 Executando...");
 
-        console.log("\n🚀 Próximos passos:");
-        console.log("   1. openclaw setup    — configurar ambiente");
-        console.log("   2. openclaw doctor   — verificar saúde");
-        console.log("   3. openclaw status   — ver status\n");
-    }
-}
+        for (const a of actions) {
+            if (a.type === "DELETE_DIR") {
+                fs.rmSync(a.path, { recursive: true, force: true });
+                audit.push(`- ACT: DELETED ${a.path}`);
+            }
+        }
 
-/**
- * Lista a estrutura instalada de forma visual.
- * @param {string} dir — diretório para listar
- * @param {string} prefix — prefixo para indentação
- */
-function listInstalledStructure(dir, prefix = "") {
-    const entries = fs.readdirSync(dir, { withFileTypes: true })
-        .sort((a, b) => {
-            // Diretórios primeiro, depois arquivos
-            if (a.isDirectory() && !b.isDirectory()) return -1;
-            if (!a.isDirectory() && b.isDirectory()) return 1;
-            return a.name.localeCompare(b.name);
-        });
-
-    for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i];
-        const isLast = i === entries.length - 1;
-        const connector = isLast ? "└── " : "├── ";
-        const icon = entry.isDirectory() ? "📁" : "📄";
-
-        console.log(`${prefix}${connector}${icon} ${entry.name}`);
+        // Executar cópia/merge se necessário
+        const copyAction = actions.find(a => a.type === "COPY_DIR" || a.type === "MERGE_DIR");
+        if (copyAction) {
+            const isMerge = copyAction.type === "MERGE_DIR";
+            const stats = copyDirRecursive(TEMPLATES_DIR, agentDir, undefined, isMerge);
+            audit.push(`- ACT: ${isMerge ? "MERGED" : "COPIED"} templates (Files: ${stats.files}, Skipped: ${stats.skipped})`);
+            console.log(`   ✅ Templates processados.`);
+        }
 
-        if (entry.isDirectory()) {
-            const childPrefix = prefix + (isLast ? "    " : "│   ");
-            listInstalledStructure(path.join(dir, entry.name), childPrefix);
+        // Criar config se necessário
+        if (actions.some(a => a.type === "CREATE_FILE" && a.path === configPath)) {
+            const defaults = initConfigDefaults({});
+            writeJsonSafe(configPath, defaults);
+            audit.push(`- ACT: CREATED openclaw.json`);
+            console.log(`   ✅ Config criada.`);
         }
+
+        // Gravar contexto se ainda não existe
+        const contextDir = path.join(agentDir, "context");
+        if (!fs.existsSync(contextDir)) fs.mkdirSync(contextDir, { recursive: true });
+        fs.writeFileSync(path.join(contextDir, "context.json"), JSON.stringify(ctx, null, 2));
+
+        console.log("\n✨ Concluído com sucesso!");
+        writeAudit(targetPath, audit, flags);
+
+    } catch (err) {
+        console.error(`\n❌ Falha na execução: ${err.message}`);
+        audit.push(`\n## ERROR: ${err.message}`);
+        writeAudit(targetPath, audit, flags);
+        process.exit(1);
     }
 }
 

package/lib/cli/inspect.js

@@ -0,0 +1,58 @@
+"use strict";
+
+/**
+ * Comando CLI: inspect
+ *
+ * 100% Read-Only. Coleta e exibe contexto do ambiente sem alterar nada.
+ * Usado como primeiro passo antes de qualquer ação.
+ */
+
+const path = require("path");
+const collectContext = require("../context/collector");
+
+// Caminho dos templates do pacote
+const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
+
+/**
+ * Executa o comando inspect (read-only puro).
+ * @param {object} options
+ * @param {string} options.targetPath — diretório alvo
+ * @param {object} options.flags — flags do CLI
+ */
+async function run({ targetPath, flags }) {
+    const ctx = collectContext({
+        targetPath,
+        templatesDir: TEMPLATES_DIR,
+    });
+
+    if (flags.quiet) {
+        // Modo silencioso: só JSON
+        console.log(JSON.stringify(ctx, null, 2));
+        return ctx;
+    }
+
+    console.log("\n🔎 OpenClaw Inspect (Read-Only)\n");
+    console.log(`   🖥️  Plataforma: ${ctx.env.platform}`);
+    console.log(`   🐳 Docker: ${ctx.env.docker}`);
+    console.log(`   🪟 WSL: ${ctx.env.wsl}`);
+    console.log(`   💻 IDE: ${ctx.ide}`);
+    console.log(`   📂 Path: ${ctx.targetPath}`);
+    console.log(`   📦 OpenClaw instalado: ${ctx.openclaw.hasAgentDir ? "Sim" : "Não"}`);
+    console.log(`   📋 Config: ${ctx.openclaw.hasConfig ? "Sim" : "Não"}`);
+    console.log(`   🐙 Git repo: ${ctx.git.isRepo ? "Sim" : "Não"}`);
+
+    if (ctx.skillsInstalled.length > 0) {
+        console.log(`\n   🧠 Skills instaladas (${ctx.skillsInstalled.length}):`);
+        ctx.skillsInstalled.forEach(s => console.log(`      • ${s.name}`));
+    }
+
+    if (ctx.skillsInTemplates.length > 0) {
+        console.log(`\n   📦 Skills disponíveis nos templates (${ctx.skillsInTemplates.length}):`);
+        ctx.skillsInTemplates.forEach(s => console.log(`      • ${s.name}`));
+    }
+
+    console.log("\n✅ Inspect concluído (nenhuma alteração feita).\n");
+    return ctx;
+}
+
+module.exports = { run };

package/lib/cli/orchestrate.js

@@ -6,6 +6,19 @@ const initCmd = require("./init");
 const doctorCmd = require("./doctor");
 const debugCmd = require("./debug");
 
+const readline = require("readline");
+
+function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => rl.question(query, (ans) => {
+        rl.close();
+        resolve(ans);
+    }));
+}
+
 module.exports = {
     run: async function ({ targetPath, flags }) {
         const agentDir = path.join(targetPath, ".agent");
@@ -15,29 +28,44 @@ module.exports = {
         if (!fs.existsSync(agentDir)) {
             console.log("⚠️  Instalação não encontrada.");
             console.log("🚀 Iniciando processo de instalação (init)...");
-
-            // Repassa flags, força path atual
             await initCmd.run({ targetPath, flags });
             return;
         }
 
-        console.log("✅ Instalação detectada.");
-        console.log("🏥 Executando verificação de saúde (doctor)...");
+        console.log("✅ Instalação detectada! Contexto preservado.");
+        console.log("   (Arquivos em .agent/ encontrados)\n");
 
-        try {
-            // Doctor lança erro ou exit(1) se falhar? 
-            // Precisamos capturar o exit code do doctor se ele for desenhado para matar o processo.
-            // O doctor atual usa exit(1) em erros críticos ou apenas loga?
-            // Vamos checar o doctor depois. Por enquanto, assumimos que ele roda.
+        console.log("O que deseja fazer?");
+        console.log("  [1] 🏥 Verificar Saúde (Doctor) - Recomendado");
+        console.log("  [2] 🔄 Atualizar (Safe Merge) - Adiciona novidades, mantém edições");
+        console.log("  [3] ⚠️  Reinstalar (Force) - ALERTA: Sobrescreve TUDO");
+        console.log("  [4] 🚪 Sair\n");
 
-            await doctorCmd.run({ targetPath, flags });
+        const ans = await askQuestion("Escolha uma opção [1-4]: ");
+        const choice = ans.trim();
 
-            console.log("\n✨ Sistema parece saudável.");
-        } catch (err) {
-            console.log("\n❌ Doctor encontrou problemas ou falhou.");
-            console.log("🔍 Iniciando diagnóstico avançado (debug)...");
+        console.log(""); // quebra de linha
 
-            await debugCmd.run({ targetPath, flags });
+        if (choice === "1" || choice === "") {
+            console.log("🏥 Iniciando Doctor...");
+            await doctorCmd.run({ targetPath, flags });
+        } else if (choice === "2") {
+            console.log("🔄 Iniciando Safe Merge...");
+            // Como o usuário já confirmou interativamente aqui, passamos apply + yes
+            const safeFlags = { ...flags, merge: true, apply: true, yes: true };
+            await initCmd.run({ targetPath, flags: safeFlags });
+        } else if (choice === "3") {
+            const confirm = await askQuestion("Tem certeza? Isso apagará todas as suas customizações em .agent/. Digite 'sim' para confirmar: ");
+            if (confirm.toLowerCase() === "sim") {
+                console.log("⚠️  Iniciando Reinstalação Forçada...");
+                // Aqui passamos force, apply e yes (já confirmou a string "sim")
+                const forceFlags = { ...flags, force: true, apply: true, yes: true };
+                await initCmd.run({ targetPath, flags: forceFlags });
+            } else {
+                console.log("⏹️  Cancelado.");
+            }
+        } else {
+            console.log("👋 Saindo.");
         }
     }
 };

package/lib/cli/update.js

@@ -12,14 +12,38 @@
 const fs = require("fs");
 const path = require("path");
 const crypto = require("crypto");
+const readline = require("readline");
+const { detectContext, getAuditHeader } = require("../context");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
 
+function ask(q) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((res) => rl.question(q, (ans) => { rl.close(); res(ans.trim()); }));
+}
+
+function safeRel(targetPath, p) {
+    return path.relative(targetPath, p);
+}
+
+function writeAudit(targetPath, lines, flags) {
+    if (flags.audit === false) return;
+    const auditDir = path.join(targetPath, ".agent", "audit");
+    if (!fs.existsSync(auditDir)) {
+        try { fs.mkdirSync(auditDir, { recursive: true }); } catch (e) { }
+    }
+    const filename = `update-${new Date().toISOString().replace(/[:.]/g, "-")}.md`;
+    const auditPath = path.join(auditDir, filename);
+    try {
+        fs.writeFileSync(auditPath, lines.join("\n") + "\n", "utf8");
+    } catch (e) {
+        console.error("⚠️  Falha ao gravar auditoria:", e.message);
+    }
+}
+
 /**
- * Calcula o SHA-256 de um arquivo.
- * @param {string} filePath — caminho do arquivo
- * @returns {string} hash em hex
+ * Calcula o SHA-256 de um arquivo (Utilitário mantido)
  */
 function fileHash(filePath) {
     const content = fs.readFileSync(filePath);
@@ -27,14 +51,13 @@ function fileHash(filePath) {
 }
 
 /**
- * Compara e atualiza um diretório recursivamente.
- * @param {string} src — diretório fonte (template)
- * @param {string} dest — diretório destino (instalado)
- * @param {object} stats — contadores { updated, skipped, added }
+ * Analisa atualizações necessárias.
+ * Retorna lista de ações planejadas.
  */
-function updateDirRecursive(src, dest, stats) {
+function planUpdates(src, dest, actions = { added: [], updated: [], skipped: [] }) {
     if (!fs.existsSync(dest)) {
-        fs.mkdirSync(dest, { recursive: true });
+        // Diretório não existe no destino, será criado implicitamente na cópia
+        // Mas a lógica recursiva precisa entrar
     }
 
     const entries = fs.readdirSync(src, { withFileTypes: true });
@@ -44,79 +67,122 @@ function updateDirRecursive(src, dest, stats) {
         const destPath = path.join(dest, entry.name);
 
         if (entry.isDirectory()) {
-            updateDirRecursive(srcPath, destPath, stats);
+            if (!fs.existsSync(destPath)) {
+                // Diretório novo, tudo dentro será added
+                // Simplificação: marcar diretório como added e não recursar? 
+                // Melhor recursar para listar arquivos
+            }
+            planUpdates(srcPath, destPath, actions);
         } else {
             if (!fs.existsSync(destPath)) {
-                // Arquivo novo — copiar
-                fs.copyFileSync(srcPath, destPath);
-                stats.added.push(path.relative(dest, destPath) || entry.name);
+                actions.added.push({ src: srcPath, dest: destPath });
             } else {
-                // Arquivo já existe — comparar hashes
                 const srcHash = fileHash(srcPath);
                 const destHash = fileHash(destPath);
-
                 if (srcHash === destHash) {
-                    // Idêntico — nada a fazer
-                    stats.skipped.push(path.relative(dest, destPath) || entry.name);
+                    actions.skipped.push({ src: srcPath, dest: destPath });
                 } else {
-                    // Diferente — arquivo foi customizado ou template atualizado
-                    // Preserva o original do usuário fazendo backup
-                    const backupPath = destPath + ".bak";
-                    fs.copyFileSync(destPath, backupPath);
-                    fs.copyFileSync(srcPath, destPath);
-                    stats.updated.push(path.relative(dest, destPath) || entry.name);
+                    actions.updated.push({ src: srcPath, dest: destPath });
                 }
             }
         }
     }
+    return actions;
 }
 
 /**
- * Executa o comando update.
- * @param {object} options
- * @param {string} options.targetPath — diretório alvo
- * @param {object} options.flags — flags do CLI
+ * Executa o comando update com segurança.
  */
 async function run({ targetPath, flags }) {
     const agentDir = path.join(targetPath, ".agent");
+    const ctx = detectContext(targetPath);
+
+    // Default: Plan Mode
+    const planMode = !flags.apply;
 
     if (!fs.existsSync(agentDir)) {
         console.error("❌ Diretório .agent/ não encontrado.");
-        console.error("   Rode 'openclaw init' primeiro para instalar os templates.");
+        console.error("   Rode 'openclaw init' primeiro.");
         process.exit(1);
     }
-
     if (!fs.existsSync(TEMPLATES_DIR)) {
-        console.error("❌ Templates não encontrados. Pacote pode estar corrompido.");
+        console.error("❌ Templates não encontrados.");
         process.exit(1);
     }
 
-    if (!flags.quiet) {
-        console.log("\n🔄 OpenClaw Update — Atualizando templates...\n");
+    // 1. Planejar
+    const actions = planUpdates(TEMPLATES_DIR, agentDir);
+    const audit = [getAuditHeader(ctx, "update", flags)];
+
+    // 2. Exibir Plano
+    console.log(`\n🧭 Plano de Atualização (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
+    console.log(`   Contexto: ${ctx.env} | IDE: ${ctx.ide}\n`);
+
+    if (actions.added.length > 0) {
+        console.log(`📄 Novos (${actions.added.length}):`);
+        actions.added.forEach(a => console.log(`   + CREATE ${safeRel(targetPath, a.dest)}`));
+    }
+    if (actions.updated.length > 0) {
+        console.log(`\n🔄 Modificados (${actions.updated.length}):`);
+        actions.updated.forEach(a => console.log(`   ~ UPDATE ${safeRel(targetPath, a.dest)} (Backup gerado)`));
+    }
+    if (actions.skipped.length > 0) {
+        console.log(`\n⏭️  Ignorados (${actions.skipped.length} arquivos idênticos)`);
     }
 
-    const stats = { updated: [], skipped: [], added: [] };
-    updateDirRecursive(TEMPLATES_DIR, agentDir, stats);
+    if (actions.added.length === 0 && actions.updated.length === 0) {
+        console.log("\n✅ Tudo atualizado. Nenhuma alteração necessária.");
+        return;
+    }
+
+    if (planMode) {
+        console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
+        console.log("   Para aplicar, rode: npx openclaw update --apply");
+        return;
+    }
 
-    if (!flags.quiet) {
-        if (stats.added.length > 0) {
-            console.log(`📄 Novos (${stats.added.length}):`);
-            stats.added.forEach((f) => console.log(`   + ${f}`));
+    // 3. Confirmação
+    if (!flags.yes) {
+        const ok = await ask("\nAplicar este plano? (y/N): ");
+        if (ok.toLowerCase() !== "y") {
+            console.log("⏹️  Cancelado.");
+            return;
+        }
+    }
+
+    // 4. Execução
+    try {
+        console.log("\n🚀 Executando atualizações...");
+
+        // Criar diretórios necessários
+        function ensureDir(p) {
+            const dir = path.dirname(p);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
         }
 
-        if (stats.updated.length > 0) {
-            console.log(`\n🔄 Atualizados (${stats.updated.length}):`);
-            stats.updated.forEach((f) => console.log(`   ~ ${f} (backup: ${f}.bak)`));
+        for (const action of actions.added) {
+            ensureDir(action.dest);
+            fs.copyFileSync(action.src, action.dest);
+            audit.push(`- ACT: CREATED ${safeRel(targetPath, action.dest)}`);
         }
 
-        if (stats.skipped.length > 0) {
-            console.log(`\n⏭️  Sem alteração (${stats.skipped.length}):`);
-            stats.skipped.forEach((f) => console.log(`   = ${f}`));
+        for (const action of actions.updated) {
+            ensureDir(action.dest);
+            const backupPath = action.dest + ".bak";
+            fs.copyFileSync(action.dest, backupPath);
+            fs.copyFileSync(action.src, action.dest);
+            audit.push(`- ACT: UPDATED ${safeRel(targetPath, action.dest)} (Backup: ${path.basename(backupPath)})`);
         }
 
-        const total = stats.added.length + stats.updated.length;
-        console.log(`\n✅ Update concluído: ${total} alterações, ${stats.skipped.length} mantidos\n`);
+        console.log("\n✨ Atualização concluída com sucesso!");
+        writeAudit(targetPath, audit, flags);
+
+    } catch (err) {
+        console.error(`\n❌ Falha na execução: ${err.message}`);
+        audit.push(`\n## ERROR: ${err.message}`);
+        writeAudit(targetPath, audit, flags);
+        process.exit(1);
     }
 }
 
-module.exports = { run, updateDirRecursive, fileHash };
+module.exports = { run, fileHash };