@andrebuzeli/git-mcp 12.0.0 → 13.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "12.0.0",
+  "version": "13.5.0",
   "private": false,
   "description": "MCP server para Git com operações locais e sincronização paralela GitHub/Gitea",
   "license": "MIT",

package/src/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/dist/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/dist/server/stdio.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import Ajv from "ajv";
 import { asToolError } from "./utils/errors.js";
 import { ProviderManager } from "./providers/providerManager.js";
@@ -52,13 +52,13 @@ function listToolsResult() {
 
 server.setRequestHandler(
   // list tools
-  (await import("@modelcontextprotocol/sdk/dist/types.js")).ListToolsRequestSchema,
+  (await import("@modelcontextprotocol/sdk/types.js")).ListToolsRequestSchema,
   async () => listToolsResult()
 );
 
 server.setRequestHandler(
   // call tool
-  (await import("@modelcontextprotocol/sdk/dist/types.js")).CallToolRequestSchema,
+  (await import("@modelcontextprotocol/sdk/types.js")).CallToolRequestSchema,
   async (req) => {
     const name = req.params?.name || "";
     const args = req.params?.arguments || {};

package/src/tools/git-workflow.js

@@ -11,7 +11,8 @@ export function createGitWorkflowTool(pm, git) {
       projectPath: { type: "string", description: "Caminho absoluto do projeto" },
       action: { type: "string", enum: ["init", "status", "add", "remove", "commit", "push", "pull", "sync", "ensure-remotes"], description: "Ação" },
       files: { type: "array", items: { type: "string" } },
-      message: { type: "string" }
+      message: { type: "string" },
+      force: { type: "boolean", description: "Force push (para resolver divergências de histórico)" }
     },
     required: ["projectPath", "action"],
     additionalProperties: true
@@ -62,8 +63,9 @@ export function createGitWorkflowTool(pm, git) {
       }
       if (action === "push") {
         const branch = await git.getCurrentBranch(projectPath);
-        await git.pushParallel(projectPath, branch);
-        return asToolResult({ success: true, branch, remotes: ["github", "gitea"] });
+        const force = !!args.force;
+        await git.pushParallel(projectPath, branch, force);
+        return asToolResult({ success: true, branch, remotes: ["github", "gitea"], force });
       }
       if (action === "sync" || action === "pull") {
         // Basic implementation: fetch + status; full merge/pull can be added

package/src/utils/gitAdapter.js

@@ -97,20 +97,321 @@ export class GitAdapter {
     throw new MCPError("AUTH", "GITEA_TOKEN ausente");
   }
 
-  async pushOne(dir, remote, branch) {
+  async pushOne(dir, remote, branch, force = false) {
     const remotes = await git.listRemotes({ fs, dir });
     const info = remotes.find(r => r.remote === remote);
     if (!info) throw new MCPError("REMOTE", `Remote '${remote}' não encontrado`);
     const onAuth = this.getAuth(info.url);
     const ref = branch.startsWith("refs/") ? branch : `refs/heads/${branch}`;
-    await git.push({ fs, http, dir, remote, ref, remoteRef: ref, onAuth });
+    await git.push({ fs, http, dir, remote, ref, remoteRef: ref, onAuth, force });
   }
 
-  async pushParallel(dir, branch) {
+  async pushParallel(dir, branch, force = false) {
     const remotes = await git.listRemotes({ fs, dir });
     const targets = remotes.filter(r => ["github", "gitea"].includes(r.remote));
     if (targets.length === 0) throw new MCPError("REMOTE", "Nenhum remote github/gitea configurado");
-    await Promise.all(targets.map(t => this.pushOne(dir, t.remote, branch)));
+    await Promise.all(targets.map(t => this.pushOne(dir, t.remote, branch, force)));
+  }
+
+  // ============ BRANCHES ============
+  async listBranches(dir, remote = false) {
+    if (remote) {
+      const remotes = await git.listRemotes({ fs, dir });
+      const branches = [];
+      for (const r of remotes) {
+        try {
+          const refs = await git.listServerRefs({ http, url: r.url, prefix: "refs/heads/", onAuth: this.getAuth(r.url) });
+          for (const ref of refs) branches.push(`${r.remote}/${ref.ref.replace("refs/heads/", "")}`);
+        } catch { /* ignore */ }
+      }
+      return branches;
+    }
+    return await git.listBranches({ fs, dir });
+  }
+
+  async createBranch(dir, name, ref = "HEAD") {
+    const oid = await git.resolveRef({ fs, dir, ref });
+    await git.branch({ fs, dir, ref: name, checkout: false });
+  }
+
+  async deleteBranch(dir, name, force = false) {
+    await git.deleteBranch({ fs, dir, ref: name });
+  }
+
+  async renameBranch(dir, oldName, newName) {
+    await git.renameBranch({ fs, dir, oldref: oldName, ref: newName });
+  }
+
+  async checkout(dir, ref) {
+    await git.checkout({ fs, dir, ref, force: true });
+  }
+
+  // ============ TAGS ============
+  async listTags(dir) {
+    return await git.listTags({ fs, dir });
+  }
+
+  async createTag(dir, tag, ref = "HEAD", message = "") {
+    const oid = await git.resolveRef({ fs, dir, ref });
+    if (message) {
+      const author = await this.getAuthor(dir);
+      await git.tag({ fs, dir, ref: tag, object: oid, tagger: { name: author.name, email: author.email }, message });
+    } else {
+      await git.tag({ fs, dir, ref: tag, object: oid });
+    }
+  }
+
+  async deleteTag(dir, tag) {
+    await git.deleteTag({ fs, dir, ref: tag });
+  }
+
+  async pushTag(dir, remote, tag) {
+    const remotes = await git.listRemotes({ fs, dir });
+    const info = remotes.find(r => r.remote === remote);
+    if (!info) throw new MCPError("REMOTE", `Remote '${remote}' não encontrado`);
+    const onAuth = this.getAuth(info.url);
+    await git.push({ fs, http, dir, remote, ref: `refs/tags/${tag}`, remoteRef: `refs/tags/${tag}`, onAuth });
+  }
+
+  // ============ STASH (simulated via JSON file) ============
+  _getStashFile(dir) {
+    return path.join(dir, ".git", "stash.json");
+  }
+
+  async listStash(dir) {
+    const stashFile = this._getStashFile(dir);
+    if (!fs.existsSync(stashFile)) return [];
+    try {
+      return JSON.parse(fs.readFileSync(stashFile, "utf8"));
+    } catch { return []; }
+  }
+
+  async saveStash(dir, message = "WIP", includeUntracked = false) {
+    const st = await this.status(dir);
+    if (st.isClean && !includeUntracked) throw new MCPError("STASH", "Nada para stash");
+    
+    // Salva arquivos modificados/adicionados
+    const filesToSave = [...st.not_added, ...st.modified, ...st.created];
+    const stashData = { message, timestamp: Date.now(), files: {} };
+    
+    for (const file of filesToSave) {
+      const fullPath = path.join(dir, file);
+      if (fs.existsSync(fullPath)) {
+        stashData.files[file] = fs.readFileSync(fullPath, "utf8");
+      }
+    }
+    
+    // Carrega stashes existentes
+    const stashes = await this.listStash(dir);
+    stashes.unshift(stashData);
+    
+    // Salva lista de stashes
+    fs.writeFileSync(this._getStashFile(dir), JSON.stringify(stashes, null, 2));
+    
+    // Restaura arquivos para estado HEAD mantendo a branch atual
+    const currentBranch = await this.getCurrentBranch(dir);
+    if (currentBranch && currentBranch !== "HEAD") {
+      await git.checkout({ fs, dir, ref: currentBranch, force: true });
+    } else {
+      // Se estiver em detached HEAD, usa o SHA atual
+      const oid = await git.resolveRef({ fs, dir, ref: "HEAD" });
+      await git.checkout({ fs, dir, ref: oid, force: true });
+    }
+  }
+
+  async applyStash(dir, ref = "stash@{0}") {
+    const stashes = await this.listStash(dir);
+    const idx = Number(ref.match(/\{(\d+)\}/)?.[1] || 0);
+    const stash = stashes[idx];
+    if (!stash) throw new MCPError("STASH", "Stash não encontrado");
+    
+    // Restaura arquivos do stash
+    for (const [file, content] of Object.entries(stash.files)) {
+      const fullPath = path.join(dir, file);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, content);
+    }
+  }
+
+  async popStash(dir, ref = "stash@{0}") {
+    await this.applyStash(dir, ref);
+    await this.dropStash(dir, ref);
+  }
+
+  async dropStash(dir, ref = "stash@{0}") {
+    const stashes = await this.listStash(dir);
+    const idx = Number(ref.match(/\{(\d+)\}/)?.[1] || 0);
+    stashes.splice(idx, 1);
+    
+    if (stashes.length === 0) {
+      const stashFile = this._getStashFile(dir);
+      if (fs.existsSync(stashFile)) fs.unlinkSync(stashFile);
+    } else {
+      fs.writeFileSync(this._getStashFile(dir), JSON.stringify(stashes, null, 2));
+    }
+  }
+
+  async clearStash(dir) {
+    const stashFile = this._getStashFile(dir);
+    if (fs.existsSync(stashFile)) fs.unlinkSync(stashFile);
+  }
+
+  // ============ CONFIG ============
+  async getConfig(dir, key, scope = "local") {
+    return await git.getConfig({ fs, dir, path: key }).catch(() => undefined);
+  }
+
+  async setConfig(dir, key, value, scope = "local") {
+    await git.setConfig({ fs, dir, path: key, value });
+  }
+
+  async unsetConfig(dir, key, scope = "local") {
+    // isomorphic-git não tem unset, então setamos para undefined
+    const configPath = path.join(dir, ".git", "config");
+    if (!fs.existsSync(configPath)) return;
+    let content = fs.readFileSync(configPath, "utf8");
+    const regex = new RegExp(`^\\s*${key.split(".").pop()}\\s*=.*$`, "gm");
+    content = content.replace(regex, "");
+    fs.writeFileSync(configPath, content);
+  }
+
+  async listConfig(dir, scope = "local") {
+    const configPath = path.join(dir, ".git", "config");
+    const items = {};
+    if (!fs.existsSync(configPath)) return items;
+    const content = fs.readFileSync(configPath, "utf8");
+    let section = "";
+    for (const line of content.split("\n")) {
+      const secMatch = line.match(/^\[([^\]]+)\]$/);
+      if (secMatch) { section = secMatch[1].replace(/\s+"/g, ".").replace(/"/g, ""); continue; }
+      const kvMatch = line.match(/^\s*(\w+)\s*=\s*(.*)$/);
+      if (kvMatch && section) items[`${section}.${kvMatch[1]}`] = kvMatch[2].trim();
+    }
+    return items;
+  }
+
+  // ============ FILES ============
+  async listFiles(dir, ref = "HEAD") {
+    const oid = await git.resolveRef({ fs, dir, ref });
+    const { tree } = await git.readTree({ fs, dir, oid });
+    const files = [];
+    const walk = async (treePath, entries) => {
+      for (const entry of entries) {
+        const fullPath = treePath ? `${treePath}/${entry.path}` : entry.path;
+        if (entry.type === "blob") files.push(fullPath);
+        else if (entry.type === "tree") {
+          const { tree: subTree } = await git.readTree({ fs, dir, oid: entry.oid });
+          await walk(fullPath, subTree);
+        }
+      }
+    };
+    await walk("", tree);
+    return files;
+  }
+
+  async readFile(dir, filepath, ref = "HEAD") {
+    const oid = await git.resolveRef({ fs, dir, ref });
+    const { blob } = await git.readBlob({ fs, dir, oid, filepath });
+    return new TextDecoder().decode(blob);
+  }
+
+  // ============ HISTORY ============
+  async log(dir, { ref = "HEAD", maxCount = 50 } = {}) {
+    const commits = await git.log({ fs, dir, ref, depth: maxCount });
+    return commits.map(c => ({
+      sha: c.oid,
+      message: c.commit.message,
+      author: c.commit.author,
+      date: new Date(c.commit.author.timestamp * 1000).toISOString()
+    }));
+  }
+
+  // ============ SYNC (FETCH/PULL) ============
+  async fetch(dir, remote, branch) {
+    const remotes = await git.listRemotes({ fs, dir });
+    const info = remotes.find(r => r.remote === remote);
+    if (!info) throw new MCPError("REMOTE", `Remote '${remote}' não encontrado`);
+    const onAuth = this.getAuth(info.url);
+    await git.fetch({ fs, http, dir, remote, ref: branch, singleBranch: true, onAuth });
+  }
+
+  async pull(dir, remote, branch) {
+    const remotes = await git.listRemotes({ fs, dir });
+    const info = remotes.find(r => r.remote === remote);
+    if (!info) throw new MCPError("REMOTE", `Remote '${remote}' não encontrado`);
+    const onAuth = this.getAuth(info.url);
+    await git.pull({ fs, http, dir, remote, ref: branch, singleBranch: true, onAuth, author: await this.getAuthor(dir) });
+  }
+
+  // ============ RESET ============
+  async _resolveRef(dir, ref) {
+    // Resolve refs como HEAD~1, HEAD~2, etc.
+    const match = ref.match(/^(HEAD|[a-zA-Z0-9_\-\/]+)~(\d+)$/);
+    if (match) {
+      const baseRef = match[1];
+      const steps = parseInt(match[2], 10);
+      const commits = await git.log({ fs, dir, ref: baseRef, depth: steps + 1 });
+      if (commits.length > steps) return commits[steps].oid;
+      throw new MCPError("REF", `Não foi possível resolver ${ref}`);
+    }
+    // Refs normais
+    return await git.resolveRef({ fs, dir, ref });
+  }
+
+  async resetSoft(dir, ref) {
+    const oid = await this._resolveRef(dir, ref);
+    const headPath = path.join(dir, ".git", "HEAD");
+    const headContent = fs.readFileSync(headPath, "utf8").trim();
+    if (headContent.startsWith("ref:")) {
+      const branchRef = headContent.replace("ref: ", "");
+      const branchPath = path.join(dir, ".git", branchRef);
+      fs.writeFileSync(branchPath, oid + "\n");
+    }
+  }
+
+  async resetMixed(dir, ref) {
+    await this.resetSoft(dir, ref);
+    // Reset index to match ref
+    const oid = await this._resolveRef(dir, ref);
+    await git.checkout({ fs, dir, ref: oid, noUpdateHead: true });
+  }
+
+  async resetHard(dir, ref) {
+    const oid = await this._resolveRef(dir, ref);
+    await git.checkout({ fs, dir, ref: oid, force: true });
+    await this.resetSoft(dir, ref);
+  }
+
+  // ============ GITIGNORE ============
+  async listGitignore(dir) {
+    const ignorePath = path.join(dir, ".gitignore");
+    if (!fs.existsSync(ignorePath)) return [];
+    return fs.readFileSync(ignorePath, "utf8").split("\n").filter(l => l.trim() && !l.startsWith("#"));
+  }
+
+  async createGitignore(dir, patterns = []) {
+    const ignorePath = path.join(dir, ".gitignore");
+    fs.writeFileSync(ignorePath, patterns.join("\n") + "\n");
+  }
+
+  async addToGitignore(dir, patterns = []) {
+    const ignorePath = path.join(dir, ".gitignore");
+    const existing = fs.existsSync(ignorePath) ? fs.readFileSync(ignorePath, "utf8") : "";
+    const newContent = existing.trimEnd() + "\n" + patterns.join("\n") + "\n";
+    fs.writeFileSync(ignorePath, newContent);
+  }
+
+  async removeFromGitignore(dir, patterns = []) {
+    const ignorePath = path.join(dir, ".gitignore");
+    if (!fs.existsSync(ignorePath)) return;
+    let lines = fs.readFileSync(ignorePath, "utf8").split("\n");
+    lines = lines.filter(l => !patterns.includes(l.trim()));
+    fs.writeFileSync(ignorePath, lines.join("\n"));
+  }
+
+  // ============ REMOTES ============
+  async listRemotes(dir) {
+    return await git.listRemotes({ fs, dir });
   }
 }