feat: v3.0.0 architecture overhaul

- Rename marketplace to lm-claude-plugins
- Move MCP servers to root with symlinks
- Add 6 PR tools to Gitea MCP (list_pull_requests, get_pull_request,
  get_pr_diff, get_pr_comments, create_pr_review, add_pr_comment)
- Add clarity-assist plugin (prompt optimization with ND accommodations)
- Add git-flow plugin (workflow automation)
- Add pr-review plugin (multi-agent review with confidence scoring)
- Centralize configuration docs
- Update all documentation for v3.0.0

BREAKING CHANGE: MCP server paths changed, marketplace renamed

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

mcp-servers/gitea/mcp_server/tools/__init__.py

@@ -0,0 +1,11 @@
+"""
+MCP tools for Gitea integration.
+
+This package provides MCP tool implementations for:
+- Issue operations (issues.py)
+- Label management (labels.py)
+- Wiki operations (wiki.py)
+- Milestone management (milestones.py)
+- Issue dependencies (dependencies.py)
+- Pull request operations (pull_requests.py)
+"""

mcp-servers/gitea/mcp_server/tools/dependencies.py

@@ -0,0 +1,216 @@
+"""
+Issue dependency management tools for MCP server.
+
+Provides async wrappers for issue dependency operations:
+- List/create/remove dependencies
+- Build dependency graphs for parallel execution
+"""
+import asyncio
+import logging
+from typing import List, Dict, Optional, Set, Tuple
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DependencyTools:
+    """Async wrappers for Gitea issue dependency operations"""
+
+    def __init__(self, gitea_client):
+        """
+        Initialize dependency tools.
+
+        Args:
+            gitea_client: GiteaClient instance
+        """
+        self.gitea = gitea_client
+
+    async def list_issue_dependencies(
+        self,
+        issue_number: int,
+        repo: Optional[str] = None
+    ) -> List[Dict]:
+        """
+        List all dependencies for an issue (issues that block this one).
+
+        Args:
+            issue_number: Issue number
+            repo: Repository in owner/repo format
+
+        Returns:
+            List of issues that this issue depends on
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.list_issue_dependencies(issue_number, repo)
+        )
+
+    async def create_issue_dependency(
+        self,
+        issue_number: int,
+        depends_on: int,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Create a dependency between issues.
+
+        Args:
+            issue_number: The issue that will depend on another
+            depends_on: The issue that blocks issue_number
+            repo: Repository in owner/repo format
+
+        Returns:
+            Created dependency information
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.create_issue_dependency(issue_number, depends_on, repo)
+        )
+
+    async def remove_issue_dependency(
+        self,
+        issue_number: int,
+        depends_on: int,
+        repo: Optional[str] = None
+    ) -> bool:
+        """
+        Remove a dependency between issues.
+
+        Args:
+            issue_number: The issue that currently depends on another
+            depends_on: The issue being depended on
+            repo: Repository in owner/repo format
+
+        Returns:
+            True if removed successfully
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.remove_issue_dependency(issue_number, depends_on, repo)
+        )
+
+    async def list_issue_blocks(
+        self,
+        issue_number: int,
+        repo: Optional[str] = None
+    ) -> List[Dict]:
+        """
+        List all issues that this issue blocks.
+
+        Args:
+            issue_number: Issue number
+            repo: Repository in owner/repo format
+
+        Returns:
+            List of issues blocked by this issue
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.list_issue_blocks(issue_number, repo)
+        )
+
+    async def build_dependency_graph(
+        self,
+        issue_numbers: List[int],
+        repo: Optional[str] = None
+    ) -> Dict[int, List[int]]:
+        """
+        Build a dependency graph for a list of issues.
+
+        Args:
+            issue_numbers: List of issue numbers to analyze
+            repo: Repository in owner/repo format
+
+        Returns:
+            Dictionary mapping issue_number -> list of issues it depends on
+        """
+        graph = {}
+        for issue_num in issue_numbers:
+            try:
+                deps = await self.list_issue_dependencies(issue_num, repo)
+                graph[issue_num] = [
+                    d.get('number') or d.get('index')
+                    for d in deps
+                    if (d.get('number') or d.get('index')) in issue_numbers
+                ]
+            except Exception as e:
+                logger.warning(f"Could not fetch dependencies for #{issue_num}: {e}")
+                graph[issue_num] = []
+        return graph
+
+    async def get_ready_tasks(
+        self,
+        issue_numbers: List[int],
+        completed: Set[int],
+        repo: Optional[str] = None
+    ) -> List[int]:
+        """
+        Get tasks that are ready to execute (no unresolved dependencies).
+
+        Args:
+            issue_numbers: List of all issue numbers in sprint
+            completed: Set of already completed issue numbers
+            repo: Repository in owner/repo format
+
+        Returns:
+            List of issue numbers that can be executed now
+        """
+        graph = await self.build_dependency_graph(issue_numbers, repo)
+        ready = []
+
+        for issue_num in issue_numbers:
+            if issue_num in completed:
+                continue
+
+            deps = graph.get(issue_num, [])
+            # Task is ready if all its dependencies are completed
+            if all(dep in completed for dep in deps):
+                ready.append(issue_num)
+
+        return ready
+
+    async def get_execution_order(
+        self,
+        issue_numbers: List[int],
+        repo: Optional[str] = None
+    ) -> List[List[int]]:
+        """
+        Get a parallelizable execution order for issues.
+
+        Returns batches of issues that can be executed in parallel.
+        Each batch contains issues with no unresolved dependencies.
+
+        Args:
+            issue_numbers: List of all issue numbers
+            repo: Repository in owner/repo format
+
+        Returns:
+            List of batches, where each batch can be executed in parallel
+        """
+        graph = await self.build_dependency_graph(issue_numbers, repo)
+        completed: Set[int] = set()
+        remaining = set(issue_numbers)
+        batches = []
+
+        while remaining:
+            # Find all tasks with no unresolved dependencies
+            batch = []
+            for issue_num in remaining:
+                deps = graph.get(issue_num, [])
+                if all(dep in completed for dep in deps):
+                    batch.append(issue_num)
+
+            if not batch:
+                # Circular dependency detected
+                logger.error(f"Circular dependency detected! Remaining: {remaining}")
+                batch = list(remaining)  # Force include remaining to avoid infinite loop
+
+            batches.append(batch)
+            completed.update(batch)
+            remaining -= set(batch)
+
+        return batches

mcp-servers/gitea/mcp_server/tools/issues.py

@@ -0,0 +1,261 @@
+"""
+Issue management tools for MCP server.
+
+Provides async wrappers for issue CRUD operations with:
+- Branch-aware security
+- PMO multi-repo support
+- Comprehensive error handling
+"""
+import asyncio
+import subprocess
+import logging
+from typing import List, Dict, Optional
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class IssueTools:
+    """Async wrappers for Gitea issue operations with branch detection"""
+
+    def __init__(self, gitea_client):
+        """
+        Initialize issue tools.
+
+        Args:
+            gitea_client: GiteaClient instance
+        """
+        self.gitea = gitea_client
+
+    def _get_current_branch(self) -> str:
+        """
+        Get current git branch.
+
+        Returns:
+            Current branch name or 'unknown' if not in a git repo
+        """
+        try:
+            result = subprocess.run(
+                ['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return result.stdout.strip()
+        except subprocess.CalledProcessError:
+            return "unknown"
+
+    def _check_branch_permissions(self, operation: str) -> bool:
+        """
+        Check if operation is allowed on current branch.
+
+        Args:
+            operation: Operation name (list_issues, create_issue, etc.)
+
+        Returns:
+            True if operation is allowed, False otherwise
+        """
+        branch = self._get_current_branch()
+
+        # Production branches (read-only except incidents)
+        if branch in ['main', 'master'] or branch.startswith('prod/'):
+            return operation in ['list_issues', 'get_issue', 'get_labels']
+
+        # Staging branches (read-only for code)
+        if branch == 'staging' or branch.startswith('stage/'):
+            return operation in ['list_issues', 'get_issue', 'get_labels', 'create_issue']
+
+        # Development branches (full access)
+        if branch in ['development', 'develop'] or branch.startswith(('feat/', 'feature/', 'dev/')):
+            return True
+
+        # Unknown branch - be restrictive
+        return False
+
+    async def list_issues(
+        self,
+        state: str = 'open',
+        labels: Optional[List[str]] = None,
+        repo: Optional[str] = None
+    ) -> List[Dict]:
+        """
+        List issues from repository (async wrapper).
+
+        Args:
+            state: Issue state (open, closed, all)
+            labels: Filter by labels
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            List of issue dictionaries
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('list_issues'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot list issues on branch '{branch}'. "
+                f"Switch to a development branch."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.list_issues(state, labels, repo)
+        )
+
+    async def get_issue(
+        self,
+        issue_number: int,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Get specific issue details (async wrapper).
+
+        Args:
+            issue_number: Issue number
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            Issue dictionary
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('get_issue'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot get issue on branch '{branch}'. "
+                f"Switch to a development branch."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.get_issue(issue_number, repo)
+        )
+
+    async def create_issue(
+        self,
+        title: str,
+        body: str,
+        labels: Optional[List[str]] = None,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Create new issue (async wrapper with branch check).
+
+        Args:
+            title: Issue title
+            body: Issue description
+            labels: List of label names
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            Created issue dictionary
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('create_issue'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot create issues on branch '{branch}'. "
+                f"Switch to a development branch to create issues."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.create_issue(title, body, labels, repo)
+        )
+
+    async def update_issue(
+        self,
+        issue_number: int,
+        title: Optional[str] = None,
+        body: Optional[str] = None,
+        state: Optional[str] = None,
+        labels: Optional[List[str]] = None,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Update existing issue (async wrapper with branch check).
+
+        Args:
+            issue_number: Issue number
+            title: New title (optional)
+            body: New body (optional)
+            state: New state - 'open' or 'closed' (optional)
+            labels: New labels (optional)
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            Updated issue dictionary
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('update_issue'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot update issues on branch '{branch}'. "
+                f"Switch to a development branch to update issues."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.update_issue(issue_number, title, body, state, labels, repo)
+        )
+
+    async def add_comment(
+        self,
+        issue_number: int,
+        comment: str,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Add comment to issue (async wrapper with branch check).
+
+        Args:
+            issue_number: Issue number
+            comment: Comment text
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            Created comment dictionary
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('add_comment'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot add comments on branch '{branch}'. "
+                f"Switch to a development branch to add comments."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.add_comment(issue_number, comment, repo)
+        )
+
+    async def aggregate_issues(
+        self,
+        org: str,
+        state: str = 'open',
+        labels: Optional[List[str]] = None
+    ) -> Dict[str, List[Dict]]:
+        """Aggregate issues across all repositories in org."""
+        if not self._check_branch_permissions('aggregate_issues'):
+            branch = self._get_current_branch()
+            raise PermissionError(f"Cannot aggregate issues on branch '{branch}'.")
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.aggregate_issues(org, state, labels)
+        )

mcp-servers/gitea/mcp_server/tools/labels.py

@@ -0,0 +1,158 @@
+"""
+Label management tools for MCP server.
+
+Provides async wrappers for label operations with:
+- Label taxonomy retrieval
+- Intelligent label suggestion
+- Dynamic label detection
+"""
+import asyncio
+import logging
+from typing import List, Dict, Optional
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class LabelTools:
+    """Async wrappers for Gitea label operations"""
+
+    def __init__(self, gitea_client):
+        """
+        Initialize label tools.
+
+        Args:
+            gitea_client: GiteaClient instance
+        """
+        self.gitea = gitea_client
+
+    async def get_labels(self, repo: Optional[str] = None) -> Dict[str, List[Dict]]:
+        """Get all labels (org + repo). Repo must be 'owner/repo' format."""
+        loop = asyncio.get_event_loop()
+
+        target_repo = repo or self.gitea.repo
+        if not target_repo or '/' not in target_repo:
+            raise ValueError("Use 'owner/repo' format (e.g. 'org/repo-name')")
+
+        org = target_repo.split('/')[0]
+
+        org_labels = await loop.run_in_executor(
+            None,
+            lambda: self.gitea.get_org_labels(org)
+        )
+
+        repo_labels = await loop.run_in_executor(
+            None,
+            lambda: self.gitea.get_labels(target_repo)
+        )
+
+        return {
+            'organization': org_labels,
+            'repository': repo_labels,
+            'total_count': len(org_labels) + len(repo_labels)
+        }
+
+    async def suggest_labels(self, context: str) -> List[str]:
+        """
+        Analyze context and suggest appropriate labels.
+
+        Args:
+            context: Issue title + description or sprint context
+
+        Returns:
+            List of suggested label names
+        """
+        suggested = []
+        context_lower = context.lower()
+
+        # Type detection (exclusive - only one)
+        if any(word in context_lower for word in ['bug', 'error', 'fix', 'broken', 'crash', 'fail']):
+            suggested.append('Type/Bug')
+        elif any(word in context_lower for word in ['refactor', 'extract', 'restructure', 'architecture', 'service extraction']):
+            suggested.append('Type/Refactor')
+        elif any(word in context_lower for word in ['feature', 'add', 'implement', 'new', 'create']):
+            suggested.append('Type/Feature')
+        elif any(word in context_lower for word in ['docs', 'documentation', 'readme', 'guide']):
+            suggested.append('Type/Documentation')
+        elif any(word in context_lower for word in ['test', 'testing', 'spec', 'coverage']):
+            suggested.append('Type/Test')
+        elif any(word in context_lower for word in ['chore', 'maintenance', 'update', 'upgrade']):
+            suggested.append('Type/Chore')
+
+        # Priority detection
+        if any(word in context_lower for word in ['critical', 'urgent', 'blocker', 'blocking', 'emergency']):
+            suggested.append('Priority/Critical')
+        elif any(word in context_lower for word in ['high', 'important', 'asap', 'soon']):
+            suggested.append('Priority/High')
+        elif any(word in context_lower for word in ['low', 'nice-to-have', 'optional', 'later']):
+            suggested.append('Priority/Low')
+        else:
+            suggested.append('Priority/Medium')
+
+        # Complexity detection
+        if any(word in context_lower for word in ['simple', 'trivial', 'easy', 'quick']):
+            suggested.append('Complexity/Simple')
+        elif any(word in context_lower for word in ['complex', 'difficult', 'challenging', 'intricate']):
+            suggested.append('Complexity/Complex')
+        else:
+            suggested.append('Complexity/Medium')
+
+        # Efforts detection
+        if any(word in context_lower for word in ['xs', 'tiny', '1 hour', '2 hours']):
+            suggested.append('Efforts/XS')
+        elif any(word in context_lower for word in ['small', 's ', '1 day', 'half day']):
+            suggested.append('Efforts/S')
+        elif any(word in context_lower for word in ['medium', 'm ', '2 days', '3 days']):
+            suggested.append('Efforts/M')
+        elif any(word in context_lower for word in ['large', 'l ', '1 week', '5 days']):
+            suggested.append('Efforts/L')
+        elif any(word in context_lower for word in ['xl', 'extra large', '2 weeks', 'sprint']):
+            suggested.append('Efforts/XL')
+
+        # Component detection (based on keywords)
+        component_keywords = {
+            'Component/Backend': ['backend', 'server', 'api', 'database', 'service'],
+            'Component/Frontend': ['frontend', 'ui', 'interface', 'react', 'vue', 'component'],
+            'Component/API': ['api', 'endpoint', 'rest', 'graphql', 'route'],
+            'Component/Database': ['database', 'db', 'sql', 'migration', 'schema', 'postgres'],
+            'Component/Auth': ['auth', 'authentication', 'login', 'oauth', 'token', 'session'],
+            'Component/Deploy': ['deploy', 'deployment', 'docker', 'kubernetes', 'ci/cd'],
+            'Component/Testing': ['test', 'testing', 'spec', 'jest', 'pytest', 'coverage'],
+            'Component/Docs': ['docs', 'documentation', 'readme', 'guide', 'wiki']
+        }
+
+        for label, keywords in component_keywords.items():
+            if any(keyword in context_lower for keyword in keywords):
+                suggested.append(label)
+
+        # Tech stack detection
+        tech_keywords = {
+            'Tech/Python': ['python', 'fastapi', 'django', 'flask', 'pytest'],
+            'Tech/JavaScript': ['javascript', 'js', 'node', 'npm', 'yarn'],
+            'Tech/Docker': ['docker', 'dockerfile', 'container', 'compose'],
+            'Tech/PostgreSQL': ['postgres', 'postgresql', 'psql', 'sql'],
+            'Tech/Redis': ['redis', 'cache', 'session store'],
+            'Tech/Vue': ['vue', 'vuejs', 'nuxt'],
+            'Tech/FastAPI': ['fastapi', 'pydantic', 'starlette']
+        }
+
+        for label, keywords in tech_keywords.items():
+            if any(keyword in context_lower for keyword in keywords):
+                suggested.append(label)
+
+        # Source detection (based on git branch or context)
+        if 'development' in context_lower or 'dev/' in context_lower:
+            suggested.append('Source/Development')
+        elif 'staging' in context_lower or 'stage/' in context_lower:
+            suggested.append('Source/Staging')
+        elif 'production' in context_lower or 'prod' in context_lower:
+            suggested.append('Source/Production')
+
+        # Risk detection
+        if any(word in context_lower for word in ['breaking', 'breaking change', 'major', 'risky']):
+            suggested.append('Risk/High')
+        elif any(word in context_lower for word in ['safe', 'low risk', 'minor']):
+            suggested.append('Risk/Low')
+
+        logger.info(f"Suggested {len(suggested)} labels based on context")
+        return suggested

mcp-servers/gitea/mcp_server/tools/milestones.py

@@ -0,0 +1,145 @@
+"""
+Milestone management tools for MCP server.
+
+Provides async wrappers for milestone operations:
+- CRUD operations for milestones
+- Milestone-sprint relationship tracking
+"""
+import asyncio
+import logging
+from typing import List, Dict, Optional
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class MilestoneTools:
+    """Async wrappers for Gitea milestone operations"""
+
+    def __init__(self, gitea_client):
+        """
+        Initialize milestone tools.
+
+        Args:
+            gitea_client: GiteaClient instance
+        """
+        self.gitea = gitea_client
+
+    async def list_milestones(
+        self,
+        state: str = 'open',
+        repo: Optional[str] = None
+    ) -> List[Dict]:
+        """
+        List all milestones in repository.
+
+        Args:
+            state: Milestone state (open, closed, all)
+            repo: Repository in owner/repo format
+
+        Returns:
+            List of milestone dictionaries
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.list_milestones(state, repo)
+        )
+
+    async def get_milestone(
+        self,
+        milestone_id: int,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Get a specific milestone by ID.
+
+        Args:
+            milestone_id: Milestone ID
+            repo: Repository in owner/repo format
+
+        Returns:
+            Milestone dictionary
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.get_milestone(milestone_id, repo)
+        )
+
+    async def create_milestone(
+        self,
+        title: str,
+        description: Optional[str] = None,
+        due_on: Optional[str] = None,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Create a new milestone.
+
+        Args:
+            title: Milestone title (e.g., "v2.0 Release", "Sprint 17")
+            description: Milestone description
+            due_on: Due date in ISO 8601 format (e.g., "2025-02-01T00:00:00Z")
+            repo: Repository in owner/repo format
+
+        Returns:
+            Created milestone dictionary
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.create_milestone(title, description, due_on, repo)
+        )
+
+    async def update_milestone(
+        self,
+        milestone_id: int,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        state: Optional[str] = None,
+        due_on: Optional[str] = None,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Update an existing milestone.
+
+        Args:
+            milestone_id: Milestone ID
+            title: New title (optional)
+            description: New description (optional)
+            state: New state - 'open' or 'closed' (optional)
+            due_on: New due date (optional)
+            repo: Repository in owner/repo format
+
+        Returns:
+            Updated milestone dictionary
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.update_milestone(
+                milestone_id, title, description, state, due_on, repo
+            )
+        )
+
+    async def delete_milestone(
+        self,
+        milestone_id: int,
+        repo: Optional[str] = None
+    ) -> bool:
+        """
+        Delete a milestone.
+
+        Args:
+            milestone_id: Milestone ID
+            repo: Repository in owner/repo format
+
+        Returns:
+            True if deleted successfully
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.delete_milestone(milestone_id, repo)
+        )

mcp-servers/gitea/mcp_server/tools/pull_requests.py

@@ -0,0 +1,274 @@
+"""
+Pull request management tools for MCP server.
+
+Provides async wrappers for PR operations with:
+- Branch-aware security
+- PMO multi-repo support
+- Comprehensive error handling
+"""
+import asyncio
+import subprocess
+import logging
+from typing import List, Dict, Optional
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class PullRequestTools:
+    """Async wrappers for Gitea pull request operations with branch detection"""
+
+    def __init__(self, gitea_client):
+        """
+        Initialize pull request tools.
+
+        Args:
+            gitea_client: GiteaClient instance
+        """
+        self.gitea = gitea_client
+
+    def _get_current_branch(self) -> str:
+        """
+        Get current git branch.
+
+        Returns:
+            Current branch name or 'unknown' if not in a git repo
+        """
+        try:
+            result = subprocess.run(
+                ['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return result.stdout.strip()
+        except subprocess.CalledProcessError:
+            return "unknown"
+
+    def _check_branch_permissions(self, operation: str) -> bool:
+        """
+        Check if operation is allowed on current branch.
+
+        Args:
+            operation: Operation name (list_prs, create_review, etc.)
+
+        Returns:
+            True if operation is allowed, False otherwise
+        """
+        branch = self._get_current_branch()
+
+        # Read-only operations allowed everywhere
+        read_ops = ['list_pull_requests', 'get_pull_request', 'get_pr_diff', 'get_pr_comments']
+
+        # Production branches (read-only)
+        if branch in ['main', 'master'] or branch.startswith('prod/'):
+            return operation in read_ops
+
+        # Staging branches (read-only for PRs, can comment)
+        if branch == 'staging' or branch.startswith('stage/'):
+            return operation in read_ops + ['add_pr_comment']
+
+        # Development branches (full access)
+        if branch in ['development', 'develop'] or branch.startswith(('feat/', 'feature/', 'dev/')):
+            return True
+
+        # Unknown branch - be restrictive
+        return operation in read_ops
+
+    async def list_pull_requests(
+        self,
+        state: str = 'open',
+        sort: str = 'recentupdate',
+        labels: Optional[List[str]] = None,
+        repo: Optional[str] = None
+    ) -> List[Dict]:
+        """
+        List pull requests from repository (async wrapper).
+
+        Args:
+            state: PR state (open, closed, all)
+            sort: Sort order
+            labels: Filter by labels
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            List of pull request dictionaries
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('list_pull_requests'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot list PRs on branch '{branch}'. "
+                f"Switch to a development branch."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.list_pull_requests(state, sort, labels, repo)
+        )
+
+    async def get_pull_request(
+        self,
+        pr_number: int,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Get specific pull request details (async wrapper).
+
+        Args:
+            pr_number: Pull request number
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            Pull request dictionary
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('get_pull_request'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot get PR on branch '{branch}'. "
+                f"Switch to a development branch."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.get_pull_request(pr_number, repo)
+        )
+
+    async def get_pr_diff(
+        self,
+        pr_number: int,
+        repo: Optional[str] = None
+    ) -> str:
+        """
+        Get pull request diff (async wrapper).
+
+        Args:
+            pr_number: Pull request number
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            Diff as string
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('get_pr_diff'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot get PR diff on branch '{branch}'. "
+                f"Switch to a development branch."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.get_pr_diff(pr_number, repo)
+        )
+
+    async def get_pr_comments(
+        self,
+        pr_number: int,
+        repo: Optional[str] = None
+    ) -> List[Dict]:
+        """
+        Get comments on a pull request (async wrapper).
+
+        Args:
+            pr_number: Pull request number
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            List of comment dictionaries
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('get_pr_comments'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot get PR comments on branch '{branch}'. "
+                f"Switch to a development branch."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.get_pr_comments(pr_number, repo)
+        )
+
+    async def create_pr_review(
+        self,
+        pr_number: int,
+        body: str,
+        event: str = 'COMMENT',
+        comments: Optional[List[Dict]] = None,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Create a review on a pull request (async wrapper with branch check).
+
+        Args:
+            pr_number: Pull request number
+            body: Review body/summary
+            event: Review action (APPROVE, REQUEST_CHANGES, COMMENT)
+            comments: Optional list of inline comments
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            Created review dictionary
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('create_pr_review'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot create PR review on branch '{branch}'. "
+                f"Switch to a development branch to review PRs."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.create_pr_review(pr_number, body, event, comments, repo)
+        )
+
+    async def add_pr_comment(
+        self,
+        pr_number: int,
+        body: str,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Add a general comment to a pull request (async wrapper with branch check).
+
+        Args:
+            pr_number: Pull request number
+            body: Comment text
+            repo: Override configured repo (for PMO multi-repo)
+
+        Returns:
+            Created comment dictionary
+
+        Raises:
+            PermissionError: If operation not allowed on current branch
+        """
+        if not self._check_branch_permissions('add_pr_comment'):
+            branch = self._get_current_branch()
+            raise PermissionError(
+                f"Cannot add PR comment on branch '{branch}'. "
+                f"Switch to a development or staging branch to comment on PRs."
+            )
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.add_pr_comment(pr_number, body, repo)
+        )

mcp-servers/gitea/mcp_server/tools/wiki.py

@@ -0,0 +1,149 @@
+"""
+Wiki management tools for MCP server.
+
+Provides async wrappers for wiki operations to support lessons learned:
+- Page CRUD operations
+- Lessons learned creation and search
+"""
+import asyncio
+import logging
+from typing import List, Dict, Optional
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class WikiTools:
+    """Async wrappers for Gitea wiki operations"""
+
+    def __init__(self, gitea_client):
+        """
+        Initialize wiki tools.
+
+        Args:
+            gitea_client: GiteaClient instance
+        """
+        self.gitea = gitea_client
+
+    async def list_wiki_pages(self, repo: Optional[str] = None) -> List[Dict]:
+        """List all wiki pages in repository."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.list_wiki_pages(repo)
+        )
+
+    async def get_wiki_page(
+        self,
+        page_name: str,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """Get a specific wiki page by name."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.get_wiki_page(page_name, repo)
+        )
+
+    async def create_wiki_page(
+        self,
+        title: str,
+        content: str,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """Create a new wiki page."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.create_wiki_page(title, content, repo)
+        )
+
+    async def update_wiki_page(
+        self,
+        page_name: str,
+        content: str,
+        repo: Optional[str] = None
+    ) -> Dict:
+        """Update an existing wiki page."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.update_wiki_page(page_name, content, repo)
+        )
+
+    async def delete_wiki_page(
+        self,
+        page_name: str,
+        repo: Optional[str] = None
+    ) -> bool:
+        """Delete a wiki page."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.delete_wiki_page(page_name, repo)
+        )
+
+    async def search_wiki_pages(
+        self,
+        query: str,
+        repo: Optional[str] = None
+    ) -> List[Dict]:
+        """Search wiki pages by title."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.search_wiki_pages(query, repo)
+        )
+
+    async def create_lesson(
+        self,
+        title: str,
+        content: str,
+        tags: List[str],
+        category: str = "sprints",
+        repo: Optional[str] = None
+    ) -> Dict:
+        """
+        Create a lessons learned entry in the wiki.
+
+        Args:
+            title: Lesson title (e.g., "Sprint 16 - Prevent Infinite Loops")
+            content: Lesson content in markdown
+            tags: List of tags for categorization
+            category: Category (sprints, patterns, architecture, etc.)
+            repo: Repository in owner/repo format
+
+        Returns:
+            Created wiki page
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.gitea.create_lesson(title, content, tags, category, repo)
+        )
+
+    async def search_lessons(
+        self,
+        query: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        limit: int = 20,
+        repo: Optional[str] = None
+    ) -> List[Dict]:
+        """
+        Search lessons learned from previous sprints.
+
+        Args:
+            query: Search query (optional)
+            tags: Tags to filter by (optional)
+            limit: Maximum results (default 20)
+            repo: Repository in owner/repo format
+
+        Returns:
+            List of matching lessons
+        """
+        loop = asyncio.get_event_loop()
+        results = await loop.run_in_executor(
+            None,
+            lambda: self.gitea.search_lessons(query, tags, repo)
+        )
+        return results[:limit]