@andre.buzeli/git-mcp 15.12.5

package/src/tools/git-workflow.js

@@ -0,0 +1,443 @@
+import Ajv from "ajv";
+import fs from "fs";
+import path from "path";
+import { MCPError, asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
+import { getRepoNameFromPath, detectProjectType, GITIGNORE_TEMPLATES, validateProjectPath, withRetry } 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 diretório do projeto (ex: 'C:/Users/user/projeto' ou '/home/user/projeto')"
+      },
+      action: {
+        type: "string",
+        enum: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes", "clean", "update"],
+        description: `Ação a executar:
+- init: Inicializa repositório git local E cria repos no GitHub/Gitea automaticamente
+- status: Retorna arquivos modificados, staged, untracked (use ANTES de commit para ver o que mudou)
+- add: Adiciona arquivos ao staging (use ANTES de commit)
+- remove: Remove arquivos do staging
+- commit: Cria commit com os arquivos staged (use DEPOIS de add)
+- push: Envia commits para GitHub E Gitea em paralelo (use DEPOIS de commit)
+- ensure-remotes: Configura remotes GitHub e Gitea (use se push falhar por falta de remote)
+- clean: Remove arquivos não rastreados do working directory
+- update: RECOMENDADO - Executa fluxo completo automatizado (status → add → commit → push) em uma única chamada`
+      },
+      files: {
+        type: "array",
+        items: { type: "string" },
+        description: "Lista de arquivos para add/remove. Use ['.'] para todos os arquivos. Ex: ['src/index.js', 'package.json']"
+      },
+      message: {
+        type: "string",
+        description: "Mensagem do commit. Obrigatório para action='commit'. Ex: 'feat: adiciona nova funcionalidade'"
+      },
+      force: {
+        type: "boolean",
+        description: "Force push (use apenas se push normal falhar com erro de histórico divergente). Default: false"
+      },
+      createGitignore: {
+        type: "boolean",
+        description: "Se true, cria .gitignore padrão baseado no tipo de projeto (action='init'). Default: true"
+      },
+      isPublic: {
+        type: "boolean",
+        description: "Se true, repositório será PÚBLICO. Default: false (privado). Aplica-se a action='init' e 'ensure-remotes'"
+      },
+      dryRun: {
+        type: "boolean",
+        description: "Se true, simula a operação sem executar (útil para testes). Default: false"
+      },
+      skipIfClean: {
+        type: "boolean",
+        description: "Para action='update': se true, pula silenciosamente se não houver mudanças. Default: false"
+      },
+      gitignore: {
+        type: "array",
+        items: {
+          type: "string"
+        },
+        description: "Para action='update': lista de padrões para adicionar ao .gitignore antes de atualizar"
+      },
+      organization: {
+        type: "string",
+        description: "Opcional. Nome da organização no GitHub/Gitea onde o repositório será criado/gerenciado. Se não informado, usa a conta pessoal. Ex: 'automacao-casa', 'cliente-joao'"
+      }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: false
+  };
+
+  const description = `Operações Git essenciais com sincronização automática GitHub + Gitea.
+
+⭐ RECOMENDADO - FLUXO AUTOMATIZADO:
+• action="update" → Executa status, add, commit e push em uma única chamada
+• Exemplo: { "projectPath": "/path", "action": "update", "message": "feat: nova feature" }
+
+FLUXO MANUAL (se preferir controle individual):
+1. git-workflow status → ver arquivos modificados
+2. git-workflow add → adicionar arquivos ao staging  
+3. git-workflow commit → criar commit
+4. git-workflow push → enviar para GitHub e Gitea
+
+QUANDO USAR CADA ACTION:
+- update: ⭐ RECOMENDADO - Fluxo completo automatizado (status → add → commit → push)
+- status: Para verificar estado atual do repositório
+- add: Quando há arquivos modificados para commitar
+- commit: Após add, para salvar as mudanças
+- push: Após commit, para sincronizar com remotes
+- init: Apenas uma vez, para novos projetos (cria .gitignore automaticamente)
+- ensure-remotes: Se push falhar por falta de configuração
+- clean: Limpar arquivos não rastreados
+
+EXEMPLOS DE USO:
+• ⭐ Atualizar tudo: { "projectPath": "/path/to/project", "action": "update", "message": "feat: descrição" }
+• Iniciar projeto: { "projectPath": "/path/to/project", "action": "init" }
+• Ver mudanças: { "projectPath": "/path/to/project", "action": "status" }`;
+
+  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 {
+      // #region agent log
+      if (process.env.DEBUG_AGENT_LOG) {
+        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: 'debug-session', runId: 'run1', hypothesisId: 'H1', location: 'git-workflow.js:handle-entry', message: 'handle start', data: { action, projectPath }, timestamp: Date.now() }) }).catch(() => { });
+      }
+      // #endregion
+
+      validateProjectPath(projectPath);
+      // #region agent log
+      if (process.env.DEBUG_AGENT_LOG) {
+        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: 'debug-session', runId: 'run1', hypothesisId: 'H1', location: 'git-workflow.js:handle-validated', message: 'projectPath validated', data: { action }, timestamp: Date.now() }) }).catch(() => { });
+      }
+      // #endregion
+      if (action === "init") {
+        if (args.dryRun) {
+          return asToolResult({
+            success: true,
+            dryRun: true,
+            message: "DRY RUN: Repositório seria inicializado localmente e nos providers",
+            repoName: getRepoNameFromPath(projectPath),
+            gitignoreCreated: shouldCreateGitignore
+          });
+        }
+
+        const isRepo = await git.isRepo(projectPath);
+        if (!isRepo) {
+          await git.init(projectPath);
+        }
+
+        // Criar .gitignore baseado no tipo de projeto (apenas se não existir ou se for novo repo)
+        const shouldCreateGitignore = args.createGitignore !== false;
+        let gitignoreCreated = false;
+
+        if (shouldCreateGitignore) {
+          const hasGitignore = fs.existsSync(path.join(projectPath, ".gitignore"));
+          if (!hasGitignore) {
+            const projectType = detectProjectType(projectPath);
+            const patterns = GITIGNORE_TEMPLATES[projectType] || GITIGNORE_TEMPLATES.general;
+            await git.createGitignore(projectPath, patterns);
+            gitignoreCreated = true;
+          }
+        }
+
+        const repo = getRepoNameFromPath(projectPath);
+        const isPublic = args.isPublic === true; // Default: privado
+        const organization = args.organization || undefined;
+        const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic, organization });
+
+        // Configurar remotes com org se fornecida
+        const urls = await pm.getRemoteUrls(repo, organization);
+        await git.ensureRemotes(projectPath, { githubUrl: urls.github || "", giteaUrl: urls.gitea || "" });
+
+        return asToolResult({
+          success: true,
+          ensured,
+          isPrivate: !isPublic,
+          organization: organization || undefined,
+          gitignoreCreated,
+          message: "Repositório inicializado localmente e nos providers" + (organization ? ` [org: ${organization}]` : "") + (gitignoreCreated ? " (.gitignore criado)" : "") + (!isPublic ? " [PRIVADO]" : " [PÚBLICO]")
+        });
+      }
+      if (action === "status") {
+        const st = await git.status(projectPath);
+        // #region agent log
+        if (process.env.DEBUG_AGENT_LOG) {
+          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: 'debug-session', runId: 'run1', hypothesisId: 'H2', location: 'git-workflow.js:status', message: 'status result', data: { modified: st.modified.length, created: st.created.length, deleted: st.deleted.length, notAdded: st.not_added.length, isClean: st.isClean }, timestamp: Date.now() }) }).catch(() => { });
+        }
+        // #endregion
+
+        if (args.dryRun) {
+          return asToolResult({
+            success: true,
+            dryRun: true,
+            message: "DRY RUN: Status seria verificado",
+            ...st
+          });
+        }
+
+        // Adicionar contexto para AI Agent decidir próximo passo
+        const hasUnstaged = st.not_added?.length > 0 || st.modified?.length > 0 || st.created?.length > 0;
+        const hasStaged = st.staged?.length > 0;
+        const hasConflicts = st.conflicted?.length > 0;
+
+        let _aiContext = {
+          needsAdd: hasUnstaged && !hasStaged,
+          readyToCommit: hasStaged && !hasConflicts,
+          hasConflicts: hasConflicts,
+          isClean: st.isClean,
+          suggestedAction: null
+        };
+
+        if (hasConflicts) {
+          _aiContext.suggestedAction = "Resolva os conflitos manualmente antes de continuar";
+        } else if (hasStaged) {
+          _aiContext.suggestedAction = "Use action='commit' com uma mensagem descritiva";
+        } else if (hasUnstaged) {
+          _aiContext.suggestedAction = "Use action='add' com files=['.'] para adicionar todas as mudanças";
+        } else {
+          _aiContext.suggestedAction = "Working tree limpa. Modifique arquivos ou use action='push' se há commits pendentes";
+        }
+
+        return asToolResult({ ...st, _aiContext }, { tool: 'workflow', action: 'status' });
+      }
+      if (action === "add") {
+        const files = Array.isArray(args.files) && args.files.length ? args.files : ["."];
+
+        if (args.dryRun) {
+          return asToolResult({
+            success: true,
+            dryRun: true,
+            message: `DRY RUN: Arquivos seriam adicionados: ${files.join(", ")}`,
+            files
+          });
+        }
+
+        await git.add(projectPath, files);
+        return asToolResult({ success: true, files }, { tool: 'workflow', action: 'add' });
+      }
+      if (action === "remove") {
+        const files = Array.isArray(args.files) ? args.files : [];
+        await git.remove(projectPath, files);
+        return asToolResult({ success: true, files });
+      }
+      if (action === "commit") {
+        if (!args.message) {
+          return asToolError("MISSING_PARAMETER", "message é obrigatório para commit", { parameter: "message" });
+        }
+
+        if (args.dryRun) {
+          return asToolResult({
+            success: true,
+            dryRun: true,
+            message: `DRY RUN: Commit seria criado com mensagem: "${args.message}"`
+          });
+        }
+
+        const sha = await git.commit(projectPath, args.message);
+        // #region agent log
+        if (process.env.DEBUG_AGENT_LOG) {
+          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: 'debug-session', runId: 'run1', hypothesisId: 'H3', location: 'git-workflow.js:commit', message: 'commit created', data: { sha, message: args.message }, timestamp: Date.now() }) }).catch(() => { });
+        }
+        // #endregion
+        return asToolResult({ success: true, sha, message: args.message }, { tool: 'workflow', action: 'commit' });
+      }
+      if (action === "clean") {
+        if (args.dryRun) {
+          const result = await git.cleanUntracked(projectPath);
+          return asToolResult({
+            success: true,
+            dryRun: true,
+            message: `DRY RUN: ${result.cleaned.length} arquivo(s) seriam removidos`,
+            wouldClean: result.cleaned
+          });
+        }
+
+        const result = await git.cleanUntracked(projectPath);
+        return asToolResult({
+          success: true,
+          ...result,
+          message: result.cleaned.length > 0
+            ? `${result.cleaned.length} arquivo(s) não rastreados removidos`
+            : "Nenhum arquivo para limpar"
+        });
+      }
+      if (action === "ensure-remotes") {
+        const repo = getRepoNameFromPath(projectPath);
+        const isPublic = args.isPublic === true; // Default: privado
+        const organization = args.organization || undefined;
+
+        if (args.dryRun) {
+          const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: false, isPublic, organization }); // Don't create for dry run
+          const urls = await pm.getRemoteUrls(repo, organization);
+
+          return asToolResult({
+            success: true,
+            dryRun: true,
+            message: "DRY RUN: Remotes seriam configurados" + (organization ? ` [org: ${organization}]` : ""),
+            repo,
+            organization: organization || undefined,
+            githubUrl: urls.github || "",
+            giteaUrl: urls.gitea || "",
+            ensured
+          });
+        }
+
+        const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic, organization });
+        const urls = await pm.getRemoteUrls(repo, organization);
+        await git.ensureRemotes(projectPath, { githubUrl: urls.github || "", giteaUrl: urls.gitea || "" });
+        const remotes = await git.listRemotes(projectPath);
+        return asToolResult({ success: true, ensured, remotes, isPrivate: !isPublic, organization: organization || undefined }, { tool: 'workflow', action: 'ensure-remotes' });
+      }
+      if (action === "push") {
+        const branch = await git.getCurrentBranch(projectPath);
+        const force = !!args.force;
+
+        if (args.dryRun) {
+          return asToolResult({
+            success: true,
+            dryRun: true,
+            message: `DRY RUN: Push seria executado na branch '${branch}'${force ? ' (force)' : ''}`,
+            branch,
+            force
+          });
+        }
+
+        // Retry logic for push (often fails due to network or concurrent updates)
+        const result = await withRetry(
+          () => git.pushParallel(projectPath, branch, force),
+          3,
+          "push"
+        );
+
+        return asToolResult({ success: true, branch, ...result });
+      }
+
+      // ============ UPDATE - FLUXO AUTOMATIZADO COMPLETO ============
+      if (action === "update") {
+        if (!args.message) {
+          return asToolError("MISSING_PARAMETER", "message é obrigatório para update", { parameter: "message" });
+        }
+
+        const files = Array.isArray(args.files) && args.files.length ? args.files : ["."];
+        const force = !!args.force;
+        const skipIfClean = !!args.skipIfClean;
+        const gitignorePatterns = Array.isArray(args.gitignore) ? args.gitignore : [];
+
+        // 0. Gitignore (se solicitado)
+        let gitignored = [];
+        if (gitignorePatterns.length > 0) {
+          if (args.dryRun) {
+            gitignored = gitignorePatterns;
+          } else {
+            await git.addToGitignore(projectPath, gitignorePatterns);
+            gitignored = gitignorePatterns;
+          }
+        }
+
+        // 1. Status para ver o que mudou
+        const status = await git.status(projectPath);
+
+        const hasChanges = !status.isClean ||
+          (status.not_added?.length > 0) ||
+          (status.modified?.length > 0) ||
+          (status.created?.length > 0) ||
+          (status.deleted?.length > 0) ||
+          (status.staged?.length > 0);
+
+        if (!hasChanges && skipIfClean && gitignored.length === 0) {
+          return asToolResult({
+            success: true,
+            skipped: true,
+            reason: "Working tree limpa, nada para atualizar",
+            status
+          });
+        }
+
+        if (!hasChanges && gitignored.length === 0) {
+          return asToolResult({
+            success: false,
+            error: "NOTHING_TO_UPDATE",
+            message: "Nenhuma mudança para atualizar. Use skipIfClean=true para pular silenciosamente.",
+            status
+          });
+        }
+
+        if (args.dryRun) {
+          return asToolResult({
+            success: true,
+            dryRun: true,
+            message: "DRY RUN: Update seria executado",
+            wouldExecute: ["gitignore (opcional)", "status", "add", "commit", "push"],
+            files,
+            commitMessage: args.message,
+            gitignored,
+            status
+          });
+        }
+
+        // 2. Add
+        await git.add(projectPath, files);
+
+        // 3. Commit  
+        const sha = await git.commit(projectPath, args.message);
+
+        // 3.5. Garantir remotes com organization (se fornecida)
+        const organization = args.organization || undefined;
+        if (organization) {
+          const repo = getRepoNameFromPath(projectPath);
+          await pm.ensureRepos({ repoName: repo, createIfMissing: true, organization });
+          const urls = await pm.getRemoteUrls(repo, organization);
+          await git.ensureRemotes(projectPath, { githubUrl: urls.github || "", giteaUrl: urls.gitea || "" });
+        }
+
+        // 4. Push
+        const branch = await git.getCurrentBranch(projectPath);
+        const pushResult = await withRetry(
+          () => git.pushParallel(projectPath, branch, force),
+          3,
+          "push"
+        );
+
+        return asToolResult({
+          success: true,
+          action: "update",
+          steps: ["status", "add", "commit", "push"],
+          sha,
+          message: args.message,
+          branch,
+          filesAdded: files,
+          gitignored,
+          organization: organization || undefined,
+          push: pushResult,
+          _aiContext: {
+            completed: true,
+            message: "Ciclo completo: arquivos adicionados, commit criado e push realizado" + (organization ? ` [org: ${organization}]` : "")
+          }
+        }, { tool: 'workflow', action: 'update' });
+      }
+
+      return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, {
+        availableActions: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes", "clean", "update"],
+        suggestion: "Use action='update' para fluxo completo automatizado"
+      });
+    } catch (e) {
+      return errorToResponse(e);
+    }
+  }
+
+  return {
+    name: "git-workflow",
+    description,
+    inputSchema,
+    handle
+  };
+}

package/src/utils/env.js

@@ -0,0 +1,104 @@
+// Suporte a arquivo .env
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Carrega variáveis de ambiente de um arquivo .env
+ * @param {string} envPath - Caminho para o arquivo .env (opcional)
+ */
+export function loadEnv(envPath = null) {
+  // Tenta encontrar .env no diretório do projeto ou no cwd
+  const possiblePaths = [
+    envPath,
+    path.join(process.cwd(), ".env"),
+    path.join(process.cwd(), ".env.local"),
+    // Para quando executado como pacote npm
+    path.resolve(import.meta.url.replace("file:///", "").replace(/\/[^/]+$/, ""), "../../.env")
+  ].filter(Boolean);
+
+  for (const p of possiblePaths) {
+    try {
+      const normalizedPath = p.replace(/\\/g, "/").replace("file:///", "");
+      if (fs.existsSync(normalizedPath)) {
+        const content = fs.readFileSync(normalizedPath, "utf8");
+        parseEnvFile(content);
+        console.error(`[git-mcp] Loaded .env from: ${normalizedPath}`);
+        return true;
+      }
+    } catch (e) {
+      // Ignora erros de leitura
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Parse do conteúdo de um arquivo .env
+ * @param {string} content - Conteúdo do arquivo
+ */
+function parseEnvFile(content) {
+  const lines = content.split("\n");
+
+  for (const line of lines) {
+    // Ignora linhas vazias e comentários
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    // Parse KEY=VALUE
+    const match = trimmed.match(/^([^=]+)=(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      let value = match[2].trim();
+
+      // Remove aspas ao redor do valor
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+
+      // Só define se não existir (variáveis de ambiente têm precedência)
+      if (!(key in process.env)) {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+
+/**
+ * Retorna uma variável de ambiente com valor padrão opcional
+ * @param {string} key - Nome da variável
+ * @param {string} defaultValue - Valor padrão se não existir
+ */
+export function getEnvVar(key, defaultValue = "") {
+  return process.env[key] || defaultValue;
+}
+
+/**
+ * Verifica se todas as variáveis obrigatórias estão definidas
+ * @param {string[]} requiredVars - Lista de variáveis obrigatórias
+ * @returns {{ valid: boolean, missing: string[] }}
+ */
+export function validateEnv(requiredVars) {
+  const missing = requiredVars.filter(v => !process.env[v]);
+  return {
+    valid: missing.length === 0,
+    missing
+  };
+}
+
+/**
+ * Configuração padrão do git-mcp
+ */
+export const ENV_CONFIG = {
+  // Providers
+  GITHUB_TOKEN: "Token de autenticação do GitHub",
+  GITEA_URL: "URL do servidor Gitea",
+  GITEA_TOKEN: "Token de autenticação do Gitea",
+
+  // Performance
+  GIT_TIMEOUT_MS: "Timeout para operações Git em ms (default: 120000)",
+
+  // Debug
+  DEBUG_AGENT_LOG: "Habilita logging de debug"
+};