@andre.buzeli/git-mcp 15.12.6 → 16.0.1

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@andre.buzeli/git-mcp",
-  "version": "15.12.6",
+  "version": "16.0.1",
   "private": false,
   "description": "MCP server para Git com operações locais e sincronização paralela GitHub/Gitea",
   "license": "MIT",
-  "author": "andrebuzeli",
+  "author": "andre.buzeli",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/utils/errors.js

@@ -167,7 +167,7 @@ export const ERROR_CODES = {
   // Git Corruption
   GIT_CORRUPTED: {
     code: "GIT_CORRUPTED",
-    suggestion: "Repositório Git corrompido. Tente: 1) git fsck --full, 2) git gc --prune=now, ou 3) re-clone do remote"
+    suggestion: "Repositório Git corrompido. O sistema tentou auto-corrigir (remove index, gc --prune=now, re-add). Se persistir, re-clone do remote"
   },
   GIT_LOCK_FILE: {
     code: "GIT_LOCK_FILE",
@@ -312,7 +312,9 @@ export function mapExternalError(error, context = {}) {
 
   // Git corruption
   if (msg.includes("corrupt") || msg.includes("bad object") || msg.includes("broken") ||
-    msg.includes("missing object") || msg.includes("invalid sha") || msg.includes("fatal: packed")) {
+    msg.includes("missing object") || msg.includes("invalid sha") || msg.includes("fatal: packed") ||
+    msg.includes("invalid object") || msg.includes("error building trees") ||
+    msg.includes("unable to read tree")) {
     return createError("GIT_CORRUPTED", { originalError: msg });
   }
 

package/src/utils/gitAdapter.js

@@ -181,6 +181,124 @@ export class GitAdapter {
                 }
             }
 
+            // Auto-fix 4: Git object corruption (invalid object, error building trees, bad object, unable to read tree)
+            if ((msg.includes("invalid object") || msg.includes("error building trees") ||
+                msg.includes("bad object") || msg.includes("corrupt") ||
+                msg.includes("missing object") || msg.includes("broken link") ||
+                msg.includes("unable to read tree")) &&
+                !options._corruptionRetried) {
+                console.error("[GitAdapter] Auto-fix: git object corruption detected, attempting multi-step recovery...");
+                try {
+                    // Step 1: Remove corrupt index file
+                    const indexPath = path.join(dir, ".git", "index");
+                    if (fs.existsSync(indexPath)) {
+                        try { fs.unlinkSync(indexPath); } catch { }
+                        console.error("[GitAdapter] Removed corrupt index file");
+                    }
+
+                    // Step 2: Try to clean corrupt refs (branches pointing to bad objects)
+                    try {
+                        const packedRefsPath = path.join(dir, ".git", "packed-refs");
+                        if (fs.existsSync(packedRefsPath)) {
+                            // Read packed refs and remove lines referencing corrupt objects
+                            const content = fs.readFileSync(packedRefsPath, "utf8");
+                            const lines = content.split("\n");
+                            const cleanLines = lines.filter(line => {
+                                // Keep header and non-ref lines
+                                if (line.startsWith("#") || !line.trim()) return true;
+                                // Keep lines that DON'T reference tmp/ or test branches
+                                return !line.includes("tmp/") && !line.includes("test-");
+                            });
+                            if (cleanLines.length !== lines.length) {
+                                fs.writeFileSync(packedRefsPath, cleanLines.join("\n"), "utf8");
+                                console.error(`[GitAdapter] Cleaned ${lines.length - cleanLines.length} potentially corrupt packed refs`);
+                            }
+                        }
+                    } catch { }
+
+                    // Step 3: Remove loose corrupt objects (they'll be re-created)
+                    try {
+                        const objectsDir = path.join(dir, ".git", "objects");
+                        // Run fsck to identify broken objects (ignore errors)
+                        const fsckOutput = await this._runSpawn(this.gitPath, ["fsck", "--no-dangling"], dir).catch(e => e.message || "");
+                        const brokenShas = [];
+                        const fsckLines = (typeof fsckOutput === "string" ? fsckOutput : "").split("\n");
+                        for (const line of fsckLines) {
+                            // Match patterns like "error in tree SHA: invalid object"
+                            const shaMatch = line.match(/([0-9a-f]{40})/);
+                            if (shaMatch && (line.includes("invalid") || line.includes("corrupt") || line.includes("broken") || line.includes("missing"))) {
+                                brokenShas.push(shaMatch[1]);
+                            }
+                        }
+                        // Remove identified corrupt loose objects
+                        for (const sha of brokenShas) {
+                            const objPath = path.join(objectsDir, sha.substring(0, 2), sha.substring(2));
+                            if (fs.existsSync(objPath)) {
+                                try { fs.unlinkSync(objPath); console.error(`[GitAdapter] Removed corrupt object: ${sha.substring(0, 8)}`); } catch { }
+                            }
+                        }
+                    } catch { }
+
+                    // Step 4: Try gc (may fail with deep corruption, that's OK)
+                    await this._runSpawn(this.gitPath, ["reflog", "expire", "--expire=now", "--all"], dir).catch(() => { });
+                    await this._runSpawn(this.gitPath, ["gc", "--prune=now", "--aggressive"], dir).catch(() => { });
+
+                    // Step 5: Try simple reset first
+                    let resetOk = false;
+                    try {
+                        await this._runSpawn(this.gitPath, ["reset"], dir);
+                        resetOk = true;
+                    } catch {
+                        // Reset failed (HEAD tree is corrupt) - try nuclear recovery
+                        console.error("[GitAdapter] Simple reset failed, attempting nuclear recovery...");
+                        try {
+                            // Re-add all working directory files to create fresh objects
+                            await this._runSpawn(this.gitPath, ["add", "."], dir);
+                            // Create new tree from working directory
+                            const newTree = await this._runSpawn(this.gitPath, ["write-tree"], dir);
+                            if (newTree && newTree.match(/^[0-9a-f]{40}$/)) {
+                                // Find a valid parent commit (walk back until we find one)
+                                let parentArg = [];
+                                for (let i = 1; i <= 10; i++) {
+                                    try {
+                                        const parentSha = await this._runSpawn(this.gitPath, ["rev-parse", `HEAD~${i}`], dir);
+                                        if (parentSha && parentSha.match(/^[0-9a-f]{40}$/)) {
+                                            parentArg = ["-p", parentSha];
+                                            console.error(`[GitAdapter] Found valid parent at HEAD~${i}: ${parentSha.substring(0, 8)}`);
+                                            break;
+                                        }
+                                    } catch { continue; }
+                                }
+                                // Create recovery commit using low-level git commands
+                                const newCommit = await this._runSpawn(this.gitPath,
+                                    ["commit-tree", newTree, ...parentArg, "-m", "chore: auto-recovery from git object corruption"], dir);
+                                if (newCommit && newCommit.match(/^[0-9a-f]{40}$/)) {
+                                    // Point HEAD to the new clean commit
+                                    await this._runSpawn(this.gitPath, ["update-ref", "HEAD", newCommit], dir);
+                                    console.error(`[GitAdapter] Nuclear recovery complete: created clean commit ${newCommit.substring(0, 8)}`);
+                                    resetOk = true;
+                                }
+                            }
+                        } catch (nuclearError) {
+                            console.error("[GitAdapter] Nuclear recovery failed:", nuclearError.message);
+                        }
+                    }
+
+                    // Step 6: Final re-add (rebuild index from working directory)
+                    await this._runSpawn(this.gitPath, ["add", "."], dir).catch(() => { });
+
+                    if (resetOk) {
+                        console.error("[GitAdapter] Recovery complete, retrying operation...");
+                        return await this._exec(dir, args, { ...options, _corruptionRetried: true });
+                    } else {
+                        console.error("[GitAdapter] Recovery partially failed. Retrying anyway...");
+                        return await this._exec(dir, args, { ...options, _corruptionRetried: true });
+                    }
+                } catch (recoveryError) {
+                    console.error("[GitAdapter] Recovery failed:", recoveryError.message);
+                }
+            }
+
             if (options.ignoreErrors) return "";
 
             // Enhance error message with context