@andrebuzeli/git-mcp 15.8.0 → 15.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "15.8.0",
+  "version": "15.8.1",
   "private": false,
   "description": "MCP server para Git com operações locais e sincronização paralela GitHub/Gitea",
   "license": "MIT",
@@ -35,6 +35,7 @@
     "@modelcontextprotocol/sdk": "^0.4.0",
     "@octokit/rest": "^20.0.0",
     "ajv": "^8.12.0",
+    "archiver": "^7.0.1",
     "axios": "^1.7.7"
   },
   "devDependencies": {

package/src/prompts/index.js

@@ -430,11 +430,42 @@ Analise o histórico e sugira qual commit pode ter introduzido o bug.`
   },
 
   "git-release": {
-    getMessages: (context) => [{
-      role: "user",
-      content: {
-        type: "text",
-        text: `# Criar Release do Projeto
+    getMessages: (context) => {
+      // Analisa mensagem do usuário para detectar instruções sobre assets
+      const userMessage = context.userMessage || "";
+      let assetsInstructions = "";
+      let detectedAssets = [];
+
+      // Detecta menções de upload/pasta/asset
+      const assetPatterns = [
+        /(?:upload|envia|adiciona?) (?:tamb[eé]m? )?(?:a |o |da |do )?(?:pasta|arquivo|asset) (.+?)(?: com (?:o |a )?nome (.+?))?(?:$|[.!?])/gi,
+        /(?:inclu[íi]|adiciona?) (.+?) (?:como |no |ao )?asset/gi,
+        /(?:compacta|zipa) (.+?)(?: como (.+?))?(?: e envia|$)/gi
+      ];
+
+      for (const pattern of assetPatterns) {
+        let match;
+        while ((match = pattern.exec(userMessage)) !== null) {
+          const assetPath = match[1]?.trim();
+          const assetName = match[2]?.trim();
+
+          if (assetPath) {
+            if (assetName) {
+              detectedAssets.push(`{ path: "${assetPath}", name: "${assetName}" }`);
+              assetsInstructions += `- Asset customizado: \`${assetPath}\` → \`${assetName}\`\n`;
+            } else {
+              detectedAssets.push(`"${assetPath}"`);
+              assetsInstructions += `- Asset automático: \`${assetPath}\`\n`;
+            }
+          }
+        }
+      }
+
+      return [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `# Criar Release do Projeto
 
 Você vai criar uma nova release deste projeto.
 
@@ -447,6 +478,9 @@ Você vai criar uma nova release deste projeto.
 ## Commits para esta Release
 ${context.recentCommits?.map(c => `- ${c.shortSha}: ${c.message}`).join("\n") || "Use git-history para ver commits"}
 
+## Assets para Upload
+${assetsInstructions || "Nenhum asset específico solicitado"}
+
 ## Passos para Release
 
 1. **Determinar versão**: Baseado nos commits, sugira a próxima versão (semver)
@@ -464,6 +498,7 @@ ${context.recentCommits?.map(c => `- ${c.shortSha}: ${c.message}`).join("\n") ||
    - tag: "vX.Y.Z"
    - name: "Release vX.Y.Z"
    - body: Release notes geradas
+${detectedAssets.length > 0 ? `   - assets: [${detectedAssets.join(', ')}]` : ''}
 
 ## Template de Release Notes
 
@@ -482,9 +517,12 @@ ${context.recentCommits?.map(c => `- ${c.shortSha}: ${c.message}`).join("\n") ||
 - Mudança 1
 \`\`\`
 
-Analise os commits e execute os passos para criar a release. UTILIZANDO APENAS AS TOOLS DO GIT-MCP.`
-      }
-    }]
+${assetsInstructions ? `## 📦 Assets Inclusos\n${assetsInstructions}` : ''}
+
+Analise os commits e execute os passos para criar a release${assetsInstructions ? ', incluindo os assets solicitados' : ''}. UTILIZANDO APENAS AS TOOLS DO GIT-MCP.`
+        }
+      }];
+    }
   },
 
   "git-update": {

package/src/tools/git-remote.js

@@ -1,9 +1,84 @@
 import Ajv from "ajv";
 import axios from "axios";
+import fs from "node:fs";
+import path from "node:path";
+import archiver from "archiver";
 import { asToolError, asToolResult, errorToResponse, mapExternalError } from "../utils/errors.js";
 import { getRepoNameFromPath, validateProjectPath } from "../utils/repoHelpers.js";
 import { runBoth } from "../utils/providerExec.js";
 
+/**
+ * Compacta uma pasta em ZIP e retorna o caminho do arquivo temporário
+ * @param {string} folderPath - Caminho da pasta a compactar
+ * @param {string} zipName - Nome do arquivo ZIP (sem extensão)
+ * @returns {Promise<string>} Caminho do arquivo ZIP criado
+ */
+async function compactFolder(folderPath, zipName) {
+  return new Promise((resolve, reject) => {
+    const outputPath = path.join(process.cwd(), 'temp_scripts', `${zipName}.zip`);
+    const output = fs.createWriteStream(outputPath);
+    const archive = archiver('zip', { zlib: { level: 9 } });
+
+    output.on('close', () => resolve(outputPath));
+    output.on('error', reject);
+    archive.on('error', reject);
+
+    archive.pipe(output);
+    archive.directory(folderPath, false);
+    archive.finalize();
+  });
+}
+
+/**
+ * Faz upload de um asset para um release
+ * @param {Object} pm - Provider Manager
+ * @param {string} owner - Dono do repo
+ * @param {string} repo - Nome do repo
+ * @param {number} releaseId - ID do release
+ * @param {string} assetPath - Caminho do arquivo a fazer upload
+ * @param {string} assetName - Nome do asset (com extensão)
+ * @returns {Promise<Object>} Resultado do upload
+ */
+async function uploadAsset(pm, owner, repo, releaseId, assetPath, assetName) {
+  const fileBuffer = fs.readFileSync(assetPath);
+  const fileSize = fs.statSync(assetPath).size;
+
+  const out = await runBoth(pm, {
+    github: async () => {
+      const response = await pm.github.request("POST /repos/{owner}/{repo}/releases/{release_id}/assets", {
+        owner,
+        repo,
+        release_id: releaseId,
+        name: assetName,
+        data: fileBuffer,
+        headers: {
+          'content-type': 'application/octet-stream',
+          'content-length': fileSize
+        }
+      });
+      return { ok: true, id: response.data.id, url: response.data.browser_download_url };
+    },
+    gitea: async () => {
+      const base = pm.giteaUrl.replace(/\/$/, "");
+
+      const response = await axios.post(
+        `${base}/api/v1/repos/${owner}/${repo}/releases/${releaseId}/assets?name=${encodeURIComponent(assetName)}`,
+        fileBuffer,
+        {
+          headers: {
+            'Authorization': `token ${pm.giteaToken}`,
+            'Content-Type': 'application/octet-stream',
+            'Content-Length': fileSize
+          }
+        }
+      );
+      return { ok: true, id: response.data.id, url: response.data.browser_download_url };
+    }
+  });
+
+  return out;
+}
+
 const ajv = new Ajv({ allErrors: true });
 
 export function createGitRemoteTool(pm, git) {
@@ -62,6 +137,23 @@ ARQUIVOS VIA API:
         type: "string",
         description: "Descrição/corpo da release"
       },
+      assets: {
+        type: "array",
+        items: {
+          oneOf: [
+            { type: "string" },  // path simples: "dist/app.exe"
+            {
+              type: "object",
+              properties: {
+                path: { type: "string" },  // "dist/build"
+                name: { type: "string" }   // "MeuApp-Windows" (sem extensao)
+              },
+              required: ["path"]
+            }
+          ]
+        },
+        description: "Assets para upload. String = nome automatico, Objeto = nome custom. Pastas são compactadas automaticamente"
+      },
       topics: {
         type: "array",
         items: { type: "string" },
@@ -190,11 +282,100 @@ QUANDO USAR:
         const tag = args.tag;
         const name = args.name || tag;
         const body = args.body || "";
+
+        // Criar release primeiro
         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, url: r.data.html_url }; },
           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), tag, name, providers: out });
+
+        const releaseCreated = !!(out.github?.ok || out.gitea?.ok);
+        if (!releaseCreated) {
+          return asToolResult({ success: false, tag, name, providers: out, error: "Falha ao criar release" });
+        }
+
+        // Processar assets se fornecidos
+        let assetsUploaded = [];
+        if (args.assets && args.assets.length > 0) {
+          const tempFiles = []; // Arquivos temporários a serem deletados
+          const [ghOwner, geOwner] = await Promise.all([
+            pm.getGitHubOwner().catch(() => ""),
+            pm.getGiteaOwner().catch(() => "")
+          ]);
+
+          for (const asset of args.assets) {
+            try {
+              const assetPath = typeof asset === 'string' ? asset : asset.path;
+              const customName = typeof asset === 'object' ? asset.name : null;
+
+              // Resolver caminho absoluto
+              const absolutePath = path.resolve(projectPath, assetPath);
+
+              // Verificar se existe
+              if (!fs.existsSync(absolutePath)) {
+                assetsUploaded.push({ path: assetPath, error: "Arquivo/pasta não encontrado" });
+                continue;
+              }
+
+              const stats = fs.statSync(absolutePath);
+              let uploadPath = absolutePath;
+              let uploadName = customName;
+              let isTempFile = false;
+
+              if (stats.isDirectory()) {
+                // Compactar pasta
+                const zipName = customName || path.basename(absolutePath);
+                const zipPath = await compactFolder(absolutePath, zipName);
+                uploadPath = zipPath;
+                uploadName = `${zipName}.zip`;
+                tempFiles.push(zipPath);
+                isTempFile = true;
+              } else {
+                // Arquivo direto
+                if (!uploadName) {
+                  uploadName = path.basename(absolutePath);
+                } else {
+                  // Adicionar extensão se não tiver
+                  const ext = path.extname(absolutePath);
+                  if (!uploadName.includes('.')) {
+                    uploadName += ext;
+                  }
+                }
+              }
+
+              // Upload para GitHub e Gitea
+              const uploadResult = await uploadAsset(pm, ghOwner || geOwner, repo, out.github?.id || out.gitea?.id, uploadPath, uploadName);
+
+              assetsUploaded.push({
+                path: assetPath,
+                name: uploadName,
+                uploaded: !!(uploadResult.github?.ok || uploadResult.gitea?.ok),
+                providers: uploadResult
+              });
+
+              // Deletar arquivo temporário se foi criado
+              if (isTempFile && tempFiles.includes(uploadPath)) {
+                try {
+                  fs.unlinkSync(uploadPath);
+                  tempFiles.splice(tempFiles.indexOf(uploadPath), 1);
+                } catch (e) {
+                  console.warn(`Falha ao deletar arquivo temporário: ${uploadPath}`);
+                }
+              }
+
+            } catch (error) {
+              assetsUploaded.push({ path: typeof asset === 'string' ? asset : asset.path, error: String(error.message || error) });
+            }
+          }
+        }
+
+        return asToolResult({
+          success: releaseCreated,
+          tag,
+          name,
+          providers: out,
+          assets: assetsUploaded.length > 0 ? assetsUploaded : undefined
+        });
       }
       if (action === "topics-set") {
         const repo = getRepoNameFromPath(projectPath);