recce-nightly 1.23.0.20251029__py3-none-any.whl → 1.23.0.20251030__py3-none-any.whl

recce/mcp_server.py

@@ -0,0 +1,276 @@
+"""
+Recce MCP (Model Context Protocol) Server
+
+This module implements a stdio-based MCP server that provides tools for
+interacting with Recce's data validation capabilities.
+"""
+
+import asyncio
+import json
+import logging
+from typing import Any, Dict, List
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+from recce.core import RecceContext, load_context
+from recce.tasks.profile import ProfileDiffTask
+from recce.tasks.query import QueryDiffTask, QueryTask
+from recce.tasks.rowcount import RowCountDiffTask
+
+logger = logging.getLogger(__name__)
+
+
+class RecceMCPServer:
+    """MCP Server for Recce data validation tools"""
+
+    def __init__(self, context: RecceContext):
+        self.context = context
+        self.server = Server("recce")
+        self._setup_handlers()
+
+    def _setup_handlers(self):
+        """Register all tool handlers"""
+
+        @self.server.list_tools()
+        async def list_tools() -> List[Tool]:
+            """List all available tools"""
+            return [
+                Tool(
+                    name="get_lineage_diff",
+                    description="Get the lineage diff between base and current environments. "
+                    "Shows added, removed, and modified models.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "select": {
+                                "type": "string",
+                                "description": "dbt selector syntax to filter models (optional)",
+                            },
+                            "exclude": {
+                                "type": "string",
+                                "description": "dbt selector syntax to exclude models (optional)",
+                            },
+                            "packages": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of packages to filter (optional)",
+                            },
+                        },
+                    },
+                ),
+                Tool(
+                    name="row_count_diff",
+                    description="Compare row counts between base and current environments for specified models.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "node_names": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of model names to check row counts (optional)",
+                            },
+                            "node_ids": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of node IDs to check row counts (optional)",
+                            },
+                            "select": {
+                                "type": "string",
+                                "description": "dbt selector syntax to filter models (optional)",
+                            },
+                            "exclude": {
+                                "type": "string",
+                                "description": "dbt selector syntax to exclude models (optional)",
+                            },
+                        },
+                    },
+                ),
+                Tool(
+                    name="query",
+                    description="Execute a SQL query on the current environment. "
+                    "Supports Jinja templates with dbt macros like {{ ref('model_name') }}.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "sql_template": {
+                                "type": "string",
+                                "description": "SQL query template with optional Jinja syntax",
+                            },
+                            "base": {
+                                "type": "boolean",
+                                "description": "Whether to run on base environment (default: false)",
+                                "default": False,
+                            },
+                        },
+                        "required": ["sql_template"],
+                    },
+                ),
+                Tool(
+                    name="query_diff",
+                    description="Execute SQL queries on both base and current environments and compare results. "
+                    "Supports primary keys for row-level comparison.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "sql_template": {
+                                "type": "string",
+                                "description": "SQL query template for current environment",
+                            },
+                            "base_sql_template": {
+                                "type": "string",
+                                "description": "SQL query template for base environment (optional, defaults to sql_template)",
+                            },
+                            "primary_keys": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of primary key columns for row comparison (optional)",
+                            },
+                        },
+                        "required": ["sql_template"],
+                    },
+                ),
+                Tool(
+                    name="profile_diff",
+                    description="Generate and compare statistical profiles (min, max, avg, distinct count, etc.) "
+                    "for columns in a model between base and current environments.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "model": {
+                                "type": "string",
+                                "description": "Model name to profile",
+                            },
+                            "columns": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of column names to profile (optional, profiles all columns if not specified)",
+                            },
+                        },
+                        "required": ["model"],
+                    },
+                ),
+            ]
+
+        @self.server.call_tool()
+        async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+            """Handle tool calls"""
+            try:
+                if name == "get_lineage_diff":
+                    result = await self._get_lineage_diff(arguments)
+                elif name == "row_count_diff":
+                    result = await self._row_count_diff(arguments)
+                elif name == "query":
+                    result = await self._query(arguments)
+                elif name == "query_diff":
+                    result = await self._query_diff(arguments)
+                elif name == "profile_diff":
+                    result = await self._profile_diff(arguments)
+                else:
+                    raise ValueError(f"Unknown tool: {name}")
+
+                return [TextContent(type="text", text=json.dumps(result, indent=2))]
+            except Exception as e:
+                logger.exception(f"Error executing tool {name}")
+                return [TextContent(type="text", text=json.dumps({"error": str(e)}, indent=2))]
+
+    async def _get_lineage_diff(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get lineage diff between base and current"""
+        try:
+            # Get lineage diff from adapter (returns a Pydantic LineageDiff model)
+            lineage_diff = self.context.get_lineage_diff()
+            # Convert Pydantic model to dict for JSON serialization
+            return lineage_diff.model_dump(mode="json")
+        except Exception:
+            logger.exception("Error getting lineage diff")
+            raise
+
+    async def _row_count_diff(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute row count diff task"""
+        try:
+            task = RowCountDiffTask(params=arguments)
+
+            # Execute task synchronously (it's already sync)
+            result = await asyncio.get_event_loop().run_in_executor(None, task.execute)
+
+            return result
+        except Exception:
+            logger.exception("Error executing row count diff")
+            raise
+
+    async def _query(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute a query"""
+        try:
+            sql_template = arguments.get("sql_template")
+            is_base = arguments.get("base", False)
+
+            params = {"sql_template": sql_template}
+            task = QueryTask(params=params)
+            task.is_base = is_base
+
+            # Execute task
+            result = await asyncio.get_event_loop().run_in_executor(None, task.execute)
+
+            # Convert to dict if it's a model
+            if hasattr(result, "model_dump"):
+                return result.model_dump(mode="json")
+            return result
+        except Exception:
+            logger.exception("Error executing query")
+            raise
+
+    async def _query_diff(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute query diff task"""
+        try:
+            task = QueryDiffTask(params=arguments)
+
+            # Execute task
+            result = await asyncio.get_event_loop().run_in_executor(None, task.execute)
+
+            # Convert to dict if it's a model
+            if hasattr(result, "model_dump"):
+                return result.model_dump(mode="json")
+            return result
+        except Exception:
+            logger.exception("Error executing query diff")
+            raise
+
+    async def _profile_diff(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute profile diff task"""
+        try:
+            task = ProfileDiffTask(params=arguments)
+
+            # Execute task
+            result = await asyncio.get_event_loop().run_in_executor(None, task.execute)
+
+            # Convert to dict if it's a model
+            if hasattr(result, "model_dump"):
+                return result.model_dump(mode="json")
+            return result
+        except Exception:
+            logger.exception("Error executing profile diff")
+            raise
+
+    async def run(self):
+        """Run the MCP server"""
+        async with stdio_server() as (read_stream, write_stream):
+            await self.server.run(read_stream, write_stream, self.server.create_initialization_options())
+
+
+async def run_mcp_server(**kwargs):
+    """
+    Entry point for running the MCP server
+
+    Args:
+        **kwargs: Arguments for loading RecceContext (dbt options, etc.)
+    """
+    # Setup logging
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+    # Load Recce context
+    context = load_context(**kwargs)
+
+    # Create and run server
+    server = RecceMCPServer(context)
+    await server.run()

recce/state/const.py

@@ -21,6 +21,6 @@ RECCE_CLOUD_PASSWORD_MISSING = ErrorMessage(
 )
 
 RECCE_API_TOKEN_MISSING = ErrorMessage(
-    error_message="No Recc API token is provided",
+    error_message="No Recce API token is provided",
     hint_message="Please login to Recce Cloud and copy the API token from the settings page",
 )

recce/state/state_loader.py

@@ -8,9 +8,7 @@ from recce.exceptions import RecceException
 from recce.pull_request import fetch_pr_metadata
 
 from ..util.io import SupportedFileTypes, file_io_factory
-from .const import (
-    RECCE_CLOUD_TOKEN_MISSING,
-)
+from .const import RECCE_API_TOKEN_MISSING
 from .state import RecceState
 
 logger = logging.getLogger("uvicorn")
@@ -55,7 +53,7 @@ class RecceStateLoader(ABC):
                     self.catalog = "preview"
                     self.share_id = self.cloud_options.get("share_id")
             else:
-                raise RecceException(RECCE_CLOUD_TOKEN_MISSING.error_message)
+                raise RecceException(RECCE_API_TOKEN_MISSING.error_message)
 
     @property
     def token(self):

{recce_nightly-1.23.0.20251029.dist-info → recce_nightly-1.23.0.20251030.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: recce-nightly
-Version: 1.23.0.20251029
+Version: 1.23.0.20251030
 Summary: Environment diff tool for dbt
 Home-page: https://github.com/InfuseAI/recce
 Author: InfuseAI Dev Team
@@ -39,8 +39,11 @@ Requires-Dist: python-multipart
 Requires-Dist: GitPython
 Requires-Dist: PyGithub
 Requires-Dist: sqlglot
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == "mcp"
 Provides-Extra: dev
 Requires-Dist: pytest>=4.6; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pytest-flake8; extra == "dev"
 Requires-Dist: black>=25.1.0; extra == "dev"
 Requires-Dist: isort>=6.0.1; extra == "dev"

{recce_nightly-1.23.0.20251029.dist-info → recce_nightly-1.23.0.20251030.dist-info}/RECORD

@@ -1,7 +1,7 @@
-recce/VERSION,sha256=c46n2tbAF9VpZ7z1Mky2wXxGSSi6GfZ3DJFMd7rA_qY,16
+recce/VERSION,sha256=1ELJHFjMvjvnFJJ00qb31P6k7uqIchH_h5H_PW25o30,16
 recce/__init__.py,sha256=gT5G7sJ78C1GHAWr4pna6UvVNxPKs29_EgFS_ia3DT4,2554
 recce/artifact.py,sha256=BdNW5eQQqEKu5cRzA_XusKMIN73V7-MTQP0VxnLdd9E,9265
-recce/cli.py,sha256=ws50nwIzWvYcLNPDfcI6N69k5DaaIONKxloqa-5UdE8,52989
+recce/cli.py,sha256=McDz__wg_whFspjlsD_m9T4268eVQ5VrOJe7FEip7ag,56427
 recce/config.py,sha256=noWimlOdGHAtBhNoApK5gRTQMwNPmUGAmZu39MV7szo,4697
 recce/connect_to_cloud.py,sha256=CT7ELcVCTNa9ukSp_gMrJ0Av2UCUpF9H03tIk9y7U-4,4768
 recce/core.py,sha256=Fph2kodFqzXy3cob80M9-nPVcv-Xxzme-E-bKFJ4cBQ,10754
@@ -9,6 +9,7 @@ recce/diff.py,sha256=L2_bzQ3__PO-0aeir8PHF8FvSOUmQ8WcDXgML1-mHdY,748
 recce/exceptions.py,sha256=SclQ678GrHGjw7p_ZFJ3vZaL_yMU5xABeIAm2u_W2bk,592
 recce/git.py,sha256=8Eg-6NzL-KjA3rT-ibbAyaCwGlzV0JqH3yGikrJNMDA,2344
 recce/github.py,sha256=vIwHTpB8YWEUcHQlW0nToUUKmGGO0NcmB_Q5RvxQLLE,7438
+recce/mcp_server.py,sha256=NjR1q4pMzph0Ps1pQlFX2Go83ml1JQD4ilP_4mLH7QI,11461
 recce/pull_request.py,sha256=dLHsdiMtL4NC6Vkwp8Mq4baJmnqbm19lfiDti9MREN0,3850
 recce/run.py,sha256=ctp-K2FmrsGrS4xEZKDMbMtitNw2QKJ6Tq_0OvCWaaM,14080
 recce/server.py,sha256=FURnuOtooA4ezglEouV_-J-y2ECrNjd6vvSiROnm7Nc,22851
@@ -23,11 +24,13 @@ recce/apis/check_api.py,sha256=KMCXSMl1qqzx2jQgRqCrD4j_cY3EHBbM3H2-t-6saAU,6227
 recce/apis/check_func.py,sha256=gktbCcyk3WGvWRJJ-wDnwv7NrIny2nTHWLl1-kdiVRo,4183
 recce/apis/run_api.py,sha256=eOaxOxXDkH59uqGCd4blld7edavUx7JU_DCd2WAYrL8,3416
 recce/apis/run_func.py,sha256=6wC8TDU-h7TLr2VZH7HNsWaUVlQ9HBN5N_dwqfi4lMY,7440
-recce/data/404.html,sha256=Uf2QEM3obZQFhZi7F7OYjmPlXbQTBVsn8D9L_srTeJw,59085
+recce/data/404.html,sha256=WyRvwUWhYVYBrARjspe_zhkppuNIXnzDJQNEPpDdXkM,59085
 recce/data/auth_callback.html,sha256=H-XfdlAFiw5VU2RpKBVQbwh1AIqJrPHrFA0S09nNJZA,94779
 recce/data/favicon.ico,sha256=B2mBumUOnzvUrXrqNkrc5QfdDXjzEXRcWkWur0fJ6sM,2565
-recce/data/index.html,sha256=wAMuaWDbPpy7XFe8iI5mp6_evy9Qx6ugqhuo5aQi_AM,77170
-recce/data/index.txt,sha256=8RLgnQrk6dzlyqYqg-Cu4X3giA3z6c_llJbnrma-soU,6406
+recce/data/index.html,sha256=9ZzdgS_axunI4Wo-Lhp37ua70TaaYKnZ2EPDIK05tmE,77170
+recce/data/index.txt,sha256=FO8bYezNOfzIF7ANp8bT0POjJwDr0Lk3TPYz5nqQlnQ,6406
+recce/data/_next/static/9_NHXNrry9XjEuvMyJcMg/_buildManifest.js,sha256=oqgeL8q3W6T625zlDuGLFDWY3H4_3tlJCNWvj42kYcs,544
+recce/data/_next/static/9_NHXNrry9XjEuvMyJcMg/_ssgManifest.js,sha256=Z49s4suAsf5y_GfnQSvm4qtq2ggxEbZPfEDTXjy6XgA,80
 recce/data/_next/static/chunks/12f8fac4-a2fd98f42126999f.js,sha256=ILGeY9xCblLTFgnG9zdwGqe5jxxulBBz761KM3HRxMc,152792
 recce/data/_next/static/chunks/272-058426d7d18ce061.js,sha256=-MHfq8GlLLjSveELfok_YIHlMtuBkYY-hCsJc-EyQOA,10714
 recce/data/_next/static/chunks/3a92ee20-9c4519f55ecaa314.js,sha256=3pmoD3iJD1ZSIoY-v_9ZsGqXu-ILHdy5FiKF3vvaN2s,177908
@@ -68,8 +71,6 @@ recce/data/_next/static/css/5da8812af0008c76.css,sha256=1JLGRCtK9HwSjFvlp-iimWYY
 recce/data/_next/static/css/8edca58d4abcf908.css,sha256=Ab-wk7RhsXgiX5fkJsrCJ-EVvrS1hZtOFpI0uZQSgL0,8093
 recce/data/_next/static/css/abdb9814a3dd18bb.css,sha256=Do5x9FJaOIe-pSBlbk_PP7PQAYFbDXTTl_0PWY4cnBM,1327
 recce/data/_next/static/css/af2813f12c8a4fd8.css,sha256=sLhHpBJpH5zsmd5h13LU922e3dTlJWkPzZ5R67f8CzM,12260
-recce/data/_next/static/fCULljmCJ7BP8dZt7mK5Y/_buildManifest.js,sha256=oqgeL8q3W6T625zlDuGLFDWY3H4_3tlJCNWvj42kYcs,544
-recce/data/_next/static/fCULljmCJ7BP8dZt7mK5Y/_ssgManifest.js,sha256=Z49s4suAsf5y_GfnQSvm4qtq2ggxEbZPfEDTXjy6XgA,80
 recce/data/_next/static/media/montserrat-cyrillic-800-normal.728ecd06.woff,sha256=XiXifLCW_CfSR4eNCIxDzi3Cg59f6L34ARTHrw-hoDA,10924
 recce/data/_next/static/media/montserrat-cyrillic-800-normal.ffc85bb1.woff2,sha256=6XlujeGVTucujV3iPSa7j1d9S5A6uuH-EduJBCeVFu8,11180
 recce/data/_next/static/media/montserrat-cyrillic-ext-800-normal.622429c0.woff2,sha256=9hQT0vu2HmOb21Pk5Ht7bydZU7QIsY7rCyAPtm1VxM8,12144
@@ -96,10 +97,10 @@ recce/models/run.py,sha256=QK2gvOWvko9YYhd2NLs3BPt5l4MSCZGwpzTAiqx9zJw,1161
 recce/models/types.py,sha256=9ReOyIv3rUD3_cIQfB9Rplb0L2YQuZr4kS9Zai30nB8,5234
 recce/state/__init__.py,sha256=V1FRPTQJUz-uwI3Cn8wDa5Z9bueVs86MR_1Ti4RGfPc,650
 recce/state/cloud.py,sha256=hCLvRgMwQwRxlcQhU33L8gXq6yoytBdAIwgWIWPTeLc,25489
-recce/state/const.py,sha256=Me3uVQHi_uZysl3tfpmghPInuKF236X6LfMKVvJlCgA,827
+recce/state/const.py,sha256=5XwGWEv4RhGucgl1RHWg_67gVY7fV0-jsbZPpfnOCTs,828
 recce/state/local.py,sha256=bZIkl7cAfyYaGgYEr3uD_JLrtwlHBnu8_o1Qz2djQzw,1920
 recce/state/state.py,sha256=D3wBd8VLtrYEqAb0ueNxzjF84OB4vFDNJL3a1fPhziQ,4177
-recce/state/state_loader.py,sha256=_4vzZ3XiIMdC7G2m2WUhGi_IIoJLzsE7KwTVUeebMc0,5979
+recce/state/state_loader.py,sha256=IiGaFDm2y_0NMsv_YUZhSuDTsvWmdMrf9SXIv9w5sKE,5966
 recce/tasks/__init__.py,sha256=b553AtDHjYROgmMePv_Hv_X3fjh4iEn11gzzpUJz6_o,610
 recce/tasks/core.py,sha256=JFYa1CfgOiRPQ7KVTwMuxJjhMB-pvCwB-xezVt-h3RU,4080
 recce/tasks/dataframe.py,sha256=03UBWwt0DFTXlaEOtnV5i_mxdRKD7UbRayewEL2Ub48,3650
@@ -125,14 +126,16 @@ recce/util/pydantic_model.py,sha256=KumKuyCjbTzEMsKLE4-b-eZfp0gLhYDdmVtw1-hxiJw,
 recce/util/recce_cloud.py,sha256=fM4At7-90dS_TXIAxYNjWdEOW1OUbjTOqYmwWt89eEw,17171
 recce/util/singleton.py,sha256=1cU99I0f9tjuMQLMJyLsK1oK3fZJMsO5-TbRHAMXqds,627
 recce/yaml/__init__.py,sha256=PAym5akbtL24Ag7VR7EW8SS2VINNaJU06esbfe-ek-U,1328
-recce_nightly-1.23.0.20251029.dist-info/licenses/LICENSE,sha256=CQjjMy9aYPhfe8xG_bcpIfKtNkdxLZ5IOb8oPygtUhY,11343
+recce_nightly-1.23.0.20251030.dist-info/licenses/LICENSE,sha256=CQjjMy9aYPhfe8xG_bcpIfKtNkdxLZ5IOb8oPygtUhY,11343
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_cli.py,sha256=CFtP4eJrtcHwpzoEgJAyveQcqxAmDQuWXPrLc_Iny7Q,6626
+tests/test_cli_mcp_optional.py,sha256=w6Iwr22fheaOxw6vGXVZyvi0pw5uh8jDJKcdnd64-_o,1629
 tests/test_cloud_listing_cli.py,sha256=77As9n0Sngdh53dfHkShmqDETMTOohlqw1xXO9cIago,14208
 tests/test_config.py,sha256=ODDFe_XF6gphmSmmc422dGLBaCCmG-IjDzTkD5SJsJE,1557
 tests/test_connect_to_cloud.py,sha256=b2fgV8L1iQBdEwh6RumMsIIyYg7GtMOMRz1dvE3WRPg,3059
 tests/test_core.py,sha256=WgCFm8Au3YQI-V5UbZ6LA8irMNHRc7NWutIq2Mny0LE,6242
 tests/test_dbt.py,sha256=VzXvdoJNwwEmKNhJJDNB1N_qZYwp1aoJQ1sLcoyRBmk,1316
+tests/test_mcp_server.py,sha256=k7FxIgHNQF-DWrFJ6eLVi3uyhlDz3AO5VHCEwY56v1s,7709
 tests/test_pull_request.py,sha256=HmZo5MoDaoKSgPwbLxJ3Ur3ajZ7IxhkzJxaOmhg6bwE,3562
 tests/test_server.py,sha256=sq03awzG-kvLNJwHaZGDvVjd2uAs502XUKZ2nLNwvRQ,3391
 tests/test_summary.py,sha256=D0WvAkdO-vzGcvholH2rfS1wTxUXjVHwWm59fWy45eA,2876
@@ -154,8 +157,8 @@ tests/tasks/test_row_count.py,sha256=21PaP2aq-x8-pqwzWHRT1sixhQ8g3CQNRWOZTTmbK0s
 tests/tasks/test_schema.py,sha256=7ds4Vx8ixaiIWDR49Lvjem4xlPkRP1cXazDRY3roUak,3121
 tests/tasks/test_top_k.py,sha256=YR_GS__DJsbDlQVaEEdJvNQ3fh1VmV5Nb3G7lb0r6YM,1779
 tests/tasks/test_valuediff.py,sha256=_xQJGgxsXoy2NYk_Z6Hsw2FlVh6zk2nN_iUueyRN1e8,2046
-recce_nightly-1.23.0.20251029.dist-info/METADATA,sha256=Ff3-DNP7eKwIViok1VaavWqYid0PiCqvvbEL1p4P9v0,9471
-recce_nightly-1.23.0.20251029.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-recce_nightly-1.23.0.20251029.dist-info/entry_points.txt,sha256=oqoY_IiwIqXbgrIsPnlqUqao2eiIeP2dprowkOlmeyg,40
-recce_nightly-1.23.0.20251029.dist-info/top_level.txt,sha256=6PKGVpf75idP0C6KEaldDzzZUauIxNu1ZDstau1pI4I,12
-recce_nightly-1.23.0.20251029.dist-info/RECORD,,
+recce_nightly-1.23.0.20251030.dist-info/METADATA,sha256=pW5TlLbxBDBFfVk45aOeu54t21K9X866P9bnXJ10hmY,9579
+recce_nightly-1.23.0.20251030.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+recce_nightly-1.23.0.20251030.dist-info/entry_points.txt,sha256=oqoY_IiwIqXbgrIsPnlqUqao2eiIeP2dprowkOlmeyg,40
+recce_nightly-1.23.0.20251030.dist-info/top_level.txt,sha256=6PKGVpf75idP0C6KEaldDzzZUauIxNu1ZDstau1pI4I,12
+recce_nightly-1.23.0.20251030.dist-info/RECORD,,

tests/test_cli_mcp_optional.py

@@ -0,0 +1,45 @@
+"""
+Test that CLI can be imported even when mcp is not available.
+"""
+
+import sys
+from unittest.mock import patch
+
+
+def test_cli_can_be_imported_without_mcp():
+    """Test that recce.cli can be imported even if mcp package is not available"""
+    # This test verifies that the CLI module doesn't fail to import
+    # when mcp is not installed, since mcp is an optional dependency
+    from recce import cli
+
+    assert cli is not None
+    assert hasattr(cli, "cli")
+    assert hasattr(cli, "mcp_server")
+
+
+def test_mcp_server_command_fails_gracefully_without_mcp():
+    """Test that mcp-server command shows helpful error when mcp is not available"""
+    # Mock sys.modules to simulate mcp not being installed
+    with patch.dict(sys.modules, {"mcp": None, "mcp.server": None, "mcp.server.stdio": None, "mcp.types": None}):
+        # Remove mcp_server from modules to force reimport
+        if "recce.mcp_server" in sys.modules:
+            del sys.modules["recce.mcp_server"]
+
+        from recce.cli import mcp_server
+
+        # The function should exist
+        assert mcp_server is not None
+
+        # When called, it should handle ImportError gracefully
+        # (We can't easily test the actual execution without more mocking,
+        # but we've verified the function exists and can be imported)
+
+
+def test_cli_command_exists():
+    """Test that both server and mcp-server commands are registered"""
+    from recce.cli import cli
+
+    # Check that both commands exist
+    commands = {cmd.name for cmd in cli.commands.values()}
+    assert "server" in commands
+    assert "mcp_server" in commands or "mcp-server" in commands

tests/test_mcp_server.py

@@ -0,0 +1,208 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# Skip all tests in this module if mcp is not available
+pytest.importorskip("mcp")
+
+from recce.core import RecceContext  # noqa: E402
+from recce.mcp_server import RecceMCPServer, run_mcp_server  # noqa: E402
+from recce.models.types import LineageDiff  # noqa: E402
+from recce.tasks.profile import ProfileDiffTask  # noqa: E402
+from recce.tasks.query import QueryDiffTask, QueryTask  # noqa: E402
+from recce.tasks.rowcount import RowCountDiffTask  # noqa: E402
+
+
+@pytest.fixture
+def mcp_server():
+    """Fixture to create a RecceMCPServer instance for testing"""
+    mock_context = MagicMock(spec=RecceContext)
+    return RecceMCPServer(mock_context), mock_context
+
+
+class TestRecceMCPServer:
+    """Test cases for the RecceMCPServer class"""
+
+    def test_server_initialization(self, mcp_server):
+        """Test that the MCP server initializes correctly"""
+        server, mock_context = mcp_server
+        assert server.context == mock_context
+        assert server.server is not None
+        assert server.server.name == "recce"
+
+    @pytest.mark.asyncio
+    async def test_get_lineage_diff(self, mcp_server):
+        """Test the get_lineage_diff tool"""
+        server, mock_context = mcp_server
+        # Mock the lineage diff response
+        mock_lineage_diff = MagicMock(spec=LineageDiff)
+        mock_lineage_diff.model_dump.return_value = {
+            "added": ["model.project.new_model"],
+            "removed": ["model.project.old_model"],
+            "modified": ["model.project.changed_model"],
+        }
+        mock_context.get_lineage_diff.return_value = mock_lineage_diff
+
+        # Execute the method
+        result = await server._get_lineage_diff({})
+
+        # Verify the result
+        assert "added" in result
+        assert "removed" in result
+        assert "modified" in result
+        mock_context.get_lineage_diff.assert_called_once()
+        mock_lineage_diff.model_dump.assert_called_once_with(mode="json")
+
+    @pytest.mark.asyncio
+    async def test_row_count_diff(self, mcp_server):
+        """Test the row_count_diff tool"""
+        server, _ = mcp_server
+        # Mock the task execution
+        mock_result = {"results": [{"node_id": "model.project.my_model", "base": 100, "current": 105, "diff": 5}]}
+
+        with patch.object(RowCountDiffTask, "execute", return_value=mock_result):
+            result = await server._row_count_diff({"node_names": ["my_model"]})
+
+        # Verify the result
+        assert result == mock_result
+        assert "results" in result
+
+    @pytest.mark.asyncio
+    async def test_query(self, mcp_server):
+        """Test the query tool"""
+        server, _ = mcp_server
+        # Mock the task execution
+        mock_result = MagicMock()
+        mock_result.model_dump.return_value = {
+            "columns": ["id", "name"],
+            "data": [[1, "Alice"], [2, "Bob"]],
+        }
+
+        with patch.object(QueryTask, "execute", return_value=mock_result):
+            result = await server._query({"sql_template": "SELECT * FROM {{ ref('my_model') }}", "base": False})
+
+        # Verify the result
+        assert "columns" in result
+        assert "data" in result
+        mock_result.model_dump.assert_called_once_with(mode="json")
+
+    @pytest.mark.asyncio
+    async def test_query_with_base_flag(self, mcp_server):
+        """Test the query tool with base environment flag"""
+        server, _ = mcp_server
+        mock_result = {"columns": ["id"], "data": [[1]]}
+
+        with patch.object(QueryTask, "execute", return_value=mock_result) as mock_execute:
+            with patch.object(QueryTask, "__init__", return_value=None):
+                task = QueryTask(params={"sql_template": "SELECT 1"})
+                task.is_base = True
+                task.execute = mock_execute
+
+                result = await server._query({"sql_template": "SELECT 1", "base": True})
+
+                # Verify base flag was set (would need to inspect task creation)
+                assert result == mock_result
+
+    @pytest.mark.asyncio
+    async def test_query_diff(self, mcp_server):
+        """Test the query_diff tool"""
+        server, _ = mcp_server
+        # Mock the task execution
+        mock_result = MagicMock()
+        mock_result.model_dump.return_value = {
+            "diff": {
+                "added": [[3, "Charlie"]],
+                "removed": [[1, "Alice"]],
+                "modified": [],
+            }
+        }
+
+        with patch.object(QueryDiffTask, "execute", return_value=mock_result):
+            result = await server._query_diff(
+                {
+                    "sql_template": "SELECT * FROM {{ ref('my_model') }}",
+                    "primary_keys": ["id"],
+                }
+            )
+
+        # Verify the result
+        assert "diff" in result
+        mock_result.model_dump.assert_called_once_with(mode="json")
+
+    @pytest.mark.asyncio
+    async def test_profile_diff(self, mcp_server):
+        """Test the profile_diff tool"""
+        server, _ = mcp_server
+        # Mock the task execution
+        mock_result = MagicMock()
+        mock_result.model_dump.return_value = {
+            "columns": {
+                "id": {
+                    "base": {"min": 1, "max": 100, "avg": 50.5},
+                    "current": {"min": 1, "max": 105, "avg": 53.0},
+                }
+            }
+        }
+
+        with patch.object(ProfileDiffTask, "execute", return_value=mock_result):
+            result = await server._profile_diff({"model": "my_model", "columns": ["id"]})
+
+        # Verify the result
+        assert "columns" in result
+        mock_result.model_dump.assert_called_once_with(mode="json")
+
+    @pytest.mark.asyncio
+    async def test_error_handling(self, mcp_server):
+        """Test error handling in tool execution"""
+        server, mock_context = mcp_server
+        # Make get_lineage_diff raise an exception
+        mock_context.get_lineage_diff.side_effect = Exception("Test error")
+
+        # The method should raise the exception
+        with pytest.raises(Exception, match="Test error"):
+            await server._get_lineage_diff({})
+
+
+class TestRunMCPServer:
+    """Test cases for the run_mcp_server function"""
+
+    @pytest.mark.asyncio
+    @patch("recce.mcp_server.load_context")
+    @patch.object(RecceMCPServer, "run")
+    async def test_run_mcp_server(self, mock_run, mock_load_context):
+        """Test the run_mcp_server entry point"""
+        # Mock the context
+        mock_context = MagicMock(spec=RecceContext)
+        mock_load_context.return_value = mock_context
+
+        # Mock the server run method
+        mock_run.return_value = None
+
+        # Run the server
+        await run_mcp_server(project_dir="/test/path")
+
+        # Verify context was loaded with correct kwargs
+        mock_load_context.assert_called_once_with(project_dir="/test/path")
+
+        # Verify server was run
+        mock_run.assert_called_once()
+
+    @pytest.mark.asyncio
+    @patch("recce.mcp_server.load_context")
+    async def test_run_mcp_server_context_error(self, mock_load_context):
+        """Test run_mcp_server handles context loading errors"""
+        # Make load_context raise an exception
+        mock_load_context.side_effect = FileNotFoundError("manifest.json not found")
+
+        # The function should raise the exception
+        with pytest.raises(FileNotFoundError):
+            await run_mcp_server()
+
+
+def test_mcp_cli_command_exists():
+    """Test that the mcp-server CLI command is registered"""
+    from recce.cli import cli
+
+    # Check that mcp_server is in the CLI commands
+    commands = [cmd.name for cmd in cli.commands.values()]
+    assert "mcp_server" in commands or "mcp-server" in commands