@andre.buzeli/git-mcp 16.0.6 → 16.0.8

package/package.json

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

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-workflow.js

@@ -318,19 +318,6 @@ EXEMPLOS DE USO:
 
         const organization = args.organization || undefined;
 
-        // Ensure repos exist and set correct remote URLs (handles GitHub org fallback)
-        if (organization) {
-          const repo = getRepoNameFromPath(projectPath);
-          const isPublic = args.isPublic === true;
-          const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic, organization });
-          const githubUrl = ensured.github?.ok && ensured.github.repo
-            ? `https://github.com/${ensured.github.repo}.git` : "";
-          const giteaBase = pm.giteaUrl?.replace(/\/$/, "");
-          const giteaUrl = ensured.gitea?.ok && ensured.gitea.repo && giteaBase
-            ? `${giteaBase}/${ensured.gitea.repo}.git` : "";
-          await git.ensureRemotes(projectPath, { githubUrl, giteaUrl, organization });
-        }
-
         // Retry logic for push (often fails due to network or concurrent updates)
         const result = await withRetry(
           () => git.pushParallel(projectPath, branch, force, organization),

package/src/utils/gitAdapter.js

@@ -616,9 +616,16 @@ export class GitAdapter {
     }
 
     async pushParallel(dir, branch, force = false, organization) {
-        await this.ensureRemotes(dir, { organization });
+        // Check if remotes already configured (caller may have set correct fallback URLs)
         const remotesStr = await this._exec(dir, ["remote"]);
-        const remotes = remotesStr.split("\n").filter(r => ["github", "gitea"].includes(r.trim()));
+        let remotes = remotesStr.split("\n").filter(r => ["github", "gitea"].includes(r.trim()));
+
+        // Only setup remotes if none exist — caller is responsible for correct URLs
+        if (remotes.length === 0) {
+            await this.ensureRemotes(dir, { organization });
+            const newStr = await this._exec(dir, ["remote"]);
+            remotes = newStr.split("\n").filter(r => ["github", "gitea"].includes(r.trim()));
+        }
 
         if (remotes.length === 0) {
             throw createError("REMOTE_NOT_FOUND", { message: "Nenhum remote github/gitea configurado" });
@@ -643,10 +650,13 @@ export class GitAdapter {
                     try {
                         console.error(`[GitAdapter] Auto-fix: repositório não existe no remote '${remote}', criando automaticamente...`);
                         const repoName = getRepoNameFromPath(dir);
-                        const ensured = await this.pm.ensureRepos({ repoName, createIfMissing: true, isPublic: false });
+                        const ensured = await this.pm.ensureRepos({ repoName, createIfMissing: true, isPublic: false, organization });
 
-                        // Atualiza remotes após criar repo
-                        await this.ensureRemotes(dir, {});
+                        // Atualiza remotes após criar repo — use actual result URLs
+                        const ghUrl = ensured.github?.ok && ensured.github.repo ? `https://github.com/${ensured.github.repo}.git` : "";
+                        const gtBase = this.pm.giteaUrl?.replace(/\/$/, "");
+                        const gtUrl = ensured.gitea?.ok && ensured.gitea.repo && gtBase ? `${gtBase}/${ensured.gitea.repo}.git` : "";
+                        await this.ensureRemotes(dir, { githubUrl: ghUrl, giteaUrl: gtUrl, organization });
 
                         // Tenta push novamente
                         await this.pushOne(dir, remote, branch, force, true); // Usa -u para criar branch também