@andre.buzeli/git-mcp 15.12.5

package/src/utils/repoHelpers.js

@@ -0,0 +1,216 @@
+import path from "node:path";
+import fs from "node:fs";
+
+export function getRepoNameFromPath(projectPath) {
+  const base = path.basename(projectPath).trim();
+  return base.replace(/\s+/g, "_").replace(/[^A-Za-z0-9_\-]/g, "");
+}
+
+export function normalizeProjectFilePath(projectPath, relative) {
+  const joined = path.resolve(projectPath, relative || ".");
+  return joined;
+}
+
+/**
+ * Valida se um caminho é seguro (não contém path traversal)
+ * @param {string} projectPath - Caminho do projeto
+ * @throws {Error} Se o caminho contiver path traversal ou for inválido
+ */
+export function validateProjectPath(projectPath) {
+  if (!projectPath || typeof projectPath !== "string") {
+    throw new Error("projectPath é obrigatório e deve ser uma string");
+  }
+  
+  // Verifica se é um caminho absoluto
+  if (!path.isAbsolute(projectPath)) {
+    throw new Error("projectPath deve ser um caminho absoluto");
+  }
+  
+  // Normaliza o caminho
+  const normalized = path.resolve(projectPath);
+  
+  // Verifica path traversal patterns
+  if (projectPath.includes("..") || projectPath.includes("./..")) {
+    throw new Error("Path traversal detectado: caminho não pode conter '..'");
+  }
+  
+  // Verifica se o diretório pai existe
+  const parentDir = path.dirname(normalized);
+  if (!fs.existsSync(parentDir)) {
+    throw new Error("Diretório pai não existe");
+  }
+  
+  // Verifica se o caminho não é muito longo (limite do Windows é 260 chars)
+  if (normalized.length > 260) {
+    throw new Error("Caminho muito longo (máximo 260 caracteres)");
+  }
+  
+  return normalized;
+}
+
+/**
+ * Valida um caminho de arquivo relativo ao projeto
+ * @param {string} projectPath - Caminho do projeto
+ * @param {string} filePath - Caminho do arquivo relativo
+ * @returns {string} Caminho absoluto validado
+ */
+export function validateFilePath(projectPath, filePath) {
+  const normalizedProject = validateProjectPath(projectPath);
+  const absoluteFile = path.resolve(normalizedProject, filePath);
+  
+  // Garante que o arquivo está dentro do projeto
+  if (!absoluteFile.startsWith(normalizedProject)) {
+    throw new Error(`Path traversal detectado: '${filePath}' tenta acessar fora do projeto`);
+  }
+  
+  return absoluteFile;
+}
+
+/**
+ * Encontra a raiz do repositório Git subindo a árvore de diretórios
+ * @param {string} startDir - Diretório inicial
+ * @returns {string|null} Caminho da raiz do repo ou null se não encontrado
+ */
+export function findGitRoot(startDir) {
+  let current = path.resolve(startDir);
+  const root = path.parse(current).root;
+
+  while (true) {
+    if (fs.existsSync(path.join(current, ".git"))) {
+      return current;
+    }
+    if (current === root) {
+      return null;
+    }
+    current = path.dirname(current);
+  }
+}
+
+export function getEnv(key) {
+  const v = process.env[key];
+  return v === undefined ? "" : String(v);
+}
+
+export function getProvidersEnv() {
+  return {
+    githubToken: getEnv("GITHUB_TOKEN"),
+    giteaUrl: getEnv("GITEA_URL"),
+    giteaToken: getEnv("GITEA_TOKEN"),
+  };
+}
+
+/**
+ * Padrões comuns de .gitignore para diferentes tipos de projeto
+ */
+export const GITIGNORE_TEMPLATES = {
+  node: [
+    "node_modules/",
+    "npm-debug.log*",
+    "yarn-debug.log*",
+    "yarn-error.log*",
+    ".npm",
+    ".yarn",
+    "dist/",
+    "build/",
+    ".env",
+    ".env.local",
+    ".env.*.local",
+    "*.log",
+    ".DS_Store",
+    "Thumbs.db",
+    "*.swp",
+    "*.swo",
+    ".idea/",
+    ".vscode/",
+    "*.sublime-*",
+    "coverage/",
+    ".nyc_output/"
+  ],
+  python: [
+    "__pycache__/",
+    "*.py[cod]",
+    "*$py.class",
+    "*.so",
+    ".Python",
+    "env/",
+    "venv/",
+    ".venv/",
+    "pip-log.txt",
+    "pip-delete-this-directory.txt",
+    ".tox/",
+    ".coverage",
+    ".cache",
+    "*.egg-info/",
+    ".installed.cfg",
+    "*.egg",
+    ".env",
+    ".vscode/",
+    ".idea/"
+  ],
+  general: [
+    ".DS_Store",
+    "Thumbs.db",
+    "*.log",
+    "*.tmp",
+    "*.temp",
+    "*.swp",
+    "*.swo",
+    "*~",
+    ".env",
+    ".env.local",
+    ".vscode/",
+    ".idea/"
+  ]
+};
+
+/**
+ * Detecta o tipo de projeto baseado nos arquivos existentes
+ */
+export function detectProjectType(projectPath) {
+  if (fs.existsSync(path.join(projectPath, "package.json"))) {
+    return "node";
+  }
+  if (fs.existsSync(path.join(projectPath, "requirements.txt")) || 
+      fs.existsSync(path.join(projectPath, "setup.py")) ||
+      fs.existsSync(path.join(projectPath, "pyproject.toml"))) {
+    return "python";
+  }
+  return "general";
+}
+
+/**
+ * Executa uma operação com retries exponenciais
+ * @param {Function} operation - Função assíncrona a executar
+ * @param {number} maxRetries - Número máximo de tentativas
+ * @param {string} context - Contexto para logs
+ * @returns {Promise<any>} Resultado da operação
+ */
+export async function withRetry(operation, maxRetries = 3, context = "") {
+  let lastError;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await operation();
+    } catch (e) {
+      lastError = e;
+      const msg = e.message || String(e);
+      // Retry on network errors, lock files, or timeouts
+      const isRetryable = msg.includes("lock") || 
+                          msg.includes("network") || 
+                          msg.includes("resolve host") || 
+                          msg.includes("timeout") || 
+                          msg.includes("connection") ||
+                          msg.includes("ECONNRESET") ||
+                          msg.includes("ETIMEDOUT");
+      
+      if (!isRetryable && i === 0) throw e; // Fail fast if not retryable and first attempt
+      
+      if (i < maxRetries - 1) {
+        const delay = 2000 * Math.pow(2, i);
+        console.warn(`[${context}] Attempt ${i + 1} failed, retrying in ${delay}ms... Error: ${msg}`);
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+

package/src/utils/retry.js

@@ -0,0 +1,123 @@
+// Sistema de Retry com Backoff Exponencial e Rate Limit Handling
+
+const DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  initialDelay: 1000,
+  maxDelay: 10000,
+  backoffFactor: 2,
+  retryableErrors: [
+    // Network errors
+    "ETIMEDOUT", "ECONNRESET", "ENOTFOUND", "ECONNREFUSED", "ENETUNREACH", "EHOSTUNREACH",
+    // HTTP status codes
+    "timeout", "rate limit", "429", "503", "502", "504",
+    // SSL/TLS (pode ser temporário)
+    "EPROTO", "UNABLE_TO_GET_ISSUER_CERT",
+    // Outros
+    "socket hang up", "network error"
+  ]
+};
+
+function shouldRetry(error, options) {
+  const msg = (error?.message || String(error)).toLowerCase();
+  const code = error?.code?.toLowerCase() || "";
+  
+  return options.retryableErrors.some(e => 
+    msg.includes(e.toLowerCase()) || code.includes(e.toLowerCase())
+  );
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Extrai o tempo de espera do header Retry-After
+ * @param {Error} error - Erro com possível informação de rate limit
+ * @returns {number|null} - Tempo em ms para esperar, ou null se não encontrado
+ */
+function getRetryAfterMs(error) {
+  // Tenta extrair de headers (axios errors)
+  const headers = error?.response?.headers;
+  if (headers) {
+    const retryAfter = headers['retry-after'] || headers['x-ratelimit-reset'];
+    if (retryAfter) {
+      // Se for número de segundos
+      const seconds = parseInt(retryAfter, 10);
+      if (!isNaN(seconds)) {
+        // Se for timestamp unix (maior que ano 2000 em segundos)
+        if (seconds > 946684800) {
+          return Math.max(0, (seconds * 1000) - Date.now());
+        }
+        return seconds * 1000;
+      }
+    }
+  }
+  
+  // Tenta extrair de GitHub API rate limit
+  const rateLimitReset = error?.response?.headers?.['x-ratelimit-reset'];
+  if (rateLimitReset) {
+    const resetTime = parseInt(rateLimitReset, 10) * 1000;
+    return Math.max(0, resetTime - Date.now());
+  }
+  
+  return null;
+}
+
+export async function withRetry(fn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let lastError;
+  let delay = opts.initialDelay;
+  
+  for (let attempt = 1; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      
+      if (attempt === opts.maxRetries || !shouldRetry(error, opts)) {
+        throw error;
+      }
+      
+      // Verificar se há Retry-After header
+      const retryAfterMs = getRetryAfterMs(error);
+      const waitTime = retryAfterMs !== null 
+        ? Math.min(retryAfterMs, opts.maxDelay) 
+        : delay;
+      
+      if (process.env.DEBUG_AGENT_LOG) {
+        console.error(`[Retry] Attempt ${attempt}/${opts.maxRetries} failed, waiting ${waitTime}ms...`);
+      }
+      
+      await sleep(waitTime);
+      delay = Math.min(delay * opts.backoffFactor, opts.maxDelay);
+    }
+  }
+  
+  throw lastError;
+}
+
+// Wrapper para axios com retry
+export async function axiosWithRetry(axiosInstance, config, options = {}) {
+  return withRetry(() => axiosInstance(config), options);
+}
+
+// Wrapper para operações git com retry
+export async function gitWithRetry(fn, options = {}) {
+  return withRetry(fn, {
+    ...options,
+    retryableErrors: [...DEFAULT_OPTIONS.retryableErrors, "ENOENT", "lock"]
+  });
+}
+
+/**
+ * Wrapper específico para APIs com rate limit
+ */
+export async function apiWithRateLimitRetry(fn, options = {}) {
+  return withRetry(fn, {
+    maxRetries: 5,
+    initialDelay: 2000,
+    maxDelay: 60000,
+    ...options,
+    retryableErrors: ["rate limit", "429", "403", "too many requests"]
+  });
+}