@andre.buzeli/git-mcp 16.1.3 → 16.1.6

package/src/utils/worktreeResolver.js

@@ -0,0 +1,189 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+const PROTECTED_PATH_PREFIXES = [
+  'C:\\Users',
+  'C:/Users'
+];
+
+/**
+ * Verifica se um caminho é protegido e não deve receber git init/worktree.
+ * Normaliza separadores e compara case-insensitive.
+ * @param {string} p - Caminho absoluto a verificar
+ * @returns {boolean} - True se for protegido
+ */
+export function isProtectedPath(p) {
+  if (!p) return false;
+  
+  const normalized = p.replace(/\\/g, '/').toLowerCase();
+  
+  // Verifica se o caminho é temporário (permitido) APENAS em ambiente de teste
+  // Isso é importante para testes em ambientes onde o temp está dentro de Users
+  if (process.env.NODE_ENV === 'test') {
+      const tempDir = path.resolve(process.env.TEMP || process.env.TMP || '/tmp').replace(/\\/g, '/').toLowerCase();
+      if (normalized.startsWith(tempDir)) {
+          return false;
+      }
+  }
+  
+  for (const prefix of PROTECTED_PATH_PREFIXES) {
+    const normalizedPrefix = prefix.replace(/\\/g, '/').toLowerCase();
+    
+    // Verifica igualdade exata ou se é subdiretório
+    if (normalized === normalizedPrefix || normalized.startsWith(normalizedPrefix + '/')) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Busca ascendente por um diretório ou arquivo .git com limite de profundidade.
+ * @param {string} startPath - Caminho inicial absoluto
+ * @param {number} maxDepth - Número máximo de níveis para subir (default: 2)
+ * @returns {string|null} - Caminho do diretório contendo .git ou null se não encontrar
+ */
+export function findGitRoot(startPath, maxDepth = 2) {
+  let current = path.resolve(startPath);
+  let depth = 0;
+
+  // Verifica o próprio startPath primeiro (depth 0)
+  if (fs.existsSync(path.join(current, '.git'))) {
+    return current;
+  }
+
+  // Sobe na árvore até maxDepth níveis ACIMA do startPath
+  while (depth < maxDepth) {
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null; // Chegou na raiz do FS
+    }
+    
+    current = parent;
+    depth++;
+
+    if (fs.existsSync(path.join(current, '.git'))) {
+      return current;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Resolve o contexto de worktree para um dado caminho de projeto.
+ * Detecta se é worktree, repo principal, ou se precisa de auto-init.
+ * @param {string} projectPath - Caminho do projeto fornecido pelo agente
+ * @param {GitAdapter} gitAdapter - Instância do GitAdapter para executar comandos
+ * @returns {Promise<Object>} - WorktreeContext resolvido
+ */
+export async function resolveWorktreeContext(projectPath, gitAdapter) {
+  const absolutePath = path.resolve(projectPath);
+  
+  // Tenta encontrar .git no path ou acima (max 2 níveis)
+  // Se encontrar .git no próprio projectPath (depth 0), usa ele.
+  // Se encontrar acima, usa o pai como base.
+  let root = findGitRoot(absolutePath, 2);
+  
+  if (!root) {
+    // Caso não encontre .git em até 2 níveis: Auto-init
+    if (isProtectedPath(absolutePath)) {
+      throw new Error(`PROTECTED_PATH: não é permitido criar repositório git em ${absolutePath}`);
+    }
+    
+    // Executa git init
+    await gitAdapter._exec(absolutePath, ['init']);
+    
+    // Após init, obtém a branch (provavelmente master/main)
+    const branch = await getBranchName(absolutePath, gitAdapter);
+    
+    return {
+      repoRoot: absolutePath,
+      worktreePath: absolutePath,
+      branch: branch,
+      isWorktree: false,
+      gitCommonDir: path.join(absolutePath, '.git'),
+      autoInitialized: true
+    };
+  }
+  
+  // Se encontrou raiz (pode ser o próprio projectPath ou um pai)
+  const gitEntry = path.join(root, '.git');
+  const stats = fs.statSync(gitEntry);
+  
+  if (stats.isDirectory()) {
+    const branch = await getBranchName(root, gitAdapter);
+
+    // Req 9.2: valida que gitCommonDir contém objects/
+    if (!fs.existsSync(path.join(gitEntry, 'objects'))) {
+      throw new Error(`WORKTREE_CORRUPT: Diretório objects não encontrado em ${gitEntry}`);
+    }
+
+    return {
+      repoRoot: root,
+      worktreePath: root,
+      branch: branch,
+      isWorktree: false,
+      gitCommonDir: gitEntry
+    };
+  } else if (stats.isFile()) {
+    // Worktree
+    const content = fs.readFileSync(gitEntry, 'utf8');
+    const match = content.match(/^gitdir:\s*(.+)$/m);
+    
+    if (!match) {
+      throw new Error('WORKTREE_CORRUPT: Arquivo .git inválido ou sem formato gitdir');
+    }
+    
+    const gitdirRelative = match[1].trim();
+    const gitdirAbsolute = path.resolve(root, gitdirRelative);
+    
+    if (!fs.existsSync(gitdirAbsolute)) {
+      throw new Error(`WORKTREE_STALE: gitdir ${gitdirAbsolute} não encontrado. Execute 'git worktree prune' no repo principal.`);
+    }
+    
+    // Tenta achar commondir
+    const commondirFile = path.join(gitdirAbsolute, 'commondir');
+    let gitCommonDir;
+    
+    if (fs.existsSync(commondirFile)) {
+      const commondirRelative = fs.readFileSync(commondirFile, 'utf8').trim();
+      gitCommonDir = path.resolve(gitdirAbsolute, commondirRelative);
+    } else {
+      gitCommonDir = gitdirAbsolute;
+    }
+    
+    // Valida objects
+    if (!fs.existsSync(path.join(gitCommonDir, 'objects'))) {
+      throw new Error(`WORKTREE_CORRUPT: Diretório objects não encontrado em ${gitCommonDir}`);
+    }
+    
+    const repoRoot = path.dirname(gitCommonDir);
+    const branch = await getBranchName(root, gitAdapter);
+    
+    return {
+      repoRoot: repoRoot,
+      worktreePath: root,
+      branch: branch,
+      isWorktree: true,
+      gitCommonDir: gitCommonDir
+    };
+  }
+  
+  throw new Error('NOT_A_GIT_REPO: .git entry is neither file nor directory');
+}
+
+/**
+ * Helper para obter o nome da branch atual
+ */
+async function getBranchName(cwd, gitAdapter) {
+  try {
+    const result = await gitAdapter._exec(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    return result.trim();
+  } catch (error) {
+    // Em repo recém inicializado sem commits, pode falhar ou retornar HEAD.
+    // Mas git init cria branch default.
+    return 'HEAD'; 
+  }
+}