@andrebuzeli/git-mcp 11.0.4 → 12.0.0

package/README.md

@@ -1,47 +1,39 @@
-# @andrebuzeli/git-mcp
-
-- Pacote MCP para manipulação Git com Gitea e GitHub em paralelo
-- Configuração via NPX gerando `mcp.json` com `GITEA_URL`, `GITEA_TOKEN`, `GITHUB_TOKEN`
-- Independente de Git instalado: usa `isomorphic-git` puro em Node
-
-## Instalação
-
-- `npm i -g @andrebuzeli/git-mcp@11.0.0` ou use via npx
-
-## Configuração
-
-- `npx @andrebuzeli/git-mcp@11.0.0 init --path .`
-- Edite `mcp.json` preenchendo os valores de ambiente
-- Garanta que o processo/IDE exporte as variáveis de ambiente
-
-## Uso rápido
-
-- Criar repositórios remotos em ambos provedores
-  - `npx @andrebuzeli/git-mcp@11.0.0 call --tool git-remote --action createRepo --projectPath "C:\\Projetos\\Meu Projeto"`
-- Inicializar e enviar para ambos remotos
-  - `npx @andrebuzeli/git-mcp@11.0.0 call --tool git-local --action init --projectPath "..."`
-  - `npx @andrebuzeli/git-mcp@11.0.0 call --tool git-remote --action ensureRemotes --projectPath "..."`
-  - `npx @andrebuzeli/git-mcp@11.0.0 call --tool git-local --action add --projectPath "..." --args '{"patterns":["."]}'`
-  - `npx @andrebuzeli/git-mcp@11.0.0 call --tool git-local --action commit --projectPath "..." --args '{"message":"Initial commit"}'`
-  - `npx @andrebuzeli/git-mcp@11.0.0 call --tool git-local --action push --projectPath "..." --args '{"remote":"origin-gitea","branch":"main"}'`
-  - `npx @andrebuzeli/git-mcp@11.0.0 call --tool git-local --action push --projectPath "..." --args '{"remote":"origin-github","branch":"main"}'`
-
-## Integração em IDEs
-
-- VSCode/Cursor/Trae: apontar o executor MCP para `npx @andrebuzeli/git-mcp@11.0.0 start` e usar `mcp.json` para descoberta das tools
-- Todas as tools exigem `projectPath` e derivam o nome do projeto do último segmento, substituindo espaços por underscore
- - Consulte `docs/TOOLS.md` para descrições, schema e exemplos de uso por tool/action
-
-## Tools
-
-- `git-local`: status, init, add, commit, push, pull, branch, tag
-  - Implementado com `isomorphic-git` (sem binário git)
-- `git-remote`: createRepo, deleteRepo, ensureRemotes
-- `git-sync`: mirror (push simultâneo para Gitea e GitHub)
-- `git-issues`: create
-- `git-releases`: create
-
-## Notas
-
-- Tokens nunca são persistidos, somente lidos de variáveis de ambiente
-- Operações remotas usam chamadas paralelas com relatório agregado
+# @andrebuzeli/git-mcp
+
+Servidor MCP (Model Context Protocol) para operações Git locais sem git instalado, com sincronização paralela para GitHub e Gitea.
+
+## Configuração MCP
+
+```json
+{
+  "mcpServers": {
+    "git-mcp": {
+      "command": "npx",
+      "args": ["@andrebuzeli/git-mcp@latest"],
+      "env": {
+        "GITEA_URL": "https://seu-gitea",
+        "GITEA_TOKEN": "...",
+        "GITHUB_TOKEN": "..."
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+- git-workflow: init, status, add, remove, commit, ensure-remotes, push
+- git-remote: list, ensure
+- git-branches: list, create, delete, rename, checkout
+- git-tags: list, create, delete, push
+- git-stash: list, save, apply, pop, drop, clear
+- git-reset: soft, mixed, hard
+- git-config: get, set, unset, list
+- git-ignore: list, create, add, remove
+- git-files: list, read
+- git-history: log
+- git-sync: fetch, pull
+- git-issues: create, list, comment
+- git-pulls: create, list, files
+
+Todas as tools exigem `projectPath` e operam com derivação automática do nome do repositório a partir do caminho.

package/package.json

@@ -1,19 +1,24 @@
-{
-  "name": "@andrebuzeli/git-mcp",
-  "version": "11.0.4",
-  "type": "module",
-  "bin": {
-    "git-mcp": "bin/git-mcp.js"
-  },
-  "scripts": {
-    "start": "node bin/git-mcp.js start",
-    "init": "node bin/git-mcp.js init",
-    "test": "node tests/run.js"
-  },
-  "dependencies": {
-    "axios": "^1.7.7",
-    "kleur": "^4.1.5",
-    "isomorphic-git": "^1.25.4",
-    "yargs": "^17.7.2"
-  }
-}
+{
+  "name": "@andrebuzeli/git-mcp",
+  "version": "12.0.0",
+  "private": false,
+  "description": "MCP server para Git com operações locais e sincronização paralela GitHub/Gitea",
+  "license": "MIT",
+  "author": "andrebuzeli",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "git-mcpv2": "src/index.js"
+  },
+  "scripts": {
+    "build": "echo 'no build'",
+    "start": "node src/index.js"
+  },
+  "dependencies": {
+    "ajv": "^8.12.0",
+    "axios": "^1.7.7",
+    "@octokit/rest": "^20.0.0",
+    "isomorphic-git": "^1.27.5",
+    "@modelcontextprotocol/sdk": "^0.4.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/dist/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/dist/server/stdio.js";
+import Ajv from "ajv";
+import { asToolError } from "./utils/errors.js";
+import { ProviderManager } from "./providers/providerManager.js";
+import { GitAdapter } from "./utils/gitAdapter.js";
+import { createGitWorkflowTool } from "./tools/git-workflow.js";
+import { createGitRemoteTool } from "./tools/git-remote.js";
+import { createGitBranchesTool } from "./tools/git-branches.js";
+import { createGitTagsTool } from "./tools/git-tags.js";
+import { createGitStashTool } from "./tools/git-stash.js";
+import { createGitResetTool } from "./tools/git-reset.js";
+import { createGitConfigTool } from "./tools/git-config.js";
+import { createGitIgnoreTool } from "./tools/git-ignore.js";
+import { createGitFilesTool } from "./tools/git-files.js";
+import { createGitHistoryTool } from "./tools/git-history.js";
+import { createGitSyncTool } from "./tools/git-sync.js";
+import { createGitIssuesTool } from "./tools/git-issues.js";
+import { createGitPullsTool } from "./tools/git-pulls.js";
+
+const transport = new StdioServerTransport();
+const server = new Server({ name: "git-mcpv2", version: "0.0.0" });
+server.connect(transport);
+
+const pm = new ProviderManager();
+const git = new GitAdapter(pm);
+const ajv = new Ajv({ allErrors: true });
+
+const tools = [
+  createGitWorkflowTool(pm, git),
+  createGitRemoteTool(pm, git),
+  createGitBranchesTool(git),
+  createGitTagsTool(git),
+  createGitStashTool(git),
+  createGitResetTool(git),
+  createGitConfigTool(git),
+  createGitIgnoreTool(git),
+  createGitFilesTool(git),
+  createGitHistoryTool(git),
+  createGitSyncTool(git),
+  createGitIssuesTool(pm),
+  createGitPullsTool(pm),
+];
+
+function listToolsResult() {
+  return {
+    nextCursor: undefined,
+    tools: tools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
+  };
+}
+
+server.setRequestHandler(
+  // list tools
+  (await import("@modelcontextprotocol/sdk/dist/types.js")).ListToolsRequestSchema,
+  async () => listToolsResult()
+);
+
+server.setRequestHandler(
+  // call tool
+  (await import("@modelcontextprotocol/sdk/dist/types.js")).CallToolRequestSchema,
+  async (req) => {
+    const name = req.params?.name || "";
+    const args = req.params?.arguments || {};
+    const progressToken = req.params?._meta?.progressToken;
+    const tool = tools.find(t => t.name === name);
+    if (!tool) return { content: [{ type: "text", text: `Tool não encontrada: ${name}` }], isError: true };
+    try {
+      if (progressToken) {
+        await server.notification({ method: "notifications/progress", params: { progressToken, progress: 0 } });
+      }
+      const result = await tool.handle(args);
+      if (progressToken) {
+        await server.notification({ method: "notifications/progress", params: { progressToken, progress: 100 } });
+      }
+      return result;
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+);
+
+// Keep process alive
+process.stdin.resume();

package/src/providers/providerManager.js

@@ -0,0 +1,107 @@
+import { Octokit } from "@octokit/rest";
+import axios from "axios";
+import { getProvidersEnv } from "../utils/repoHelpers.js";
+
+export class ProviderManager {
+  constructor() {
+    const { githubToken, giteaUrl, giteaToken } = getProvidersEnv();
+    this.githubToken = githubToken || "";
+    this.giteaUrl = giteaUrl || "";
+    this.giteaToken = giteaToken || "";
+    this.github = this.githubToken ? new Octokit({ auth: this.githubToken }) : null;
+    this._githubOwner = "";
+    this._giteaOwner = "";
+    this._ownerFetchedAt = 0;
+  }
+
+  async getGitHubOwner() {
+    if (!this.github) return "";
+    const now = Date.now();
+    if (this._githubOwner && now - this._ownerFetchedAt < 5 * 60 * 1000) return this._githubOwner;
+    try {
+      const me = await this.github.rest.users.getAuthenticated();
+      this._githubOwner = me.data.login || "";
+      this._ownerFetchedAt = now;
+      return this._githubOwner;
+    } catch {
+      return "";
+    }
+  }
+
+  async getGiteaOwner() {
+    if (!this.giteaUrl || !this.giteaToken) return "";
+    const now = Date.now();
+    if (this._giteaOwner && now - this._ownerFetchedAt < 5 * 60 * 1000) return this._giteaOwner;
+    try {
+      const r = await axios.get(`${this.giteaUrl}/api/v1/user`, {
+        headers: { Authorization: `token ${this.giteaToken}` },
+        timeout: 8000,
+      });
+      const d = r.data || {};
+      this._giteaOwner = d.login || d.username || "";
+      this._ownerFetchedAt = now;
+      return this._giteaOwner;
+    } catch {
+      return "";
+    }
+  }
+
+  async ensureRepos({ repoName, createIfMissing = true, description = "Managed by git-mcpv2" }) {
+    const results = { github: null, gitea: null };
+    // GitHub
+    if (this.github) {
+      const owner = await this.getGitHubOwner();
+      if (owner) {
+        try {
+          const full = `${owner}/${repoName}`;
+          try {
+            await this.github.rest.repos.get({ owner, repo: repoName });
+            results.github = { ok: true, repo: full, created: false };
+          } catch {
+            if (createIfMissing) {
+              const cr = await this.github.rest.repos.createForAuthenticatedUser({
+                name: repoName,
+                description,
+                private: false,
+                auto_init: true,
+              });
+              results.github = { ok: true, repo: cr.data.full_name, created: true };
+            } else {
+              results.github = { ok: false, error: "missing" };
+            }
+          }
+        } catch (e) {
+          results.github = { ok: false, error: String(e?.message || e) };
+        }
+      }
+    }
+    // Gitea
+    if (this.giteaUrl && this.giteaToken) {
+      const owner = await this.getGiteaOwner();
+      if (owner) {
+        try {
+          const base = this.giteaUrl.replace(/\/$/, "");
+          const getRepo = await axios.get(`${base}/api/v1/repos/${owner}/${repoName}`,
+            { headers: { Authorization: `token ${this.giteaToken}` }, timeout: 8000 });
+          if (getRepo.status === 200) {
+            results.gitea = { ok: true, repo: `${owner}/${repoName}`, created: false };
+          }
+        } catch (e) {
+          if (createIfMissing) {
+            try {
+              const cr = await axios.post(`${this.giteaUrl}/api/v1/user/repos`,
+                { name: repoName, description, private: false, auto_init: true },
+                { headers: { Authorization: `token ${this.giteaToken}` }, timeout: 8000 });
+              results.gitea = { ok: true, repo: `${cr.data?.owner?.login || owner}/${repoName}`, created: true };
+            } catch (err) {
+              results.gitea = { ok: false, error: String(err?.message || err) };
+            }
+          } else {
+            results.gitea = { ok: false, error: "missing" };
+          }
+        }
+      }
+    }
+    return results;
+  }
+}

package/src/tools/git-branches.js

@@ -0,0 +1,63 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult } from "../utils/errors.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitBranchesTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["list", "create", "delete", "rename", "checkout"] },
+      branch: { type: "string" },
+      newBranch: { type: "string" },
+      force: { 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 local = await git.listBranches(projectPath, false);
+        const remote = await git.listBranches(projectPath, true).catch(() => []);
+        return asToolResult({ local, remote });
+      }
+      if (action === "create") {
+        const ref = args.branch;
+        if (!ref) return asToolError("VALIDATION_ERROR", "branch é obrigatório");
+        await git.createBranch(projectPath, ref);
+        return asToolResult({ success: true, branch: ref });
+      }
+      if (action === "delete") {
+        const ref = args.branch;
+        if (!ref) return asToolError("VALIDATION_ERROR", "branch é obrigatório");
+        await git.deleteBranch(projectPath, ref, !!args.force);
+        return asToolResult({ success: true, branch: ref });
+      }
+      if (action === "rename") {
+        const oldName = args.branch;
+        const newName = args.newBranch;
+        if (!oldName || !newName) return asToolError("VALIDATION_ERROR", "branch e newBranch são obrigatórios");
+        await git.renameBranch(projectPath, oldName, newName);
+        return asToolResult({ success: true, from: oldName, to: newName });
+      }
+      if (action === "checkout") {
+        const ref = args.branch;
+        if (!ref) return asToolError("VALIDATION_ERROR", "branch é obrigatório");
+        await git.checkout(projectPath, ref);
+        return asToolResult({ success: true, branch: ref });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return { name: "git-branches", description: "Gerencia branches", inputSchema, handle };
+}
+

package/src/tools/git-config.js

@@ -0,0 +1,53 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult } from "../utils/errors.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitConfigTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["get", "set", "unset", "list"] },
+      key: { type: "string" },
+      value: { type: "string" },
+      scope: { type: "string", enum: ["local", "global", "system"], default: "local" }
+    },
+    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;
+    const scope = args.scope || "local";
+    try {
+      if (action === "get") {
+        if (!args.key) return asToolError("VALIDATION_ERROR", "key é obrigatório");
+        const val = await git.getConfig(projectPath, args.key, scope);
+        return asToolResult({ key: args.key, value: val });
+      }
+      if (action === "set") {
+        if (!args.key) return asToolError("VALIDATION_ERROR", "key é obrigatório");
+        await git.setConfig(projectPath, args.key, args.value ?? "", scope);
+        return asToolResult({ success: true, key: args.key, value: args.value ?? "" });
+      }
+      if (action === "unset") {
+        if (!args.key) return asToolError("VALIDATION_ERROR", "key é obrigatório");
+        await git.unsetConfig(projectPath, args.key, scope);
+        return asToolResult({ success: true, key: args.key });
+      }
+      if (action === "list") {
+        const items = await git.listConfig(projectPath, scope);
+        return asToolResult({ scope, items });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return { name: "git-config", description: "Gerencia configurações Git (local/global/system)", inputSchema, handle };
+}
+

package/src/tools/git-files.js

@@ -0,0 +1,41 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult } from "../utils/errors.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitFilesTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["list", "read"] },
+      filepath: { type: "string" },
+      ref: { 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 files = await git.listFiles(projectPath, args.ref || "HEAD");
+        return asToolResult({ files });
+      }
+      if (action === "read") {
+        if (!args.filepath) return asToolError("VALIDATION_ERROR", "filepath é obrigatório");
+        const text = await git.readFile(projectPath, args.filepath, args.ref || "HEAD");
+        return { content: [{ type: "text", text }], isError: false };
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return { name: "git-files", description: "Lista e lê arquivos do repo", inputSchema, handle };
+}
+

package/src/tools/git-history.js

@@ -0,0 +1,36 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult } from "../utils/errors.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitHistoryTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["log"] },
+      ref: { type: "string" },
+      maxCount: { 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 { projectPath, action } = args;
+    try {
+      if (action === "log") {
+        const items = await git.log(projectPath, { ref: args.ref || "HEAD", maxCount: args.maxCount || 50 });
+        return asToolResult({ commits: items });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+
+  return { name: "git-history", description: "Histórico de commits", inputSchema, handle };
+}
+

package/src/tools/git-ignore.js

@@ -0,0 +1,48 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult } from "../utils/errors.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitIgnoreTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["list", "create", "add", "remove"] },
+      patterns: { type: "array", items: { 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;
+    const patterns = Array.isArray(args.patterns) ? args.patterns : [];
+    try {
+      if (action === "list") {
+        const items = await git.listGitignore(projectPath);
+        return asToolResult({ items });
+      }
+      if (action === "create") {
+        await git.createGitignore(projectPath, patterns);
+        return asToolResult({ success: true });
+      }
+      if (action === "add") {
+        await git.addToGitignore(projectPath, patterns);
+        return asToolResult({ success: true });
+      }
+      if (action === "remove") {
+        await git.removeFromGitignore(projectPath, patterns);
+        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-ignore", description: "Gerencia .gitignore", inputSchema, handle };
+}
+

package/src/tools/git-issues.js

@@ -1,12 +1,58 @@
-import { Gitea } from '../providers/gitea.js'
-import { Github } from '../providers/github.js'
-import { deriveProjectName } from '../utils/project.js'
-
-export class GitIssuesTool {
-  constructor(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 === 'create') { const r = await Promise.allSettled([ this.providers.gitea.createIssue(name, args?.title || 'Issue', args?.body || ''), this.providers.github.createIssue(name, args?.title || 'Issue', args?.body || '' ) ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    return { error: 'ação inválida' }
-  }
-}
+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 createGitIssuesTool(pm) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { type: "string" },
+      action: { type: "string", enum: ["create", "list", "comment"] },
+      title: { type: "string" },
+      body: { 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 out = await runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.issues.create({ owner, repo, title: args.title || "", body: args.body || "" }); return { ok: true, number: r.data.number }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.post(`${base}/api/v1/repos/${owner}/${repo}/issues`, { title: args.title || "", body: args.body || "" }, { 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.issues.listForRepo({ owner, repo, state: "all" }); 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}/issues`, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, count: (r.data||[]).length }; }
+        });
+        return asToolResult({ providers: out });
+      }
+      if (args.action === "comment") {
+        const num = args.number;
+        if (!num) return asToolError("VALIDATION_ERROR", "number é obrigatório");
+        const out = await runBoth(pm, {
+          github: async (owner) => { await pm.github.rest.issues.createComment({ owner, repo, issue_number: num, body: args.body || "" }); return { ok: true }; },
+          gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); await axios.post(`${base}/api/v1/repos/${owner}/${repo}/issues/${num}/comments`, { body: args.body || "" }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true }; }
+        });
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), 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-issues", description: "Issues em paralelo (GitHub + Gitea)", inputSchema, handle };
+}