feat: add MCP

Author: NicolasIRAGNE

app/actions/mcps.yaml

@@ -39,3 +39,8 @@ mcps:
   config:
     type: http
     url: https://mcp.exa.ai/mcp?exa_api_key=${EXA_API_KEY}
+- display_name: GitRules
+  slug: GitRules
+  config:
+    type: http
+    url: https://gitrules.com/mcp

app/main.py

@@ -6,6 +6,7 @@
 from app.routes import install, actions
 from app.services.actions_loader import actions_loader
 from api_analytics.fastapi import Analytics
+from fastapi_mcp import FastApiMCP
 import os
 from dotenv import load_dotenv
 
@@ -28,12 +29,12 @@
 app.include_router(install.router)
 app.include_router(actions.router)
 
-@app.get("/favicon.ico")
+@app.get("/favicon.ico", operation_id="get_favicon")
 async def favicon():
     favicon_path = static_dir / "favicon.ico"
     return FileResponse(favicon_path, media_type="image/x-icon")
 
-@app.get("/", response_class=HTMLResponse)
+@app.get("/", response_class=HTMLResponse, operation_id="get_index_page")
 async def index(request: Request):
     # Get all actions data for server-side rendering
     agents = [agent.dict() for agent in actions_loader.get_agents()]
@@ -84,6 +85,16 @@ async def index(request: Request):
         }
     )
 
-@app.get("/health")
+@app.get("/health", operation_id="health_check")
 async def health_check():
-    return {"status": "healthy"}
+    return {"status": "healthy"}
+
+# Create MCP server that only exposes endpoints tagged with "mcp"
+mcp = FastApiMCP(
+    app,
+    name="gitrules-search",
+    include_tags=["mcp"]
+)
+
+# Mount the MCP server with HTTP/SSE transport
+mcp.mount_http(mount_path="/mcp")

app/routes/actions.py

@@ -1,13 +1,14 @@
-from fastapi import APIRouter, HTTPException, Body
+from fastapi import APIRouter, HTTPException, Body, Query
 from app.models.actions import ActionsResponse, Agent, Rule, MCP
 from app.services.actions_loader import actions_loader
 from app.services.mcp_installer import get_agent_content, get_rule_content, create_mcp_config
-from typing import List, Dict, Any
+from app.services.search_service import search_service
+from typing import List, Dict, Any, Optional
 import json
 
-router = APIRouter(prefix="/api/actions", tags=["actions"])
+router = APIRouter(prefix="/api", tags=["actions"])
 
-@router.get("/", response_model=ActionsResponse)
+@router.get("/actions", response_model=ActionsResponse, operation_id="get_all_actions_endpoint")
 async def get_all_actions():
     """Get all available actions (agents, rules, MCPs)"""
     return ActionsResponse(
@@ -16,80 +17,52 @@ async def get_all_actions():
         mcps=actions_loader.get_mcps()
     )
 
-@router.get("/agents", response_model=List[Agent])
+@router.get("/agents", operation_id="get_agents_endpoint")
 async def get_agents():
-    """Get all available agents"""
-    return actions_loader.get_agents()
+    """Get all available agents with tags only"""
+    agents = actions_loader.get_agents()
+    return [
+        {
+            "name": agent.name,
+            "display_name": agent.display_name,
+            "slug": agent.slug,
+            "tags": agent.tags,
+            "filename": agent.filename
+        }
+        for agent in agents
+    ]
 
-@router.get("/rules", response_model=List[Rule])
+@router.get("/rules", operation_id="get_rules_endpoint")
 async def get_rules():
-    """Get all available rules"""
-    return actions_loader.get_rules()
+    """Get all available rules with tags only"""
+    rules = actions_loader.get_rules()
+    return [
+        {
+            "name": rule.name,
+            "display_name": rule.display_name,
+            "slug": rule.slug,
+            "tags": rule.tags,
+            "filename": rule.filename
+        }
+        for rule in rules
+    ]
 
-@router.get("/mcps", response_model=List[MCP])
+@router.get("/mcps", operation_id="get_mcps_endpoint")
 async def get_mcps():
-    """Get all available MCPs"""
-    return actions_loader.get_mcps()
+    """Get all available MCPs with tags only"""
+    mcps = actions_loader.get_mcps()
+    return [
+        {
+            "name": mcp.name,
+            "tags": mcp.tags if hasattr(mcp, 'tags') else []
+        }
+        for mcp in mcps
+    ]
 
-@router.get("/agent-content/{agent_id}")
-async def get_agent_content_endpoint(agent_id: str):
-    """Get agent content for virtual workspace"""
-    agents = actions_loader.get_agents()
-    # Match by slug first, fallback to name for backward compat
-    agent = next((a for a in agents if (a.slug == agent_id or a.name == agent_id)), None)
-    
-    if not agent:
-        raise HTTPException(status_code=404, detail=f"Agent not found: {agent_id}")
-    
-    # Get content directly from the agent object (already loaded from consolidated file)
-    content = agent.content
-    if not content:
-        raise HTTPException(status_code=500, detail="Agent has no content")
-    
-    return {
-        "filename": agent.filename,
-        "content": content,
-        "path": f".claude/agents/{agent.filename}"
-    }
 
-@router.get("/rule-content/{rule_id}")
-async def get_rule_content_endpoint(rule_id: str):
-    """Get rule content to append to CLAUDE.md"""
-    rules = actions_loader.get_rules()
-    # Match by slug first, fallback to name for backward compat
-    rule = next((r for r in rules if (r.slug == rule_id or r.name == rule_id)), None)
-    
-    if not rule:
-        raise HTTPException(status_code=404, detail=f"Rule not found: {rule_id}")
-    
-    # Get content directly from the rule object (already loaded from consolidated file)
-    content = rule.content
-    if not content:
-        raise HTTPException(status_code=500, detail="Rule has no content")
-    
-    return {
-        "content": content.strip()
-    }
 
-@router.post("/mcp-config/{mcp_name}")
-async def get_mcp_config_endpoint(mcp_name: str, current_config: Dict[str, Any] = Body(default={})):
-    """Get updated MCP config for virtual workspace"""
-    mcps = actions_loader.get_mcps()
-    mcp = next((m for m in mcps if m.name == mcp_name), None)
-    
-    if not mcp:
-        raise HTTPException(status_code=404, detail="MCP not found")
-    
-    updated_config, was_removed = create_mcp_config(current_config, mcp.name, mcp.config)
-    
-    return {
-        "filename": ".mcp.json",
-        "content": updated_config,
-        "path": ".mcp.json",
-        "was_removed": was_removed
-    }
 
-@router.get("/merged-block")
+@router.get("/merged-block", operation_id="get_merged_actions_block_endpoint")
 async def get_merged_actions_block():
     """Get all actions merged into a single block with metadata for frontend"""
     agents = actions_loader.get_agents()
@@ -125,4 +98,132 @@ async def get_merged_actions_block():
         ]
     }
 
-    return merged
+    return merged
+
+@router.get("/search/agents", tags=["mcp"], operation_id="search_agents_endpoint")
+async def search_agents(
+    query: str = Query(..., description="Search query"),
+    limit: int = Query(10, ge=1, le=100, description="Maximum number of results")
+):
+    """Search for agents by name, display_name, or content"""
+    results = search_service.search_agents(query, limit)
+    return {"results": results}
+
+@router.get("/search/rules", tags=["mcp"], operation_id="search_rules_endpoint")
+async def search_rules(
+    query: str = Query(..., description="Search query"),
+    limit: int = Query(10, ge=1, le=100, description="Maximum number of results")
+):
+    """Search for rules by name, display_name, content, tags, or author"""
+    results = search_service.search_rules(query, limit)
+    return {"results": results}
+
+@router.get("/search/mcps", tags=["mcp"], operation_id="search_mcps_endpoint")
+async def search_mcps(
+    query: str = Query(..., description="Search query"),
+    limit: int = Query(10, ge=1, le=100, description="Maximum number of results")
+):
+    """Search for MCPs by name or config content"""
+    results = search_service.search_mcps(query, limit)
+    return {"results": results}
+
+@router.get("/search", tags=["mcp"], operation_id="search_all_endpoint")
+async def search_all(
+    query: str = Query(..., description="Search query"),
+    limit: int = Query(10, ge=1, le=100, description="Maximum number of results per category")
+):
+    """Search across all types (agents, rules, MCPs)"""
+    return search_service.search_all(query, limit)
+
+@router.get("/rules/{rule_ids}", tags=["mcp"], operation_id="get_multiple_rules_content")
+async def get_multiple_rules_content(rule_ids: str):
+    """Get content for multiple rules by comma-separated IDs/slugs"""
+    ids = [id.strip() for id in rule_ids.split(',') if id.strip()]
+    
+    if not ids:
+        raise HTTPException(status_code=400, detail="No rule IDs provided")
+    
+    rules = actions_loader.get_rules()
+    results = []
+    
+    for rule_id in ids:
+        # Match by slug first, fallback to name for backward compat
+        rule = next((r for r in rules if (r.slug == rule_id or r.name == rule_id)), None)
+        
+        if rule:
+            results.append({
+                "id": rule_id,
+                "slug": rule.slug,
+                "name": rule.name,
+                "display_name": rule.display_name,
+                "content": rule.content,
+                "filename": rule.filename
+            })
+        else:
+            results.append({
+                "id": rule_id,
+                "error": f"Rule not found: {rule_id}"
+            })
+    
+    return {"rules": results}
+
+@router.get("/agents/{agent_ids}", tags=["mcp"], operation_id="get_multiple_agents_content")
+async def get_multiple_agents_content(agent_ids: str):
+    """Get content for multiple agents by comma-separated IDs/slugs"""
+    ids = [id.strip() for id in agent_ids.split(',') if id.strip()]
+    
+    if not ids:
+        raise HTTPException(status_code=400, detail="No agent IDs provided")
+    
+    agents = actions_loader.get_agents()
+    results = []
+    
+    for agent_id in ids:
+        # Match by slug first, fallback to name for backward compat
+        agent = next((a for a in agents if (a.slug == agent_id or a.name == agent_id)), None)
+        
+        if agent:
+            results.append({
+                "id": agent_id,
+                "slug": agent.slug,
+                "name": agent.name,
+                "display_name": agent.display_name,
+                "content": agent.content,
+                "filename": agent.filename
+            })
+        else:
+            results.append({
+                "id": agent_id,
+                "error": f"Agent not found: {agent_id}"
+            })
+    
+    return {"agents": results}
+
+@router.get("/mcps/{mcp_ids}", tags=["mcp"], operation_id="get_multiple_mcps_config")
+async def get_multiple_mcps_config(mcp_ids: str):
+    """Get config for multiple MCPs by comma-separated names"""
+    ids = [id.strip() for id in mcp_ids.split(',') if id.strip()]
+    
+    if not ids:
+        raise HTTPException(status_code=400, detail="No MCP IDs provided")
+    
+    mcps = actions_loader.get_mcps()
+    results = []
+    
+    for mcp_id in ids:
+        # Match by name
+        mcp = next((m for m in mcps if m.name == mcp_id), None)
+        
+        if mcp:
+            results.append({
+                "id": mcp_id,
+                "name": mcp.name,
+                "config": mcp.config
+            })
+        else:
+            results.append({
+                "id": mcp_id,
+                "error": f"MCP not found: {mcp_id}"
+            })
+    
+    return {"mcps": results}

app/routes/install.py

@@ -25,7 +25,7 @@ def extract_env_vars_from_files(files: Dict[str, str]) -> Set[str]:
         env_vars.update(matches)
     return env_vars
 
-@router.post("/api/install")
+@router.post("/api/install", operation_id="create_install_script")
 async def create_install(request: Request, install: InstallCreate):
     """Generate install script from files and store by hash"""
     # Extract unique directories
@@ -53,7 +53,7 @@ async def create_install(request: Request, install: InstallCreate):
 
     return {"hash": content_hash}
 
-@router.get("/api/install/{hash_id}.sh", response_class=PlainTextResponse)
+@router.get("/api/install/{hash_id}.sh", response_class=PlainTextResponse, operation_id="get_install_script")
 async def get_install(hash_id: str):
     """Retrieve install by hash"""
     if hash_id not in installs_store: