feat: upgrade search to v2 API, add 37 tests, bump to 0.4.0 (OPE-91)

- handlers: switch from /search to /search/v2, map max_results to top_k
- formatters: support v2 fields (qualified_name, signature, match_reason)
- formatters: maintain backward compat with v1 response shape
- tests: 37 tests covering config, formatters, handlers, tool schemas
- tests: verify no emoji, error message sanitization, dispatch logic
- config: bump version 0.3.0 -> 0.4.0
- requirements: add pytest, pytest-asyncio as test dependencies

Author: DevanshuNEU

mcp-server/config.py

@@ -13,4 +13,4 @@
 API_KEY = os.getenv("API_KEY", "")
 
 SERVER_NAME = "codeintel-mcp"
-SERVER_VERSION = "0.3.0"
+SERVER_VERSION = "0.4.0"

mcp-server/formatters.py

@@ -6,10 +6,15 @@
 
 
 def format_search_results(result: dict) -> str:
-    """Format semantic search results as markdown."""
-    count = result.get("count", 0)
+    """Format semantic search results as markdown.
+
+    Supports both v1 (count/results) and v2 (total/results) response shapes
+    so the formatter stays resilient across API versions.
+    """
+    total = result.get("total") or result.get("count", 0)
     cached = " (cached)" if result.get("cached") else ""
-    output = f"# Code Search Results\n\nFound {count} results{cached}\n\n"
+    version = result.get("search_version", "v1")
+    output = f"# Code Search Results ({version})\n\nFound {total} results{cached}\n\n"
 
     if not result.get("results"):
         return output + "No results found.\n"
@@ -18,17 +23,29 @@ def format_search_results(result: dict) -> str:
         score = res.get("score", 0) * 100
         name = res.get("name", "unknown")
         file_path = res.get("file_path", "unknown")
-        file_type = res.get("type", "unknown")
         lang = res.get("language", "unknown")
         line_start = res.get("line_start", 0)
         line_end = res.get("line_end", 0)
         code = res.get("code", "")
 
         output += f"## {idx}. {name} ({score:.0f}% match)\n"
         output += f"**File:** `{file_path}`\n"
-        output += f"**Type:** {file_type} | **Language:** {lang}\n"
-        output += f"**Lines:** {line_start}-{line_end}\n\n"
-        output += f"```{lang}\n{code}\n```\n\n"
+
+        # v2 adds qualified_name and signature
+        qualified = res.get("qualified_name")
+        if qualified and qualified != name:
+            output += f"**Qualified:** `{qualified}`\n"
+        signature = res.get("signature")
+        if signature:
+            output += f"**Signature:** `{signature}`\n"
+
+        output += f"**Language:** {lang} | **Lines:** {line_start}-{line_end}\n"
+
+        reason = res.get("match_reason")
+        if reason:
+            output += f"**Why:** {reason}\n"
+
+        output += f"\n```{lang}\n{code}\n```\n\n"
 
     return output
 

mcp-server/handlers.py

@@ -22,7 +22,14 @@
 
 
 async def _handle_search(args: dict[str, Any]) -> str:
-    result = await api_post("/search", json=args)
+    # Map tool schema's max_results to v2 API's top_k
+    payload = {
+        "query": args["query"],
+        "repo_id": args["repo_id"],
+        "top_k": args.get("max_results", 10),
+        "use_reranking": True,
+    }
+    result = await api_post("/search/v2", json=payload)
     return format_search_results(result)
 
 

mcp-server/pyproject.toml

@@ -0,0 +1,3 @@
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

mcp-server/requirements.txt

@@ -3,3 +3,7 @@ mcp>=1.0.0
 httpx>=0.27.0
 python-dotenv>=1.0.0
 pydantic>=2.0.0
+
+# Test Dependencies
+pytest>=8.0.0
+pytest-asyncio>=0.23.0

mcp-server/tests/__init__.py

@@ -0,0 +1,27 @@
+"""Tests for MCP server configuration."""
+import pytest
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from config import API_PREFIX, SERVER_NAME, SERVER_VERSION, BACKEND_API_URL
+
+
+class TestConfig:
+    def test_api_prefix_format(self):
+        """API prefix must match /api/v{n} pattern."""
+        assert API_PREFIX.startswith("/api/v")
+
+    def test_server_name(self):
+        assert SERVER_NAME == "codeintel-mcp"
+
+    def test_server_version_semver(self):
+        """Version should be semver-like (x.y.z)."""
+        parts = SERVER_VERSION.split(".")
+        assert len(parts) == 3
+        assert all(p.isdigit() for p in parts)
+
+    def test_backend_url_has_prefix(self):
+        """BACKEND_API_URL should include the API prefix for direct use."""
+        assert BACKEND_API_URL.endswith(API_PREFIX)

mcp-server/tests/test_config.py

@@ -0,0 +1,195 @@
+"""Tests for response formatters.
+
+Formatters are pure functions (dict -> str) so they're straightforward to test
+without any mocking or network calls.
+"""
+import pytest
+import sys
+import os
+
+# Add parent directory to path so we can import the modules
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from formatters import (
+    format_search_results,
+    format_repositories,
+    format_dependency_graph,
+    format_code_style,
+    format_impact_analysis,
+    format_repository_insights,
+    format_codebase_dna,
+)
+
+
+# -- Search results (v2 format) --
+
+class TestFormatSearchResults:
+    def test_empty_results(self):
+        result = {"total": 0, "results": [], "cached": False, "search_version": "v2"}
+        output = format_search_results(result)
+        assert "Found 0 results" in output
+        assert "No results found" in output
+
+    def test_basic_result(self):
+        result = {
+            "total": 1,
+            "cached": False,
+            "search_version": "v2",
+            "results": [{
+                "name": "authenticate",
+                "qualified_name": "auth.service.authenticate",
+                "file_path": "backend/auth.py",
+                "code": "def authenticate(token): ...",
+                "signature": "def authenticate(token: str) -> User",
+                "language": "python",
+                "score": 0.95,
+                "line_start": 10,
+                "line_end": 20,
+                "match_reason": "Semantic match on authentication logic",
+            }],
+        }
+        output = format_search_results(result)
+        assert "authenticate" in output
+        assert "95% match" in output
+        assert "backend/auth.py" in output
+        assert "auth.service.authenticate" in output
+        assert "Signature" in output
+        assert "Why:" in output
+        assert "(v2)" in output
+
+    def test_cached_flag(self):
+        result = {"total": 0, "results": [], "cached": True, "search_version": "v2"}
+        output = format_search_results(result)
+        assert "(cached)" in output
+
+    def test_v1_fallback(self):
+        """Formatter handles v1-style response with 'count' field."""
+        result = {"count": 0, "results": []}
+        output = format_search_results(result)
+        assert "Found 0 results" in output
+        assert "(v1)" in output
+
+    def test_no_emoji_in_output(self):
+        """CLAUDE.md violation check: no emojis anywhere in formatted output."""
+        result = {"total": 1, "cached": True, "search_version": "v2", "results": [{
+            "name": "test", "file_path": "test.py", "code": "pass",
+            "language": "python", "score": 0.5, "line_start": 1, "line_end": 1,
+        }]}
+        output = format_search_results(result)
+        # Lightning bolt was the specific emoji found in OPE-91 audit
+        assert "\u26a1" not in output
+
+
+# -- Repositories --
+
+class TestFormatRepositories:
+    def test_no_repos(self):
+        output = format_repositories({"repositories": []})
+        assert "No repositories indexed" in output
+
+    def test_repo_listing(self):
+        output = format_repositories({
+            "repositories": [{
+                "id": "abc-123",
+                "name": "my-project",
+                "status": "indexed",
+                "file_count": 1500,
+                "branch": "main",
+            }]
+        })
+        assert "my-project" in output
+        assert "abc-123" in output
+        assert "indexed" in output
+        assert "1,500" in output
+
+
+# -- Dependency graph --
+
+class TestFormatDependencyGraph:
+    def test_empty_graph(self):
+        output = format_dependency_graph({"nodes": [], "edges": [], "metrics": {}})
+        assert "Total Files:** 0" in output
+
+    def test_critical_files_ranked(self):
+        output = format_dependency_graph({
+            "nodes": [{"id": "a.py"}, {"id": "b.py"}],
+            "edges": [
+                {"source": "b.py", "target": "a.py"},
+                {"source": "c.py", "target": "a.py"},
+            ],
+            "metrics": {"total_edges": 2, "avg_dependencies": 1.0},
+        })
+        assert "a.py" in output
+        assert "2 dependents" in output
+
+
+# -- Code style --
+
+class TestFormatCodeStyle:
+    def test_basic_summary(self):
+        output = format_code_style({
+            "summary": {
+                "total_files_analyzed": 50,
+                "total_functions": 200,
+                "async_adoption": "35%",
+                "type_hints_usage": "80%",
+            },
+        })
+        assert "50" in output
+        assert "200" in output
+        assert "35%" in output
+        assert "80%" in output
+
+
+# -- Impact analysis --
+
+class TestFormatImpactAnalysis:
+    def test_high_risk(self):
+        output = format_impact_analysis({
+            "file": "core/engine.py",
+            "risk_level": "high",
+            "impact_summary": "Central dependency",
+            "direct_dependencies": ["utils.py"],
+            "all_dependents": ["api.py", "cli.py"],
+            "test_files": ["test_engine.py"],
+        })
+        assert "core/engine.py" in output
+        assert "HIGH" in output
+        assert "utils.py" in output
+        assert "test_engine.py" in output
+
+
+# -- Repository insights --
+
+class TestFormatRepositoryInsights:
+    def test_basic_insights(self):
+        output = format_repository_insights({
+            "name": "opencodeintel",
+            "status": "indexed",
+            "functions_indexed": 500,
+            "total_files": 80,
+            "total_dependencies": 120,
+        })
+        assert "opencodeintel" in output
+        assert "500" in output
+
+
+# -- Codebase DNA --
+
+class TestFormatCodebaseDna:
+    def test_dna_output(self):
+        output = format_codebase_dna({
+            "dna": "## Patterns\n- Uses FastAPI\n- SQLAlchemy ORM",
+            "cached": False,
+        })
+        assert "Codebase DNA" in output
+        assert "FastAPI" in output
+        assert "Follow the auth patterns" in output
+
+    def test_dna_cached(self):
+        output = format_codebase_dna({"dna": "test", "cached": True})
+        assert "(cached)" in output
+
+    def test_no_emoji_in_dna(self):
+        output = format_codebase_dna({"dna": "test", "cached": True})
+        assert "\u26a1" not in output