spice-mcp 0.1.5__tar.gz → 0.1.6__tar.gz

{spice_mcp-0.1.5 → spice_mcp-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spice-mcp
-Version: 0.1.5
+Version: 0.1.6
 Summary: mcp server built ontop of dune api endpoint
 Author-email: Evan-Kim2028 <ekcopersonal@gmail.com>
 License-File: LICENSE

{spice_mcp-0.1.5 → spice_mcp-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spice-mcp"
-version = "0.1.5"
+version = "0.1.6"
 description = "mcp server built ontop of dune api endpoint"
 authors = [
     { name = "Evan-Kim2028", email = "ekcopersonal@gmail.com" }

{spice_mcp-0.1.5 → spice_mcp-0.1.6}/src/spice_mcp/adapters/spellbook/explorer.py

@@ -349,13 +349,17 @@ class SpellbookExplorer(CatalogExplorer):
             return {}
 
     def _parse_sql_columns(self, sql_file: Path) -> list[TableColumn]:
-        """Parse SQL file to extract column names from SELECT statements."""
+        """
+        Parse SQL file to extract column names from SELECT statements.
+        
+        Note: This is a best-effort heuristic and may not be perfect for complex SQL.
+        For accurate column information, use Dune's DESCRIBE TABLE or query the actual table.
+        """
         try:
             with open(sql_file, encoding="utf-8") as f:
                 sql = f.read()
             
-            # Look for SELECT ... FROM patterns
-            # Match: SELECT col1, col2, col3 FROM ...
+            # Look for SELECT ... FROM patterns (simple heuristic)
             select_match = re.search(
                 r"SELECT\s+(.+?)\s+FROM",
                 sql,
@@ -364,27 +368,20 @@ class SpellbookExplorer(CatalogExplorer):
             
             if select_match:
                 cols_str = select_match.group(1)
-                # Split by comma, but handle function calls and aliases
+                # Simple split - may not handle all nested cases perfectly
+                # This is OK since column info is optional and best-effort
                 cols = []
                 for col in cols_str.split(","):
                     col = col.strip()
-                    # Extract column name (handle aliases: col AS alias -> col)
-                    if " AS " in col.upper():
-                        col = col.split(" AS ", 1)[0].strip()
-                    elif " " in col and not col.startswith("("):
-                        # Might be alias without AS
-                        parts = col.split()
-                        col = parts[0].strip()
-                    
-                    # Clean up function calls: function(col) -> col
-                    col = re.sub(r"^\w+\((.+)\)", r"\1", col)
+                    # Basic cleanup - remove obvious SQL noise
+                    col = col.split()[-1] if col else ""
                     col = col.strip().strip('"').strip("'")
                     
-                    if col and col not in ["*", "DISTINCT"]:
+                    if col and col not in ["*", "DISTINCT", "FROM"]:
                         cols.append(
                             TableColumn(
                                 name=col,
-                                dune_type="VARCHAR",  # Default, can't infer from SQL
+                                dune_type="VARCHAR",
                                 polars_dtype="Utf8",
                             )
                         )

{spice_mcp-0.1.5 → spice_mcp-0.1.6}/src/spice_mcp/mcp/server.py

@@ -347,7 +347,7 @@ def _unified_discover_impl(
     schema: str | None = None,
     limit: int = 50,
     source: Literal["dune", "spellbook", "both"] = "both",
-    include_columns: bool = True,
+    include_columns: bool = False,
 ) -> dict[str, Any]:
     """
     Unified discovery implementation that can search Dune API, Spellbook repo, or both.
@@ -496,7 +496,7 @@ def dune_discover(
     schema: str | None = None,
     limit: int = 50,
     source: Literal["dune", "spellbook", "both"] = "both",
-    include_columns: bool = True,
+    include_columns: bool = False,
 ) -> dict[str, Any]:
     """
     PRIMARY discovery tool for finding tables in Dune.
@@ -520,7 +520,9 @@ def dune_discover(
         limit: Maximum number of tables to return
         source: Where to search - "dune" (Dune API only), "spellbook" (GitHub repo only),
                 or "both" (default: searches both and merges results)
-        include_columns: Whether to include column details for Spellbook models (default: True)
+        include_columns: Whether to include column details (default: False).
+                        Note: Column info from Spellbook SQL is unreliable.
+                        Use dune_describe_table on the actual Dune table for accurate columns.
     
     Returns:
         Dictionary with:
@@ -534,9 +536,10 @@ def dune_discover(
           - dune_alias: Actual Dune table alias (for Spellbook models)
           - dune_table: Verified, queryable Dune table name (e.g., "sui_walrus.base_table")
           - verified: True (all returned tables are verified to exist)
-          - columns: Column details (for Spellbook models, if include_columns=True)
         - 'source': The source parameter used
         - 'message': Helpful message if no tables found
+        
+    Note: To get accurate column information, use dune_describe_table on the dune_table value.
     
     Examples:
         # Search both sources for walrus - returns verified tables only
@@ -611,7 +614,7 @@ def _spellbook_find_models_impl(
     keyword: str | list[str] | None = None,
     schema: str | None = None,
     limit: int = 50,
-    include_columns: bool = True,
+    include_columns: bool = False,
 ) -> dict[str, Any]:
     """
     Implementation for spellbook model discovery.

spice_mcp-0.1.6/tests/integration/test_dune_table_names.py

@@ -0,0 +1,48 @@
+"""Test that Spellbook discovery returns correct queryable Dune table names."""
+
+import pytest
+
+
+def test_walrus_table_discovery_returns_dune_table_names():
+    """Test that discovering Walrus tables returns correct dune_table field."""
+    from spice_mcp.mcp.server import _spellbook_find_models_impl
+    
+    # Discover walrus models
+    result = _spellbook_find_models_impl(
+        keyword="walrus",
+        schema=None,
+        limit=10,
+        include_columns=False
+    )
+    
+    assert "models" in result
+    walrus_models = result["models"]
+    
+    # Should find at least the base_table and payments models
+    assert len(walrus_models) >= 2
+    
+    # Check each model has the required fields
+    for model in walrus_models:
+        assert "dune_schema" in model
+        assert "dune_alias" in model
+        assert "dune_table" in model
+        
+        # Verify format is schema.alias (not daily_spellbook.model_name)
+        dune_table = model["dune_table"]
+        assert "." in dune_table
+        assert not dune_table.startswith("daily_spellbook.")
+        
+        # Verify specific known tables
+        if model["table"] == "sui_walrus_base_table":
+            assert model["dune_schema"] == "sui_walrus"
+            assert model["dune_alias"] == "base_table"
+            assert model["dune_table"] == "sui_walrus.base_table"
+        elif model["table"] == "sui_walrus_payments":
+            assert model["dune_schema"] == "sui_walrus"
+            assert model["dune_alias"] == "payments"
+            assert model["dune_table"] == "sui_walrus.payments"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
+

{spice_mcp-0.1.5 → spice_mcp-0.1.6}/uv.lock

@@ -1601,7 +1601,7 @@ wheels = [
 
 [[package]]
 name = "spice-mcp"
-version = "0.1.4"
+version = "0.1.6"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },