@andre.buzeli/git-mcp 16.0.6 → 16.1.2

package/package.json

@@ -1,29 +1,32 @@
-{
-  "name": "@andre.buzeli/git-mcp",
-  "version": "16.0.6",
-  "private": false,
-  "description": "MCP server para Git com operações locais e sincronização paralela GitHub/Gitea",
-  "license": "MIT",
-  "author": "andre.buzeli",
-  "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "src",
-    "README.md"
-  ],
-  "main": "src/index.js",
-  "bin": {
-    "git-mcp": "src/index.js",
-    "git-mcpv2": "src/index.js"
-  },
-  "scripts": {},
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^0.4.0",
-    "@octokit/rest": "^20.0.0",
-    "ajv": "^8.12.0",
-    "archiver": "^7.0.0",
-    "axios": "^1.7.7"
-  }
-}
+{
+  "name": "@andre.buzeli/git-mcp",
+  "version": "16.1.2",
+  "private": false,
+  "description": "MCP server para Git com operações locais e sincronização paralela GitHub/Gitea",
+  "license": "MIT",
+  "author": "andre.buzeli",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "main": "src/index.js",
+  "bin": {
+    "git-mcp": "src/index.js",
+    "git-mcpv2": "src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "@octokit/rest": "^20.0.0",
+    "ajv": "^8.12.0",
+    "archiver": "^7.0.0",
+    "axios": "^1.7.7",
+    "zod": "^3.23.0"
+  }
+}

package/src/index.js

@@ -1,147 +1,159 @@
-#!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import Ajv from "ajv";
-import { loadEnv } from "./utils/env.js";
-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";
-import { createGitMergeTool } from "./tools/git-merge.js";
-import { createGitDiffTool } from "./tools/git-diff.js";
-import { createGitCloneTool } from "./tools/git-clone.js";
-import { createGitHelpTool } from "./tools/git-help.js";
-import { getResources, readResource } from "./resources/index.js";
-import { createPromptsHandler, PROMPTS } from "./prompts/index.js";
-
-// Carrega variáveis de ambiente do arquivo .env (se existir)
-loadEnv();
-
-const pm = new ProviderManager();
-const git = new GitAdapter(pm);
-
-// Log de inicialização para stderr (não interfere com stdio do MCP)
-const hasGitHub = !!process.env.GITHUB_TOKEN;
-const hasGitea = !!process.env.GITEA_URL && !!process.env.GITEA_TOKEN;
-if (!hasGitHub && !hasGitea) {
-  console.error("[git-mcp] ⚠️ Nenhum provider configurado. Operações remotas não funcionarão.");
-  console.error("[git-mcp] Configure GITHUB_TOKEN e/ou GITEA_URL + GITEA_TOKEN");
-} else {
-  const providers = [];
-  if (hasGitHub) providers.push("GitHub");
-  if (hasGitea) providers.push("Gitea");
-  console.error(`[git-mcp] ✓ Providers ativos: ${providers.join(", ")}`);
-}
-
-const transport = new StdioServerTransport();
-const server = new Server(
-  { name: "git-mcp", version: "15.12.4" },
-  { capabilities: { tools: {}, resources: {}, prompts: {} } }
-);
-server.connect(transport);
-
-// Prompts handler
-const promptsHandler = createPromptsHandler(git, pm);
-
-// Ajv singleton para validação
-const ajv = new Ajv({ allErrors: true });
-
-const tools = [
-  createGitHelpTool(),  // Primeiro: AI pode pedir ajuda
-  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),
-  createGitMergeTool(git),
-  createGitDiffTool(git),
-  createGitCloneTool(git),
-];
-
-// ============ TOOLS ============
-server.setRequestHandler(
-  (await import("@modelcontextprotocol/sdk/types.js")).ListToolsRequestSchema,
-  async () => ({
-    tools: tools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
-  })
-);
-
-server.setRequestHandler(
-  (await import("@modelcontextprotocol/sdk/types.js")).CallToolRequestSchema,
-  async (req) => {
-    const name = req.params?.name || "";
-    const args = req.params?.arguments || {};
-    // Progress reporting removed to prevent timeouts/unknown token errors on slow networks
-    // 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));
-    }
-  }
-);
-
-// ============ RESOURCES ============
-server.setRequestHandler(
-  (await import("@modelcontextprotocol/sdk/types.js")).ListResourcesRequestSchema,
-  async () => ({ resources: getResources() })
-);
-
-server.setRequestHandler(
-  (await import("@modelcontextprotocol/sdk/types.js")).ReadResourceRequestSchema,
-  async (req) => {
-    const uri = req.params?.uri || "";
-    const content = readResource(uri);
-    if (!content) {
-      return { contents: [{ uri, mimeType: "text/plain", text: `Resource não encontrado: ${uri}` }] };
-    }
-    return { contents: [{ uri, mimeType: "text/markdown", text: content }] };
-  }
-);
-
-// ============ PROMPTS ============
-server.setRequestHandler(
-  (await import("@modelcontextprotocol/sdk/types.js")).ListPromptsRequestSchema,
-  async () => ({ prompts: PROMPTS })
-);
-
-server.setRequestHandler(
-  (await import("@modelcontextprotocol/sdk/types.js")).GetPromptRequestSchema,
-  async (req) => {
-    const name = req.params?.name || "";
-    const args = req.params?.arguments || {};
-    return await promptsHandler.get(name, args);
-  }
-);
-
-// Keep process alive
-process.stdin.resume();
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import Ajv from "ajv";
+import { loadEnv } from "./utils/env.js";
+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";
+import { createGitMergeTool } from "./tools/git-merge.js";
+import { createGitDiffTool } from "./tools/git-diff.js";
+import { createGitCloneTool } from "./tools/git-clone.js";
+import { createGitWorktreeTool } from "./tools/git-worktree.js";
+import { createGitHelpTool } from "./tools/git-help.js";
+import { getResources, readResource } from "./resources/index.js";
+import { createPromptsHandler, PROMPTS } from "./prompts/index.js";
+import { sendProgress } from "./utils/mcpNotify.js";
+
+// Carrega variáveis de ambiente do arquivo .env (se existir)
+loadEnv();
+
+const pm = new ProviderManager();
+const git = new GitAdapter(pm);
+
+// Log de inicialização para stderr (não interfere com stdio do MCP)
+const hasGitHub = !!process.env.GITHUB_TOKEN;
+const hasGitea = !!process.env.GITEA_URL && !!process.env.GITEA_TOKEN;
+if (!hasGitHub && !hasGitea) {
+  console.error("[git-mcp] ⚠️ Nenhum provider configurado. Operações remotas não funcionarão.");
+  console.error("[git-mcp] Configure GITHUB_TOKEN e/ou GITEA_URL + GITEA_TOKEN");
+} else {
+  const providers = [];
+  if (hasGitHub) providers.push("GitHub");
+  if (hasGitea) providers.push("Gitea");
+  console.error(`[git-mcp] ✓ Providers ativos: ${providers.join(", ")}`);
+}
+
+const transport = new StdioServerTransport();
+const server = new Server(
+  { name: "git-mcp", version: "16.0.8" },
+  { capabilities: {
+    tools: { listChanged: true },
+    resources: { subscribe: true, listChanged: true },
+    prompts: {},
+    logging: {}
+  } }
+);
+server.connect(transport);
+
+// Prompts handler
+const promptsHandler = createPromptsHandler(git, pm);
+
+// Ajv singleton para validação
+const ajv = new Ajv({ allErrors: true });
+
+const tools = [
+  createGitHelpTool(),  // Primeiro: AI pode pedir ajuda
+  createGitWorkflowTool(pm, git, server),
+  createGitRemoteTool(pm, git, server),
+  createGitBranchesTool(git),
+  createGitTagsTool(git),
+  createGitStashTool(git),
+  createGitResetTool(git, server),
+  createGitConfigTool(git),
+  createGitIgnoreTool(git),
+  createGitFilesTool(git),
+  createGitHistoryTool(git),
+  createGitSyncTool(git),
+  createGitIssuesTool(pm),
+  createGitPullsTool(pm),
+  createGitMergeTool(git),
+  createGitDiffTool(git),
+  createGitCloneTool(git),
+  createGitWorktreeTool(git),
+];
+
+// ============ TOOLS ============
+server.setRequestHandler(
+  (await import("@modelcontextprotocol/sdk/types.js")).ListToolsRequestSchema,
+  async () => ({
+    tools: tools.map(t => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema,
+      annotations: t.annotations
+    })),
+  })
+);
+
+server.setRequestHandler(
+  (await import("@modelcontextprotocol/sdk/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 {
+      await sendProgress(server, progressToken, 0, 100, `Executando ${name}...`);
+
+      const result = await tool.handle(args);
+
+      await sendProgress(server, progressToken, 100, 100, `${name} concluído`);
+
+      return result;
+    } catch (e) {
+      return asToolError(e.code || "ERROR", e.message || String(e));
+    }
+  }
+);
+
+// ============ RESOURCES ============
+server.setRequestHandler(
+  (await import("@modelcontextprotocol/sdk/types.js")).ListResourcesRequestSchema,
+  async () => ({ resources: getResources() })
+);
+
+server.setRequestHandler(
+  (await import("@modelcontextprotocol/sdk/types.js")).ReadResourceRequestSchema,
+  async (req) => {
+    const uri = req.params?.uri || "";
+    const content = readResource(uri);
+    if (!content) {
+      return { contents: [{ uri, mimeType: "text/plain", text: `Resource não encontrado: ${uri}` }] };
+    }
+    return { contents: [{ uri, mimeType: "text/markdown", text: content }] };
+  }
+);
+
+// ============ PROMPTS ============
+server.setRequestHandler(
+  (await import("@modelcontextprotocol/sdk/types.js")).ListPromptsRequestSchema,
+  async () => ({ prompts: PROMPTS })
+);
+
+server.setRequestHandler(
+  (await import("@modelcontextprotocol/sdk/types.js")).GetPromptRequestSchema,
+  async (req) => {
+    const name = req.params?.name || "";
+    const args = req.params?.arguments || {};
+    return await promptsHandler.get(name, args);
+  }
+);
+
+// Keep process alive
+process.stdin.resume();

package/src/providers/providerManager.js

@@ -93,7 +93,9 @@ export class ProviderManager {
   }
 
   async getRemoteUrls(repoName, organization) {
-    const cacheKey = `urls_${organization || ""}_${repoName}`;
+    // When organization is specified, prefix repo name (no actual org needed)
+    const effectiveName = organization ? `${organization}---${repoName}` : repoName;
+    const cacheKey = `urls_${effectiveName}`;
     const now = Date.now();
 
     // Verificar cache
@@ -106,20 +108,20 @@ export class ProviderManager {
 
     const urls = {};
 
-    // GitHub URL
+    // GitHub URL — always personal account
     if (this.github) {
-      const owner = organization || await this.getGitHubOwner();
+      const owner = await this.getGitHubOwner();
       if (owner) {
-        urls.github = `https://github.com/${owner}/${repoName}.git`;
+        urls.github = `https://github.com/${owner}/${effectiveName}.git`;
       }
     }
 
-    // Gitea URL
+    // Gitea URL — always personal account
     if (this.giteaUrl && this.giteaToken) {
-      const owner = organization || await this.getGiteaOwner();
+      const owner = await this.getGiteaOwner();
       if (owner) {
         const base = this.giteaUrl.replace(/\/$/, "");
-        urls.gitea = `${base}/${owner}/${repoName}.git`;
+        urls.gitea = `${base}/${owner}/${effectiveName}.git`;
       }
     }
 
@@ -130,76 +132,27 @@ export class ProviderManager {
   }
 
   async ensureRepos({ repoName, createIfMissing = true, description = "Managed by git-mcpv2", isPublic = false, organization }) {
-    // Por padrão, repositórios são PRIVADOS. Use isPublic=true para público.
+    // When organization is specified, prefix repo name (e.g., "MCP---GIT_MCP")
+    const effectiveName = organization ? `${organization}---${repoName}` : repoName;
     const isPrivate = !isPublic;
     const results = { github: null, gitea: null };
-    // GitHub
+
+    // GitHub — always personal account
     if (this.github) {
-      const owner = organization || await this.getGitHubOwner();
+      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 };
+            await this.github.rest.repos.get({ owner, repo: effectiveName });
+            results.github = { ok: true, repo: `${owner}/${effectiveName}`, created: false };
           } catch {
             if (createIfMissing) {
-              let cr;
-              if (organization) {
-                // Tentar criar repo na organização
-                try {
-                  cr = await this.github.rest.repos.createInOrg({
-                    org: organization,
-                    name: repoName,
-                    description,
-                    private: isPrivate,
-                    auto_init: false,
-                  });
-                } catch (orgRepoErr) {
-                  const errMsg = String(orgRepoErr?.message || orgRepoErr).toLowerCase();
-                  // Se org não existe, criar a org primeiro e depois o repo
-                  if (errMsg.includes("not found") || errMsg.includes("404")) {
-                    console.error(`[ProviderManager] GitHub org '${organization}' not found, creating...`);
-                    try {
-                      await this.github.rest.orgs.createForAuthenticatedUser
-                        ? await this.github.request("POST /user/orgs", { login: organization, profile_name: organization })
-                        : null;
-                    } catch (orgCreateErr) {
-                      // GitHub free users can't create orgs via API, try alternative
-                      console.error(`[ProviderManager] GitHub org creation failed: ${orgCreateErr?.message}. Trying as user repo with org topic...`);
-                    }
-                    // Retry repo creation in org
-                    try {
-                      cr = await this.github.rest.repos.createInOrg({
-                        org: organization,
-                        name: repoName,
-                        description,
-                        private: isPrivate,
-                        auto_init: false,
-                      });
-                    } catch {
-                      // Fallback: create as personal repo if org creation not possible
-                      console.error(`[ProviderManager] Fallback: creating '${repoName}' as personal repo (GitHub org '${organization}' unavailable)`);
-                      cr = await this.github.rest.repos.createForAuthenticatedUser({
-                        name: repoName,
-                        description: `[org:${organization}] ${description}`,
-                        private: isPrivate,
-                        auto_init: false,
-                      });
-                    }
-                  } else {
-                    throw orgRepoErr;
-                  }
-                }
-              } else {
-                // Criar repo no usuário pessoal
-                cr = await this.github.rest.repos.createForAuthenticatedUser({
-                  name: repoName,
-                  description,
-                  private: isPrivate,
-                  auto_init: false,
-                });
-              }
+              const cr = await this.github.rest.repos.createForAuthenticatedUser({
+                name: effectiveName,
+                description,
+                private: isPrivate,
+                auto_init: false,
+              });
               results.github = { ok: true, repo: cr.data.full_name, created: true };
             } else {
               results.github = { ok: false, error: "missing" };
@@ -210,52 +163,26 @@ export class ProviderManager {
         }
       }
     }
-    // Gitea
+
+    // Gitea — always personal account
     if (this.giteaUrl && this.giteaToken) {
-      const owner = organization || await this.getGiteaOwner();
+      const owner = await this.getGiteaOwner();
       if (owner) {
         try {
           const base = this.giteaUrl.replace(/\/$/, "");
-          const getRepo = await axios.get(`${base}/api/v1/repos/${owner}/${repoName}`,
+          const getRepo = await axios.get(`${base}/api/v1/repos/${owner}/${effectiveName}`,
             { headers: { Authorization: `token ${this.giteaToken}` }, timeout: 8000 });
           if (getRepo.status === 200) {
-            results.gitea = { ok: true, repo: `${owner}/${repoName}`, created: false };
+            results.gitea = { ok: true, repo: `${owner}/${effectiveName}`, created: false };
           }
         } catch (e) {
           if (createIfMissing) {
             try {
-              let createUrl;
-              if (organization) {
-                // Verificar se org existe, criar se não existir
-                try {
-                  await axios.get(`${this.giteaUrl}/api/v1/orgs/${organization}`,
-                    { headers: { Authorization: `token ${this.giteaToken}` }, timeout: 8000 });
-                } catch (orgCheckErr) {
-                  // Org não existe, criar
-                  console.error(`[ProviderManager] Gitea org '${organization}' not found, creating...`);
-                  try {
-                    await axios.post(`${this.giteaUrl}/api/v1/orgs`, {
-                      username: organization,
-                      full_name: organization,
-                      description: `Organization ${organization}`,
-                      visibility: isPublic ? "public" : "limited",
-                    }, { headers: { Authorization: `token ${this.giteaToken}` }, timeout: 8000 });
-                    console.error(`[ProviderManager] Gitea org '${organization}' created successfully`);
-                  } catch (orgCreateErr) {
-                    const msg = String(orgCreateErr?.message || orgCreateErr).toLowerCase();
-                    if (!msg.includes("already exists") && !msg.includes("409")) {
-                      console.error(`[ProviderManager] Gitea org creation failed: ${orgCreateErr?.message}`);
-                    }
-                  }
-                }
-                createUrl = `${this.giteaUrl}/api/v1/orgs/${organization}/repos`;
-              } else {
-                createUrl = `${this.giteaUrl}/api/v1/user/repos`;
-              }
-              const cr = await axios.post(createUrl,
-                { name: repoName, description, private: isPrivate, auto_init: false },
+              const base = this.giteaUrl.replace(/\/$/, "");
+              const cr = await axios.post(`${base}/api/v1/user/repos`,
+                { name: effectiveName, description, private: isPrivate, auto_init: false },
                 { headers: { Authorization: `token ${this.giteaToken}` }, timeout: 8000 });
-              results.gitea = { ok: true, repo: `${cr.data?.owner?.login || owner}/${repoName}`, created: true };
+              results.gitea = { ok: true, repo: `${cr.data?.owner?.login || owner}/${effectiveName}`, created: true };
             } catch (err) {
               results.gitea = { ok: false, error: String(err?.message || err) };
             }

package/src/tools/git-branches.js

@@ -10,7 +10,7 @@ export function createGitBranchesTool(git) {
     properties: {
       projectPath: { 
         type: "string",
-        description: "Caminho absoluto do diretório do projeto"
+        description: "Caminho absoluto do diretório do projeto no IDE (ex: '/home/user/meu-projeto' ou 'C:/Users/user/meu-projeto'). IMPORTANTE: este valor não pode ser inferido automaticamente pelo servidor — o agente deve fornecer o path real do projeto sendo trabalhado, não o diretório home do usuário."
       },
       action: { 
         type: "string", 
@@ -39,7 +39,11 @@ export function createGitBranchesTool(git) {
     additionalProperties: false
   };
 
-  const description = `Gerenciamento de branches Git.
+  const description = `IMPORTANTE — projectPath:
+Informe o caminho absoluto do projeto aberto no IDE. O servidor MCP não tem acesso ao
+contexto do IDE e não consegue detectar automaticamente qual projeto está sendo trabalhado.
+
+Gerenciamento de branches Git.
 
 AÇÕES DISPONÍVEIS:
 - list: Ver branches existentes (locais e remotas)
@@ -122,5 +126,11 @@ CONVENÇÕES DE NOMES:
     }
   }
 
-  return { name: "git-branches", description, inputSchema, handle };
+  return { 
+    name: "git-branches", 
+    description, 
+    inputSchema, 
+    handle,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  };
 }