lmiranda
d5e521a759
The MCP server runs with cwd set to the plugin directory, not the user's project directory. This caused git remote auto-detection to fail because it was looking at the wrong directory. Changes: - Added _find_project_directory() method with multiple strategies: 1. CLAUDE_PROJECT_DIR environment variable 2. PWD environment variable (if it has .git or .env) 3. Current working directory (if it has .git or .env) - Updated _detect_repo_from_git() to accept project_dir parameter - Added 3 new tests for project directory detection Fixes #70 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
228 lines
7.7 KiB
Python
228 lines
7.7 KiB
Python
"""
|
|
Configuration loader for Gitea MCP Server.
|
|
|
|
Implements hybrid configuration system:
|
|
- System-level: ~/.config/claude/gitea.env (credentials)
|
|
- Project-level: .env (repository specification)
|
|
- Auto-detection: Falls back to git remote URL parsing
|
|
"""
|
|
from pathlib import Path
|
|
from dotenv import load_dotenv
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import logging
|
|
from typing import Dict, Optional
|
|
|
|
logging.basicConfig(level=logging.INFO)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class GiteaConfig:
|
|
"""Hybrid configuration loader with mode detection"""
|
|
|
|
def __init__(self):
|
|
self.api_url: Optional[str] = None
|
|
self.api_token: Optional[str] = None
|
|
self.repo: Optional[str] = None
|
|
self.mode: str = 'project'
|
|
|
|
def load(self) -> Dict[str, Optional[str]]:
|
|
"""
|
|
Load configuration from system and project levels.
|
|
Project-level configuration overrides system-level.
|
|
|
|
Returns:
|
|
Dict containing api_url, api_token, repo, mode
|
|
|
|
Raises:
|
|
FileNotFoundError: If system config is missing
|
|
ValueError: If required configuration is missing
|
|
"""
|
|
# Load system config
|
|
system_config = Path.home() / '.config' / 'claude' / 'gitea.env'
|
|
if system_config.exists():
|
|
load_dotenv(system_config)
|
|
logger.info(f"Loaded system configuration from {system_config}")
|
|
else:
|
|
raise FileNotFoundError(
|
|
f"System config not found: {system_config}\n"
|
|
"Create it with: mkdir -p ~/.config/claude && "
|
|
"cat > ~/.config/claude/gitea.env"
|
|
)
|
|
|
|
# Find project directory (MCP server cwd is plugin dir, not project dir)
|
|
project_dir = self._find_project_directory()
|
|
|
|
# Load project config (overrides system)
|
|
if project_dir:
|
|
project_config = project_dir / '.env'
|
|
if project_config.exists():
|
|
load_dotenv(project_config, override=True)
|
|
logger.info(f"Loaded project configuration from {project_config}")
|
|
|
|
# Extract values
|
|
self.api_url = os.getenv('GITEA_API_URL')
|
|
self.api_token = os.getenv('GITEA_API_TOKEN')
|
|
self.repo = os.getenv('GITEA_REPO') # Optional, must be owner/repo format
|
|
|
|
# Auto-detect repo from git remote if not specified
|
|
if not self.repo and project_dir:
|
|
self.repo = self._detect_repo_from_git(project_dir)
|
|
if self.repo:
|
|
logger.info(f"Auto-detected repository from git remote: {self.repo}")
|
|
|
|
# Detect mode
|
|
if self.repo:
|
|
self.mode = 'project'
|
|
logger.info(f"Running in project mode: {self.repo}")
|
|
else:
|
|
self.mode = 'company'
|
|
logger.info("Running in company-wide mode (PMO)")
|
|
|
|
# Validate required variables
|
|
self._validate()
|
|
|
|
return {
|
|
'api_url': self.api_url,
|
|
'api_token': self.api_token,
|
|
'repo': self.repo,
|
|
'mode': self.mode
|
|
}
|
|
|
|
def _validate(self) -> None:
|
|
"""
|
|
Validate that required configuration is present.
|
|
|
|
Raises:
|
|
ValueError: If required configuration is missing
|
|
"""
|
|
required = {
|
|
'GITEA_API_URL': self.api_url,
|
|
'GITEA_API_TOKEN': self.api_token
|
|
}
|
|
|
|
missing = [key for key, value in required.items() if not value]
|
|
|
|
if missing:
|
|
raise ValueError(
|
|
f"Missing required configuration: {', '.join(missing)}\n"
|
|
"Check your ~/.config/claude/gitea.env file"
|
|
)
|
|
|
|
def _find_project_directory(self) -> Optional[Path]:
|
|
"""
|
|
Find the user's project directory.
|
|
|
|
The MCP server runs with cwd set to the plugin directory, not the
|
|
user's project. We need to find the actual project directory using
|
|
various heuristics.
|
|
|
|
Returns:
|
|
Path to project directory, or None if not found
|
|
"""
|
|
# Strategy 1: Check CLAUDE_PROJECT_DIR environment variable
|
|
project_dir = os.getenv('CLAUDE_PROJECT_DIR')
|
|
if project_dir:
|
|
path = Path(project_dir)
|
|
if path.exists():
|
|
logger.info(f"Found project directory from CLAUDE_PROJECT_DIR: {path}")
|
|
return path
|
|
|
|
# Strategy 2: Check PWD (original working directory before cwd override)
|
|
pwd = os.getenv('PWD')
|
|
if pwd:
|
|
path = Path(pwd)
|
|
# Verify it has .git or .env (indicates a project)
|
|
if path.exists() and ((path / '.git').exists() or (path / '.env').exists()):
|
|
logger.info(f"Found project directory from PWD: {path}")
|
|
return path
|
|
|
|
# Strategy 3: Check current working directory
|
|
# This handles test scenarios and cases where cwd is actually the project
|
|
cwd = Path.cwd()
|
|
if (cwd / '.git').exists() or (cwd / '.env').exists():
|
|
logger.info(f"Found project directory from cwd: {cwd}")
|
|
return cwd
|
|
|
|
# Strategy 4: Check if GITEA_REPO is already set (user configured it)
|
|
# If so, we don't need to find the project directory for git detection
|
|
if os.getenv('GITEA_REPO'):
|
|
logger.debug("GITEA_REPO already set, skipping project directory detection")
|
|
return None
|
|
|
|
logger.debug("Could not determine project directory")
|
|
return None
|
|
|
|
def _detect_repo_from_git(self, project_dir: Optional[Path] = None) -> Optional[str]:
|
|
"""
|
|
Auto-detect repository from git remote origin URL.
|
|
|
|
Args:
|
|
project_dir: Directory to run git command from (defaults to cwd)
|
|
|
|
Supports URL formats:
|
|
- SSH: ssh://git@host:port/owner/repo.git
|
|
- SSH short: git@host:owner/repo.git
|
|
- HTTPS: https://host/owner/repo.git
|
|
- HTTP: http://host/owner/repo.git
|
|
|
|
Returns:
|
|
Repository in 'owner/repo' format, or None if detection fails
|
|
"""
|
|
try:
|
|
result = subprocess.run(
|
|
['git', 'remote', 'get-url', 'origin'],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=5,
|
|
cwd=str(project_dir) if project_dir else None
|
|
)
|
|
if result.returncode != 0:
|
|
logger.debug("No git remote 'origin' found")
|
|
return None
|
|
|
|
url = result.stdout.strip()
|
|
return self._parse_git_url(url)
|
|
|
|
except subprocess.TimeoutExpired:
|
|
logger.warning("Git command timed out")
|
|
return None
|
|
except FileNotFoundError:
|
|
logger.debug("Git not available")
|
|
return None
|
|
except Exception as e:
|
|
logger.debug(f"Failed to detect repo from git: {e}")
|
|
return None
|
|
|
|
def _parse_git_url(self, url: str) -> Optional[str]:
|
|
"""
|
|
Parse git URL to extract owner/repo.
|
|
|
|
Args:
|
|
url: Git remote URL
|
|
|
|
Returns:
|
|
Repository in 'owner/repo' format, or None if parsing fails
|
|
"""
|
|
# Remove .git suffix if present
|
|
url = re.sub(r'\.git$', '', url)
|
|
|
|
# SSH format: ssh://git@host:port/owner/repo
|
|
ssh_match = re.match(r'ssh://[^/]+/(.+/.+)$', url)
|
|
if ssh_match:
|
|
return ssh_match.group(1)
|
|
|
|
# SSH short format: git@host:owner/repo
|
|
ssh_short_match = re.match(r'git@[^:]+:(.+/.+)$', url)
|
|
if ssh_short_match:
|
|
return ssh_short_match.group(1)
|
|
|
|
# HTTPS/HTTP format: https://host/owner/repo
|
|
http_match = re.match(r'https?://[^/]+/(.+/.+)$', url)
|
|
if http_match:
|
|
return http_match.group(1)
|
|
|
|
logger.warning(f"Could not parse git URL: {url}")
|
|
return None
|