iflow-mcp_niclasolofsson-dbt-core-mcp 1.7.0__py3-none-any.whl

dbt_core_mcp/tools/build_models.py

@@ -0,0 +1,190 @@
+"""Run dbt build (execute models and tests together in dependency order).
+
+This module implements the build_models tool for dbt Core MCP.
+"""
+
+import logging
+from typing import Any
+
+from fastmcp.dependencies import Depends  # type: ignore[reportAttributeAccessIssue]
+from fastmcp.server.context import Context
+
+from ..context import DbtCoreServerContext
+from ..dependencies import get_state
+from . import dbtTool
+
+logger = logging.getLogger(__name__)
+
+
+async def _implementation(
+    ctx: Context | None,
+    select: str | None,
+    exclude: str | None,
+    select_state_modified: bool,
+    select_state_modified_plus_downstream: bool,
+    full_refresh: bool,
+    resource_types: list[str] | None,
+    fail_fast: bool,
+    state: DbtCoreServerContext,
+) -> dict[str, Any]:
+    """Implementation function for build_models tool.
+
+    Separated for testing purposes - tests call this directly with explicit state.
+    The @tool() decorated build_models() function calls this with injected dependencies.
+    """
+    # Ensure dbt components are initialized
+    await state.ensure_initialized(ctx, force_parse=False)
+
+    # Build selector (state-based preferred when available)
+    selector = await state.prepare_state_based_selection(select_state_modified, select_state_modified_plus_downstream, select)
+
+    if select_state_modified and not selector:
+        raise RuntimeError("No previous state found - cannot determine modifications. Run 'dbt build' first to create baseline state.")
+
+    # Construct dbt CLI args for build
+    args = ["build"]
+
+    cache_selected_only = True
+    if cache_selected_only and (select or selector or select_state_modified):
+        args.append("--cache-selected-only")
+
+    if selector:
+        target_path = state.get_project_paths().get("target-path", "target")
+        args.extend(["-s", selector, "--state", f"{target_path}/state_last_run"])
+    elif select:
+        args.extend(["-s", select])
+
+    if exclude:
+        args.extend(["--exclude", exclude])
+
+    if resource_types:
+        for rt in resource_types:
+            args.extend(["--resource-type", rt])
+
+    if full_refresh:
+        args.append("--full-refresh")
+
+    if fail_fast:
+        args.append("--fail-fast")
+
+    logger.info(f"Running DBT build with args: {args}")
+
+    # Stream progress back to MCP client (if provided)
+    async def progress_callback(current: int, total: int, message: str) -> None:
+        if ctx:
+            await ctx.report_progress(progress=current, total=total, message=message)
+
+    # Clear stale run_results so we parse only fresh output
+    state.clear_stale_run_results()
+
+    runner = await state.get_runner()
+    result = await runner.invoke(args, progress_callback=progress_callback if ctx else None)  # type: ignore
+
+    run_results = state.validate_and_parse_results(result, "build")
+
+    if result and result.success:
+        await state.save_execution_state()
+
+    results_list = run_results.get("results", [])
+    if ctx:
+        if results_list:
+            passed_count = sum(1 for r in results_list if r.get("status") in ("success", "pass"))
+            failed_count = sum(1 for r in results_list if r.get("status") in ("error", "fail"))
+            skip_count = sum(1 for r in results_list if r.get("status") == "skipped")
+
+            total = len(results_list)
+            parts = []
+            if passed_count > 0:
+                parts.append(f"✅ {passed_count} passed" if failed_count > 0 or skip_count > 0 else "✅ All passed")
+            if failed_count > 0:
+                parts.append(f"❌ {failed_count} failed")
+            if skip_count > 0:
+                parts.append(f"⏭️ {skip_count} skipped")
+
+            summary = f"Build: {total}/{total} resources completed ({', '.join(parts)})"
+            await ctx.report_progress(progress=total, total=total, message=summary)
+        else:
+            await ctx.report_progress(progress=0, total=0, message="0 resources matched selector")
+
+    if not results_list:
+        raise RuntimeError(f"No resources matched selector: {select or selector or 'all'}")
+
+    return {
+        "status": "success",
+        "command": " ".join(args),
+        "results": run_results.get("results", []),
+        "elapsed_time": run_results.get("elapsed_time"),
+    }
+
+
+@dbtTool()
+async def build_models(
+    ctx: Context,
+    select: str | None = None,
+    exclude: str | None = None,
+    select_state_modified: bool = False,
+    select_state_modified_plus_downstream: bool = False,
+    full_refresh: bool = False,
+    resource_types: list[str] | None = None,
+    fail_fast: bool = False,
+    state: DbtCoreServerContext = Depends(get_state),
+) -> dict[str, Any]:
+    """Run dbt build (execute models and tests together in correct dependency order).
+
+    **When to use**: This is the recommended "do everything" command that runs seeds, models,
+    snapshots, and tests in the correct order based on your DAG. It automatically handles
+    dependencies, so you don't need to run load_seeds() → run_models() → test_models() separately.
+
+    **How it works**: Executes resources in dependency order:
+    1. Seeds (if selected)
+    2. Models (with their upstream dependencies)
+    3. Tests (after their parent models complete)
+    4. Snapshots (if selected)
+
+    State-based selection modes (uses dbt state:modified selector):
+    - select_state_modified: Build only resources modified since last successful run (state:modified)
+    - select_state_modified_plus_downstream: Build modified + downstream dependencies (state:modified+)
+      Note: Requires select_state_modified=True
+
+    Manual selection (alternative to state-based):
+    - select: dbt selector syntax (e.g., "customers", "tag:mart", "stg_*")
+    - exclude: Exclude specific models
+
+    Args:
+        select: Manual selector
+        exclude: Exclude selector
+        select_state_modified: Use state:modified selector (changed resources only)
+        select_state_modified_plus_downstream: Extend to state:modified+ (changed + downstream)
+        full_refresh: Force full refresh of incremental models
+        resource_types: Filter by resource types (model, test, seed, snapshot)
+        fail_fast: Stop execution on first failure
+        state: Shared state object injected by FastMCP
+
+    Returns:
+        Build results with status, models run/tested, and timing info
+
+    See also:
+        - run_models(): Run only models (no tests)
+        - test_models(): Run only tests
+        - load_seeds(): Run only seeds
+
+    Examples:
+        # Full project build (first-time setup or comprehensive run)
+        build_models()
+
+        # Build only what changed (efficient incremental workflow)
+        build_models(select_state_modified=True)
+
+        # Build changed resources + everything downstream
+        build_models(select_state_modified=True, select_state_modified_plus_downstream=True)
+
+        # Build specific model and its dependencies + tests
+        build_models(select="customers")
+
+        # Build all marts (includes their seed dependencies automatically)
+        build_models(select="tag:mart")
+
+        # Quick feedback: stop on first test failure
+        build_models(fail_fast=True)
+    """
+    return await _implementation(ctx, select, exclude, select_state_modified, select_state_modified_plus_downstream, full_refresh, resource_types, fail_fast, state)

dbt_core_mcp/tools/demo/__init__.py

@@ -0,0 +1 @@
+"""Demo tools for MCP UI experiments."""

dbt_core_mcp/tools/demo/hello.html

@@ -0,0 +1,267 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <script>
+        // ===== STATE =====
+        const state = {
+            nextId: 1,
+            hostContext: null,
+            toolInput: null,
+            lastSize: { width: 0, height: 0 }
+        };
+
+        // ===== LOGGING =====
+        const Logger = {
+            types: {
+                out: { class: 'log-out', arrow: '→', label: 'TO HOST' },
+                in: { class: 'log-in', arrow: '←', label: 'FROM HOST' },
+                system: { class: 'log-system', arrow: 'ℹ️', label: 'SYSTEM' }
+            },
+
+            log(type, message) {
+                const log = document.getElementById('log');
+                if (!log) return;
+
+                const config = this.types[type];
+                const entry = document.createElement('div');
+                entry.className = config.class;
+                entry.innerHTML = `
+                    <div class="log-header">${new Date().toLocaleTimeString()} ${config.arrow} ${config.label}</div>
+                    <pre>${JSON.stringify(message, null, 2)}</pre>
+                `;
+                log.appendChild(entry);
+                log.scrollTop = log.scrollHeight;
+            }
+        };
+
+        // ===== SIZE MANAGEMENT =====
+        const SizeManager = {
+            update() {
+                const viewportHeight = window.innerHeight;
+                const maxHeight = Math.floor(viewportHeight * 0.4);
+                const currentHeight = document.body.scrollHeight;
+
+                document.getElementById('viewport-height').textContent = viewportHeight;
+                document.getElementById('max-height').textContent = maxHeight;
+                document.getElementById('current-size').textContent = currentHeight;
+            },
+
+            notify() {
+                const width = document.body.scrollWidth;
+                const height = document.body.scrollHeight;
+
+                this.update();
+
+                if (width !== state.lastSize.width || height !== state.lastSize.height) {
+                    state.lastSize = { width, height };
+                    window.parent.postMessage({
+                        jsonrpc: "2.0",
+                        method: "ui/notifications/size-changed",
+                        params: { width, height }
+                    }, '*');
+                }
+            }
+        };
+
+        // ===== MESSAGING =====
+        const Messenger = {
+            request(method, params) {
+                const id = state.nextId++;
+                const message = { jsonrpc: "2.0", id, method, params };
+                Logger.log('out', message);
+                window.parent.postMessage(message, '*');
+                return id;
+            },
+
+            notification(method, params) {
+                const message = { jsonrpc: "2.0", method, params };
+                Logger.log('out', message);
+                window.parent.postMessage(message, '*');
+            }
+        };
+
+        // ===== MESSAGE HANDLERS =====
+        function handleResponse(message) {
+            if (!message.result?.hostContext) return;
+
+            state.hostContext = message.result.hostContext;
+            
+            // Send initialized notification
+            Messenger.notification("ui/notifications/initialized", {});
+
+            // Apply theme variables from host
+            if (state.hostContext.styles?.variables) {
+                const root = document.documentElement;
+                Object.entries(state.hostContext.styles.variables).forEach(([key, value]) => {
+                    root.style.setProperty(key, value);
+                });
+                console.log(`✅ Applied ${Object.keys(state.hostContext.styles.variables).length} theme variables`);
+                
+                // Check if variables resolved properly before showing content
+                const testColor = getComputedStyle(root).getPropertyValue('--color-text-primary').trim();
+                if (testColor && testColor !== 'magenta') {
+                    document.body.style.opacity = '1';
+                    console.log('✅ Variables resolved, showing content');
+                } else {
+                    // Fallback: show anyway after short delay
+                    setTimeout(() => {
+                        document.body.style.opacity = '1';
+                        console.log('⚠️ Showing content with fallback colors');
+                    }, 100);
+                }
+            }
+        }
+
+        function handleNotification(message) {
+            if (message.method === 'ui/notifications/tool-input') {
+                state.toolInput = message.params.arguments;
+            }
+            
+            if (message.method === 'ui/notifications/shutdown') {
+                Logger.log('system', { 
+                    type: 'system', 
+                    message: 'Received shutdown notification' 
+                });
+            }
+        }
+
+        // ===== INITIALIZATION =====
+        function initialize() {
+            console.log('🔄 Initialize called');
+            SizeManager.update();
+
+            Logger.log('system', { 
+                type: 'system', 
+                message: 'MCP App starting initialization...' 
+            });
+
+            Messenger.request("ui/initialize", {
+                capabilities: {},
+                clientInfo: { name: "dbt-demo-ui", version: "1.0.0" },
+                protocolVersion: "2025-06-18"
+            });
+
+            // Size observer
+            new ResizeObserver(() => SizeManager.notify()).observe(document.body);
+            window.addEventListener('resize', SizeManager.update);
+        }
+
+        // ===== EVENT LISTENERS =====
+        window.addEventListener('message', event => {
+            const message = event.data;
+            Logger.log('in', message);
+
+            if (message.jsonrpc === "2.0" && message.id) {
+                handleResponse(message);
+            }
+
+            if (message.jsonrpc === "2.0" && message.method) {
+                handleNotification(message);
+            }
+        });
+
+        document.addEventListener('DOMContentLoaded', initialize);
+    </script>
+    <style>
+        * { box-sizing: border-box; }
+        
+        html, body { margin: 0; padding: 0; height: auto; }
+
+        body {
+            padding: 0;
+            font-family: var(--font-sans, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif);
+            font-size: var(--font-text-md-size, 13px);
+            color: var(--color-text-primary, magenta);
+            background: transparent;
+            opacity: 0;
+            transition: opacity 0.15s ease-in;
+        }
+
+        h1 {
+            margin: 0 0 8px;
+            font-size: var(--font-heading-md-size, 20px);
+            font-weight: var(--font-weight-semibold, 600);
+            color: var(--color-text-primary, magenta);
+        }
+
+        p {
+            margin: 0 0 16px;
+            color: var(--color-text-secondary, yellow);
+        }
+
+        #size-info {
+            background: var(--color-background-secondary, #ff1493);
+            border: var(--border-width-regular, 1px) solid var(--color-border-primary, red);
+            border-radius: var(--border-radius-lg, 6px);
+            padding: 12px;
+            margin-bottom: 16px;
+            font-family: var(--font-mono, monospace);
+            font-size: var(--font-text-sm-size, 11px);
+        }
+
+        #size-info div { margin: 4px 0; }
+        #size-info strong { color: var(--color-text-primary, magenta); }
+        #size-info span { color: var(--color-text-success, lime); }
+
+        #log {
+            background: var(--color-background-secondary, #ff1493);
+            border: var(--border-width-regular, 1px) solid var(--color-border-primary, red);
+            border-radius: var(--border-radius-lg, 6px);
+            padding: 12px;
+        }
+
+        .log-out, .log-in, .log-system {
+            margin-bottom: 12px;
+            padding: 8px;
+            border-radius: var(--border-radius-md, 4px);
+        }
+
+        .log-out {
+            background: var(--color-background-info, #8b00ff);
+            border-left: 3px solid var(--color-border-info, cyan);
+        }
+
+        .log-in {
+            background: rgba(115, 201, 145, 0.1);
+            border-left: 3px solid var(--color-border-success, lime);
+        }
+
+        .log-system {
+            background: rgba(128, 128, 128, 0.1);
+            border-left: 3px solid var(--color-border-primary, red);
+        }
+
+        .log-header {
+            font-size: var(--font-text-xs-size, 10px);
+            font-weight: var(--font-weight-semibold, 600);
+            margin-bottom: 4px;
+            color: var(--color-text-secondary, yellow);
+        }
+
+        .log-out .log-header { color: var(--color-text-primary, magenta); }
+        .log-in .log-header { color: var(--color-text-success, lime); }
+
+        pre {
+            margin: 0;
+            font-family: var(--font-mono, 'Consolas', 'Monaco', monospace);
+            font-size: var(--font-text-xs-size, 10px);
+            color: var(--color-text-primary, magenta);
+            white-space: pre-wrap;
+            word-wrap: break-word;
+        }
+    </style>
+</head>
+<body>
+    <h1>MCP Apps Protocol Monitor 📡</h1>
+    <p>Self-logging JSON-RPC message viewer</p>
+
+    <div id="size-info">
+        <div><strong>Viewport Height:</strong> <span id="viewport-height">-</span>px</div>
+        <div><strong>40% Max (40vh):</strong> <span id="max-height">-</span>px</div>
+        <div><strong>Current Body Size:</strong> <span id="current-size">-</span>px</div>
+    </div>
+
+    <div id="log"></div>
+</body>
+</html>

dbt_core_mcp/tools/demo/ui_demo.py

@@ -0,0 +1,41 @@
+"""Simple tool for MCP UI resource testing."""
+
+import logging
+from typing import Any
+
+from fastmcp.server.context import Context
+
+from .. import dbtTool
+
+logger = logging.getLogger(__name__)
+
+
+@dbtTool(
+    description="Render the demo UI resource (resource://demo/hello).",
+    meta={
+        "ui": {
+            "resourceUri": "resource://demo/hello",
+        }
+    },
+)
+async def demo_ui(_ctx: Context) -> dict[str, Any]:
+    """Render the demo UI resource (resource://demo/hello)."""
+    logger.info("demo_ui tool called")
+    return {
+        "message": "Demo UI tool invoked",
+    }
+
+
+# @dbtTool(description="Return basic client context metadata for diagnostics.")
+# async def demo_client_context(ctx: Context) -> dict[str, Any]:
+#     """Return basic client context metadata for diagnostics."""
+#     logger.info("demo_client_context tool called")
+#     meta = getattr(getattr(ctx, "request_context", None), "meta", None)
+#     meta_value = meta if meta is None else getattr(meta, "__dict__", meta)
+#     return {
+#         "client_id": getattr(ctx, "client_id", None),
+#         "request_id": getattr(ctx, "request_id", None),
+#         "session_id": getattr(ctx, "session_id", None),
+#         "has_sampling_capability": getattr(ctx, "has_sampling_capability", None),
+#         "request_meta": meta_value,
+#     }