@andrebuzeli/git-mcp 11.0.5 → 12.0.0

package/src/tools/git-pulls.js

@@ -0,0 +1,61 @@
+import Ajv from "ajv";
+import axios from "axios";
+import { asToolError, asToolResult } from "../utils/errors.js";
+import { getRepoNameFromPath } from "../utils/repoHelpers.js";
+import { runBoth } from "../utils/providerExec.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitPullsTool(pm) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["create", "list", "files"] },
+      title: { type: "string" },
+      head: { type: "string" },
+      base: { type: "string" },
+      number: { type: "number" }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: true
+  };
+
+  async function handle(args) {
+    const validate = ajv.compile(inputSchema);
+    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    const repo = getRepoNameFromPath(args.projectPath);
+    try {
+      if (args.action === "create") {
+        const head = args.head || "feature";
+        const base = args.base || "main";
+        const out = await runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.pulls.create({ owner, repo, title: args.title || `${head} -> ${base}`, head, base }); return { ok: true, number: r.data.number }; },
+          gitea: async (owner) => { const baseUrl = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.post(`${baseUrl}/api/v1/repos/${owner}/${repo}/pulls`, { title: args.title || `${head} -> ${base}`, head, base }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, number: r.data?.number }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
+      }
+      if (args.action === "list") {
+        const out = await runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.pulls.list({ owner, repo, state: "all" }); return { ok: true, count: r.data.length }; },
+          gitea: async (owner) => { const baseUrl = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.get(`${baseUrl}/api/v1/repos/${owner}/${repo}/pulls`, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, count: (r.data||[]).length }; }
+        });
+        return asToolResult({ providers: out });
+      }
+      if (args.action === "files") {
+        const num = args.number;
+        if (!num) return asToolError("VALIDATION_ERROR", "number é obrigatório");
+        const out = await runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.pulls.listFiles({ owner, repo, pull_number: num }); return { ok: true, count: r.data.length }; },
+          gitea: async (owner) => { const baseUrl = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.get(`${baseUrl}/api/v1/repos/${owner}/${repo}/pulls/${num}/files`, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, count: (r.data||[]).length }; }
+        });
+        return asToolResult({ providers: out });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${args.action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return { name: "git-pulls", description: "Pull Requests em paralelo (GitHub + Gitea)", inputSchema, handle };
+}

package/src/tools/git-remote.js

@@ -1,29 +1,182 @@
-import { Gitea } from '../providers/gitea.js'
-import { Github } from '../providers/github.js'
-import { deriveProjectName } from '../utils/project.js'
-import fs from 'fs'
-import git from 'isomorphic-git'
-import { makeSchema } from './schema.js'
-
-export class GitRemoteTool {
-  constructor(env) { this.env = env; this.providers = { gitea: new Gitea(env.GITEA_URL, env.GITEA_TOKEN), github: new Github(env.GITHUB_TOKEN) } }
-  async handle(action, projectPath, args) {
-    const name = deriveProjectName(projectPath)
-    if (action === 'createRepo') { const r = await Promise.allSettled([ this.providers.gitea.createRepo(name, false, true), this.providers.github.createRepo(name, false, true) ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'deleteRepo') { const r = await Promise.allSettled([ this.providers.gitea.deleteRepo(name), this.providers.github.deleteRepo(name) ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'ensureRemotes') { const urls = await Promise.all([ this.providers.gitea.repoHttpsUrl(name), this.providers.github.repoHttpsUrl(name) ]); try { await git.addRemote({ fs, dir: projectPath, remote: 'origin-gitea', url: urls[0] }) } catch {} ; try { await git.addRemote({ fs, dir: projectPath, remote: 'origin-github', url: urls[1] }) } catch {} ; return { gitea: urls[0], github: urls[1] } }
-    return { error: 'ação inválida' }
-  }
-}
-
-export function getSchema() {
-  return makeSchema({
-    name: 'git-remote',
-    description: 'Operações remotas simultâneas Gitea/GitHub (repos/remotes)',
-    actions: {
-      createRepo: { description: 'Criar repositório nos provedores' },
-      deleteRepo: { description: 'Excluir repositório nos provedores' },
-      ensureRemotes: { description: 'Garantir remotes origin-gitea/github' }
-    }
-  })
-}
+import Ajv from "ajv";
+import axios from "axios";
+import { asToolError, asToolResult } from "../utils/errors.js";
+import { getRepoNameFromPath } from "../utils/repoHelpers.js";
+import { runBoth } from "../utils/providerExec.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitRemoteTool(pm, git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: [
+        "list",
+        "ensure",
+        "set-url",
+        "repo-delete",
+        "release-create",
+        "topics-set",
+        "milestone-create",
+        "label-create",
+        "fork-create",
+        "fork-list",
+        "star-set",
+        "star-unset",
+        "star-check",
+        "subscription-set",
+        "subscription-unset",
+        "contents-create"
+      ] },
+      tag: { type: "string" },
+      name: { type: "string" },
+      body: { type: "string" },
+      topics: { type: "array", items: { type: "string" } },
+      path: { type: "string" },
+      content: { type: "string" },
+      branch: { type: "string" }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: true
+  };
+
+  async function handle(args) {
+    const validate = ajv.compile(inputSchema);
+    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    const { projectPath, action } = args;
+    try {
+      if (action === "list") {
+        const remotes = await git.listRemotes(projectPath);
+        return asToolResult({ remotes });
+      }
+      if (action === "ensure") {
+        const repo = getRepoNameFromPath(projectPath);
+        const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true });
+        const ghOwner = await pm.getGitHubOwner();
+        const geOwner = await pm.getGiteaOwner();
+        const githubUrl = ghOwner ? `https://github.com/${ghOwner}/${repo}.git` : "";
+        const base = pm.giteaUrl?.replace(/\/$/, "") || "";
+        const giteaUrl = geOwner && base ? `${base}/${geOwner}/${repo}.git` : "";
+        await git.ensureRemotes(projectPath, { githubUrl, giteaUrl });
+        const remotes = await git.listRemotes(projectPath);
+        return asToolResult({ success: true, ensured, remotes });
+      }
+      if (action === "set-url") {
+        // handled via ensure (auto)
+        return asToolResult({ success: true, message: "Use action=ensure para set-url automático" });
+      }
+      if (action === "repo-delete") {
+        const repo = getRepoNameFromPath(projectPath);
+        const out = await runBoth(pm, {
+          github: async (owner) => { await pm.github.rest.repos.delete({ owner, repo }); return { ok: true }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); await axios.delete(`${base}/api/v1/repos/${owner}/${repo}`, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
+      }
+      if (action === "release-create") {
+        const repo = getRepoNameFromPath(projectPath);
+        const tag = args.tag || "v1.0.0";
+        const name = args.name || tag;
+        const body = args.body || "";
+        const out = await runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.repos.createRelease({ owner, repo, tag_name: tag, name, body, draft: false, prerelease: false }); return { ok: true, id: r.data.id }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.post(`${base}/api/v1/repos/${owner}/${repo}/releases`, { tag_name: tag, name, body }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, id: r.data?.id }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
+      }
+      if (action === "topics-set") {
+        const repo = getRepoNameFromPath(projectPath);
+        const topics = Array.isArray(args.topics) ? args.topics : [];
+        const out = await runBoth(pm, {
+          github: async (owner) => { await pm.github.request("PUT /repos/{owner}/{repo}/topics", { owner, repo, names: topics, headers: { accept: "application/vnd.github.mercy-preview+json" } }); return { ok: true }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); await axios.put(`${base}/api/v1/repos/${owner}/${repo}/topics`, { topics }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
+      }
+      if (action === "milestone-create") {
+        const repo = getRepoNameFromPath(projectPath);
+        const title = args.title || "v1.0";
+        const out = await runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.request("POST /repos/{owner}/{repo}/milestones", { owner, repo, title }); return { ok: true, id: r.data?.id }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.post(`${base}/api/v1/repos/${owner}/${repo}/milestones`, { title }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, id: r.data?.id }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
+      }
+      if (action === "label-create") {
+        const repo = getRepoNameFromPath(projectPath);
+        const name = args.name || "bug";
+        const color = String(args.color || "ff0000").replace(/^#/, "");
+        const out = await runBoth(pm, {
+          github: async (owner) => { await pm.github.request("POST /repos/{owner}/{repo}/labels", { owner, repo, name, color }); return { ok: true }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); await axios.post(`${base}/api/v1/repos/${owner}/${repo}/labels`, { name, color }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
+      }
+      if (action === "fork-create") {
+        const repo = getRepoNameFromPath(projectPath);
+        const out = await runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.repos.createFork({ owner, repo }); return { ok: true, full_name: r.data?.full_name }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.post(`${base}/api/v1/repos/${owner}/${repo}/forks`, {}, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, full_name: r.data?.full_name }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
+      }
+      if (action === "fork-list") {
+        const repo = getRepoNameFromPath(projectPath);
+        const out = await runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.repos.listForks({ owner, repo }); return { ok: true, count: r.data.length }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.get(`${base}/api/v1/repos/${owner}/${repo}/forks`, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, count: (r.data || []).length }; }
+        });
+        return asToolResult({ providers: out });
+      }
+      if (action === "star-set" || action === "star-unset" || action === "star-check") {
+        const repo = getRepoNameFromPath(projectPath);
+        const out = await runBoth(pm, {
+          github: async (owner) => {
+            if (action === "star-set") { await pm.github.request("PUT /user/starred/{owner}/{repo}", { owner, repo }); return { ok: true }; }
+            if (action === "star-unset") { await pm.github.request("DELETE /user/starred/{owner}/{repo}", { owner, repo }); return { ok: true }; }
+            const r = await pm.github.request("GET /user/starred/{owner}/{repo}", { owner, repo }); return { ok: r.status === 204 || r.status === 200 };
+          },
+          gitea: async (owner) => {
+            const base = pm.giteaUrl.replace(/\/$/, "");
+            if (action === "star-set") { await axios.put(`${base}/api/v1/user/starred/${owner}/${repo}`, {}, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true }; }
+            if (action === "star-unset") { await axios.delete(`${base}/api/v1/user/starred/${owner}/${repo}`, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true }; }
+            const r = await axios.get(`${base}/api/v1/user/starred/${owner}/${repo}`, { headers: { Authorization: `token ${pm.giteaToken}` }, validateStatus: () => true }); return { ok: r.status === 204 || r.status === 200 };
+          }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
+      }
+      if (action === "subscription-set" || action === "subscription-unset") {
+        const repo = getRepoNameFromPath(projectPath);
+        const out = await runBoth(pm, {
+          github: async (owner) => { if (action === "subscription-set") { await pm.github.request("PUT /repos/{owner}/{repo}/subscription", { owner, repo, subscribed: true }); } else { await pm.github.request("DELETE /repos/{owner}/{repo}/subscription", { owner, repo }); } return { ok: true }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); if (action === "subscription-set") { await axios.put(`${base}/api/v1/repos/${owner}/${repo}/subscription`, { subscribed: true }, { headers: { Authorization: `token ${pm.giteaToken}` } }); } else { await axios.delete(`${base}/api/v1/repos/${owner}/${repo}/subscription`, { headers: { Authorization: `token ${pm.giteaToken}` } }); } return { ok: true }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
+      }
+      if (action === "contents-create") {
+        const repo = getRepoNameFromPath(projectPath);
+        const filePath = args.path || "test.txt";
+        const message = args.message || "Add file";
+        const data = typeof args.content === "string" ? args.content : "";
+        const branch = args.branch || "main";
+        const b64 = Buffer.from(data, "utf8").toString("base64");
+        const out = await runBoth(pm, {
+          github: async (owner) => { await pm.github.request("PUT /repos/{owner}/{repo}/contents/{path}", { owner, repo, path: filePath, message, content: b64, branch }); return { ok: true }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); await axios.post(`${base}/api/v1/repos/${owner}/${repo}/contents/${encodeURIComponent(filePath)}`, { content: b64, message, branch }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), path: filePath, providers: out });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return {
+    name: "git-remote",
+    description: "Gerencia remotes e garante GitHub + Gitea",
+    inputSchema,
+    handle
+  };
+}

package/src/tools/git-reset.js

@@ -0,0 +1,35 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult } from "../utils/errors.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitResetTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["soft", "mixed", "hard"] },
+      ref: { type: "string" }
+    },
+    required: ["projectPath", "action", "ref"],
+    additionalProperties: true
+  };
+
+  async function handle(args) {
+    const validate = ajv.compile(inputSchema);
+    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    const { projectPath, action, ref } = args;
+    try {
+      if (action === "soft") await git.resetSoft(projectPath, ref);
+      else if (action === "mixed") await git.resetMixed(projectPath, ref);
+      else if (action === "hard") await git.resetHard(projectPath, ref);
+      else return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolResult({ success: true, action, ref });
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return { name: "git-reset", description: "Reset soft/mixed/hard", inputSchema, handle };
+}
+

package/src/tools/git-stash.js

@@ -0,0 +1,57 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult } from "../utils/errors.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitStashTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["list", "save", "apply", "pop", "drop", "clear"] },
+      message: { type: "string" },
+      ref: { type: "string" },
+      includeUntracked: { type: "boolean" }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: true
+  };
+
+  async function handle(args) {
+    const validate = ajv.compile(inputSchema);
+    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    const { projectPath, action } = args;
+    try {
+      if (action === "list") {
+        const items = await git.listStash(projectPath);
+        return asToolResult({ items });
+      }
+      if (action === "save") {
+        await git.saveStash(projectPath, args.message || "WIP", !!args.includeUntracked);
+        return asToolResult({ success: true });
+      }
+      if (action === "apply") {
+        await git.applyStash(projectPath, args.ref);
+        return asToolResult({ success: true });
+      }
+      if (action === "pop") {
+        await git.popStash(projectPath, args.ref);
+        return asToolResult({ success: true });
+      }
+      if (action === "drop") {
+        await git.dropStash(projectPath, args.ref);
+        return asToolResult({ success: true });
+      }
+      if (action === "clear") {
+        await git.clearStash(projectPath);
+        return asToolResult({ success: true });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return { name: "git-stash", description: "Gerencia stash", inputSchema, handle };
+}
+

package/src/tools/git-sync.js

@@ -1,40 +1,44 @@
-import { deriveProjectName } from '../utils/project.js'
-import { GitLocalTool } from './git-local.js'
-import { GitRemoteTool } from './git-remote.js'
-import { listFilesRecursive, toProjectRelative, readBase64 } from '../utils/fs.js'
-import { Gitea } from '../providers/gitea.js'
-import { Github } from '../providers/github.js'
-import { makeSchema } from './schema.js'
-
-export class GitSyncTool {
-  constructor(env) { this.env = env; this.local = new GitLocalTool(); this.remote = new GitRemoteTool(env) }
-  async handle(action, projectPath, args) {
-    if (action === 'mirror') {
-      await this.remote.handle('createRepo', projectPath, args)
-      const rem = await this.remote.handle('ensureRemotes', projectPath, args)
-      try { await this.local.handle('push', projectPath, { remote: 'origin-gitea', branch: args?.branch || 'master' }, this.env) } catch {}
-      try { await this.local.handle('push', projectPath, { remote: 'origin-github', branch: args?.branch || 'master' }, this.env) } catch {}
-      // Fallback por API: subir todos arquivos via contents
-      const files = listFilesRecursive(projectPath)
-      const gitea = new Gitea(this.env.GITEA_URL, this.env.GITEA_TOKEN)
-      const github = new Github(this.env.GITHUB_TOKEN)
-      const name = deriveProjectName(projectPath)
-      for (const f of files) {
-        const rel = toProjectRelative(projectPath, f)
-        const content = readBase64(f)
-        try { await gitea.putContent(name, rel, content, 'mcp sync', args?.branch || 'master') } catch {}
-        try { await github.putContent(name, rel, content, 'mcp sync', args?.branch || 'master') } catch {}
-      }
-      return { ok: true }
-    }
-    return { error: 'ação inválida' }
-  }
-}
-
-export function getSchema() {
-  return makeSchema({
-    name: 'git-sync',
-    description: 'Espelhamento e sincronização completa entre provedores',
-    actions: { mirror: { description: 'Push e fallback via Contents API' } }
-  })
-}
+import Ajv from "ajv";
+import { asToolError, asToolResult } from "../utils/errors.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitSyncTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["pull", "fetch"] },
+      remote: { type: "string" },
+      branch: { type: "string" }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: true
+  };
+
+  async function handle(args) {
+    const validate = ajv.compile(inputSchema);
+    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    const { projectPath, action } = args;
+    try {
+      const branch = args.branch || await git.getCurrentBranch(projectPath);
+      if (action === "fetch") {
+        const remotes = args.remote ? [args.remote] : ["origin", "github", "gitea"];
+        const promises = remotes.map(r => git.fetch(projectPath, r, branch).then(() => ({ remote: r, ok: true })).catch(e => ({ remote: r, ok: false, error: String(e?.message || e) })));
+        const results = await Promise.all(promises);
+        return asToolResult({ success: results.some(x => x.ok), branch, results });
+      }
+      if (action === "pull") {
+        const remotes = args.remote ? [args.remote] : ["origin", "github", "gitea"];
+        const promises = remotes.map(r => git.pull(projectPath, r, branch).then(() => ({ remote: r, ok: true })).catch(e => ({ remote: r, ok: false, error: String(e?.message || e) })));
+        const results = await Promise.all(promises);
+        return asToolResult({ success: results.some(x => x.ok), branch, results });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return { name: "git-sync", description: "fetch/pull (opcionalmente múltiplos remotes)", inputSchema, handle };
+}

package/src/tools/git-tags.js

@@ -0,0 +1,58 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult } from "../utils/errors.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitTagsTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["list", "create", "delete", "push"] },
+      tag: { type: "string" },
+      ref: { type: "string" },
+      message: { type: "string" }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: true
+  };
+
+  async function handle(args) {
+    const validate = ajv.compile(inputSchema);
+    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    const { projectPath, action } = args;
+    try {
+      if (action === "list") {
+        const tags = await git.listTags(projectPath);
+        return asToolResult({ tags });
+      }
+      if (action === "create") {
+        const tag = args.tag;
+        if (!tag) return asToolError("VALIDATION_ERROR", "tag é obrigatório");
+        await git.createTag(projectPath, tag, args.ref || "HEAD", args.message);
+        return asToolResult({ success: true, tag });
+      }
+      if (action === "delete") {
+        const tag = args.tag;
+        if (!tag) return asToolError("VALIDATION_ERROR", "tag é obrigatório");
+        await git.deleteTag(projectPath, tag);
+        return asToolResult({ success: true, tag });
+      }
+      if (action === "push") {
+        const tag = args.tag;
+        if (!tag) return asToolError("VALIDATION_ERROR", "tag é obrigatório");
+        await Promise.all([
+          git.pushTag(projectPath, "github", tag).catch(() => {}),
+          git.pushTag(projectPath, "gitea", tag).catch(() => {})
+        ]);
+        return asToolResult({ success: true, tag, remotes: ["github", "gitea"] });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return { name: "git-tags", description: "Gerencia tags e push paralelo", inputSchema, handle };
+}
+

package/src/tools/git-workflow.js

@@ -0,0 +1,85 @@
+import Ajv from "ajv";
+import { MCPError, asToolError, asToolResult } from "../utils/errors.js";
+import { getRepoNameFromPath } from "../utils/repoHelpers.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitWorkflowTool(pm, git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      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" }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: true
+  };
+
+  async function handle(args) {
+    const validate = ajv.compile(inputSchema);
+    if (!validate(args || {})) {
+      return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    }
+    const { projectPath, action } = args;
+    try {
+      if (action === "init") {
+        await git.init(projectPath);
+        const repo = getRepoNameFromPath(projectPath);
+        const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true });
+        return asToolResult({ success: true, ensured, message: "Repositório inicializado" });
+      }
+      if (action === "status") {
+        const st = await git.status(projectPath);
+        return asToolResult(st);
+      }
+      if (action === "add") {
+        const files = Array.isArray(args.files) && args.files.length ? args.files : ["."];
+        await git.add(projectPath, files);
+        return asToolResult({ success: true, files });
+      }
+      if (action === "remove") {
+        const files = Array.isArray(args.files) ? args.files : [];
+        await git.remove(projectPath, files);
+        return asToolResult({ success: true, files });
+      }
+      if (action === "commit") {
+        const msg = args.message || "update";
+        const sha = await git.commit(projectPath, msg);
+        return asToolResult({ success: true, sha, message: msg });
+      }
+      if (action === "ensure-remotes") {
+        const repo = getRepoNameFromPath(projectPath);
+        const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true });
+        const ghOwner = await pm.getGitHubOwner();
+        const geOwner = await pm.getGiteaOwner();
+        const githubUrl = ghOwner ? `https://github.com/${ghOwner}/${repo}.git` : "";
+        const base = pm.giteaUrl?.replace(/\/$/, "") || "";
+        const giteaUrl = geOwner && base ? `${base}/${geOwner}/${repo}.git` : "";
+        await git.ensureRemotes(projectPath, { githubUrl, giteaUrl });
+        return asToolResult({ success: true, ensured, remotes: { githubUrl, giteaUrl } });
+      }
+      if (action === "push") {
+        const branch = await git.getCurrentBranch(projectPath);
+        await git.pushParallel(projectPath, branch);
+        return asToolResult({ success: true, branch, remotes: ["github", "gitea"] });
+      }
+      if (action === "sync" || action === "pull") {
+        // Basic implementation: fetch + status; full merge/pull can be added
+        return asToolResult({ success: true, message: "Operação de pull/sync não-op realizada" });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return {
+    name: "git-workflow",
+    description: "Operações Git locais e remotas em paralelo (GitHub + Gitea)",
+    inputSchema,
+    handle
+  };
+}
+

package/src/utils/errors.js

@@ -0,0 +1,22 @@
+export class MCPError extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+}
+
+export function asToolResult(result) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    isError: false,
+  };
+}
+
+export function asToolError(code, message, data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ code, message, data }) }],
+    isError: true,
+  };
+}
+