foundry-mcp 0.8.22__py3-none-any.whl

foundry_mcp/core/modifications.py

@@ -0,0 +1,224 @@
+"""
+Spec modification operations using direct Python APIs.
+Replaces subprocess calls to external CLI tools.
+"""
+import json
+from pathlib import Path
+from typing import Dict, Any, List, Optional, Tuple
+
+from .spec import load_spec, save_spec, update_node, find_specs_directory
+
+
+def apply_modifications(
+    spec_id: str,
+    modifications: List[Dict[str, Any]],
+    specs_dir: Optional[Path] = None,
+    dry_run: bool = False,
+) -> Tuple[int, int, List[Dict[str, Any]]]:
+    """
+    Apply a list of modifications to a spec.
+
+    Args:
+        spec_id: Specification ID to modify
+        modifications: List of modification dictionaries with 'action', 'node_id', etc.
+        specs_dir: Path to specs directory (auto-detected if not provided)
+        dry_run: If True, don't save changes
+
+    Returns:
+        Tuple of (applied_count, skipped_count, changes_list)
+
+    Raises:
+        ValueError: If spec not found
+        FileNotFoundError: If specs directory not found
+    """
+    if specs_dir is None:
+        specs_dir = find_specs_directory()
+
+    if not specs_dir:
+        raise FileNotFoundError("Could not find specs directory")
+
+    spec_data = load_spec(spec_id, specs_dir)
+    if not spec_data:
+        raise ValueError(f"Specification '{spec_id}' not found")
+
+    applied = 0
+    skipped = 0
+    changes: List[Dict[str, Any]] = []
+
+    for mod in modifications:
+        action = mod.get("action")
+        node_id = mod.get("node_id")
+
+        if action == "update_node":
+            mod_changes = mod.get("changes", {})
+            if update_node(spec_data, node_id, mod_changes):
+                applied += 1
+                changes.append({
+                    "action": action,
+                    "node_id": node_id,
+                    "status": "applied",
+                    "changes": mod_changes,
+                })
+            else:
+                skipped += 1
+                changes.append({
+                    "action": action,
+                    "node_id": node_id,
+                    "status": "skipped",
+                    "reason": "node not found",
+                })
+
+        elif action == "add_node":
+            node_data = mod.get("data", {})
+            parent_id = mod.get("parent")
+            if _add_node(spec_data, node_id, node_data, parent_id):
+                applied += 1
+                changes.append({
+                    "action": action,
+                    "node_id": node_id,
+                    "status": "applied",
+                })
+            else:
+                skipped += 1
+                changes.append({
+                    "action": action,
+                    "node_id": node_id,
+                    "status": "skipped",
+                    "reason": "failed to add node",
+                })
+
+        elif action == "remove_node":
+            cascade = mod.get("cascade", False)
+            if _remove_node(spec_data, node_id, cascade=cascade):
+                applied += 1
+                changes.append({
+                    "action": action,
+                    "node_id": node_id,
+                    "status": "applied",
+                })
+            else:
+                skipped += 1
+                changes.append({
+                    "action": action,
+                    "node_id": node_id,
+                    "status": "skipped",
+                    "reason": "node not found",
+                })
+
+        else:
+            skipped += 1
+            changes.append({
+                "action": action,
+                "node_id": node_id,
+                "status": "skipped",
+                "reason": f"unknown action: {action}",
+            })
+
+    if not dry_run and applied > 0:
+        save_spec(spec_id, spec_data, specs_dir, backup=True)
+
+    return applied, skipped, changes
+
+
+def load_modifications_file(file_path: str) -> List[Dict[str, Any]]:
+    """
+    Load modifications from a JSON file.
+
+    Args:
+        file_path: Path to the modifications JSON file
+
+    Returns:
+        List of modification dictionaries
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        json.JSONDecodeError: If file is not valid JSON
+    """
+    path = Path(file_path)
+    if not path.exists():
+        raise FileNotFoundError(f"Modifications file not found: {file_path}")
+
+    with open(path, 'r') as f:
+        data = json.load(f)
+
+    return data.get("modifications", [])
+
+
+def _add_node(
+    spec_data: Dict[str, Any],
+    node_id: str,
+    node_data: Dict[str, Any],
+    parent_id: Optional[str] = None,
+) -> bool:
+    """
+    Add a new node to the spec hierarchy.
+
+    Args:
+        spec_data: Spec data dictionary
+        node_id: ID for the new node
+        node_data: Node data to add
+        parent_id: Optional parent node ID
+
+    Returns:
+        True if node was added, False otherwise
+    """
+    hierarchy = spec_data.get("hierarchy", {})
+
+    # Don't overwrite existing nodes
+    if node_id in hierarchy:
+        return False
+
+    # Add the node
+    hierarchy[node_id] = node_data
+
+    # Update parent's children list if parent specified
+    if parent_id and parent_id in hierarchy:
+        parent = hierarchy[parent_id]
+        children = parent.get("children", [])
+        if node_id not in children:
+            children.append(node_id)
+            parent["children"] = children
+
+    return True
+
+
+def _remove_node(
+    spec_data: Dict[str, Any],
+    node_id: str,
+    cascade: bool = False,
+) -> bool:
+    """
+    Remove a node from the spec hierarchy.
+
+    Args:
+        spec_data: Spec data dictionary
+        node_id: ID of node to remove
+        cascade: If True, also remove children recursively
+
+    Returns:
+        True if node was removed, False if not found
+    """
+    hierarchy = spec_data.get("hierarchy", {})
+
+    if node_id not in hierarchy:
+        return False
+
+    node = hierarchy[node_id]
+
+    # Remove children first if cascade
+    if cascade:
+        children = node.get("children", [])
+        for child_id in children:
+            _remove_node(spec_data, child_id, cascade=True)
+
+    # Remove this node
+    del hierarchy[node_id]
+
+    # Remove from any parent's children list
+    for other_id, other_node in hierarchy.items():
+        children = other_node.get("children", [])
+        if node_id in children:
+            children.remove(node_id)
+            other_node["children"] = children
+
+    return True

foundry_mcp/core/naming.py

@@ -0,0 +1,146 @@
+"""Naming helpers for MCP tool registration."""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import json
+import logging
+import time
+from typing import Any, Callable
+
+from mcp.server.fastmcp import FastMCP
+from mcp.types import TextContent
+
+from foundry_mcp.core.observability import mcp_tool
+
+logger = logging.getLogger(__name__)
+
+
+def _minify_response(result: dict[str, Any]) -> TextContent:
+    """Convert dict to TextContent with minified JSON.
+
+    Args:
+        result: Dictionary to serialize
+
+    Returns:
+        TextContent with minified JSON string
+    """
+    return TextContent(
+        type="text",
+        text=json.dumps(result, separators=(",", ":"), default=str),
+    )
+
+
+def canonical_tool(
+    mcp: FastMCP,
+    *,
+    canonical_name: str,
+    **tool_kwargs: Any,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Decorator that registers a tool under its canonical name.
+
+    This decorator wraps the tool function to:
+    1. Register it with FastMCP under the canonical name
+    2. Apply observability instrumentation via mcp_tool
+    3. Collect error data when exceptions occur
+
+    Args:
+        mcp: FastMCP instance
+        canonical_name: The canonical name for the tool
+        **tool_kwargs: Additional kwargs passed to mcp.tool()
+
+    Returns:
+        Decorated function registered as an MCP tool
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        if asyncio.iscoroutinefunction(func):
+            # Async function - use async wrapper
+            @functools.wraps(func)
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                """Async wrapper for async underlying functions."""
+                start_time = time.perf_counter()
+                try:
+                    result = await func(*args, **kwargs)
+                    if isinstance(result, dict):
+                        return _minify_response(result)
+                    return result
+                except Exception as e:
+                    duration_ms = (time.perf_counter() - start_time) * 1000
+                    _collect_tool_error(
+                        tool_name=canonical_name,
+                        error=e,
+                        input_params=kwargs,
+                        duration_ms=duration_ms,
+                    )
+                    raise
+
+            wrapper = async_wrapper
+        else:
+            # Sync function - use sync wrapper to preserve sync behavior
+            @functools.wraps(func)
+            def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+                """Sync wrapper for sync underlying functions."""
+                start_time = time.perf_counter()
+                try:
+                    result = func(*args, **kwargs)
+                    if isinstance(result, dict):
+                        return _minify_response(result)
+                    return result
+                except Exception as e:
+                    duration_ms = (time.perf_counter() - start_time) * 1000
+                    _collect_tool_error(
+                        tool_name=canonical_name,
+                        error=e,
+                        input_params=kwargs,
+                        duration_ms=duration_ms,
+                    )
+                    raise
+
+            wrapper = sync_wrapper
+
+        # Apply mcp_tool first, then register with FastMCP
+        instrumented = mcp_tool(tool_name=canonical_name)(wrapper)
+        return mcp.tool(name=canonical_name, **tool_kwargs)(instrumented)
+
+    return decorator
+
+
+def _collect_tool_error(
+    tool_name: str,
+    error: Exception,
+    input_params: dict[str, Any],
+    duration_ms: float,
+) -> None:
+    """Collect error data for later introspection.
+
+    Uses lazy import to avoid circular dependencies and only
+    collects if error collection is enabled.
+
+    Args:
+        tool_name: Name of the tool that raised the error
+        error: The exception that was raised
+        input_params: Input parameters passed to the tool
+        duration_ms: Duration in milliseconds before error
+    """
+    try:
+        # Lazy import to avoid circular dependencies
+        from foundry_mcp.config import get_config
+
+        config = get_config()
+        if not config.error_collection.enabled:
+            return
+
+        from foundry_mcp.core.error_collection import get_error_collector
+
+        collector = get_error_collector()
+        collector.collect_tool_error(
+            tool_name=tool_name,
+            error=error,
+            input_params=input_params,
+            duration_ms=duration_ms,
+        )
+    except Exception as collect_error:
+        # Never let error collection failures affect tool execution
+        logger.debug(f"Error collection failed for {tool_name}: {collect_error}")