smartify-ai 0.1.0__py3-none-any.whl

smartify/tools/mcp/registry.py

@@ -0,0 +1,130 @@
+"""MCP registry integration for Smartify.
+
+Functions for registering MCP server tools into the Smartify ToolRegistry.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from smartify.tools.base import ToolRegistry
+    from smartify.tools.mcp.client import McpClient, McpServerConfig
+
+logger = logging.getLogger(__name__)
+
+
+async def register_mcp_server(
+    registry: "ToolRegistry",
+    config: "McpServerConfig",
+    client: Optional["McpClient"] = None,
+) -> List[str]:
+    """Connect to an MCP server and register its tools in the registry.
+
+    This function:
+    1. Creates an MCP client (or uses provided one)
+    2. Connects to the MCP server
+    3. Lists available tools
+    4. Creates McpToolWrapper for each tool
+    5. Registers wrappers in the ToolRegistry
+
+    Args:
+        registry: The ToolRegistry to register tools into
+        config: MCP server configuration
+        client: Optional pre-created client (will connect if not connected)
+
+    Returns:
+        List of registered tool names (with prefix if configured)
+
+    Raises:
+        ImportError: If MCP SDK is not installed
+        ConnectionError: If connection to MCP server fails
+
+    Example:
+        from smartify.tools import ToolRegistry
+        from smartify.tools.mcp import McpServerConfig, McpTransport, register_mcp_server
+
+        registry = ToolRegistry()
+
+        config = McpServerConfig(
+            id="filesystem",
+            transport=McpTransport.STDIO,
+            command="npx",
+            args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
+            prefix="fs",
+        )
+
+        tool_names = await register_mcp_server(registry, config)
+        # -> ["fs_read_file", "fs_write_file", "fs_list_directory", ...]
+    """
+    from smartify.tools.mcp.client import McpClient
+    from smartify.tools.mcp.adapter import McpToolWrapper
+
+    # Create client if not provided
+    if client is None:
+        client = McpClient(config)
+
+    # Connect if not already connected
+    if not client.is_connected:
+        await client.connect()
+
+    # List tools from the server
+    tool_defs = await client.list_tools()
+
+    if not tool_defs:
+        logger.warning(f"MCP server '{config.id}' has no tools")
+        return []
+
+    # Register each tool
+    registered_names = []
+    for tool_def in tool_defs:
+        wrapper = McpToolWrapper(
+            client=client,
+            tool_def=tool_def,
+            prefix=config.prefix,
+        )
+        registry.register(wrapper)
+        registered_names.append(wrapper.name)
+
+    logger.info(
+        f"Registered {len(registered_names)} tools from MCP server '{config.id}': "
+        f"{registered_names}"
+    )
+
+    return registered_names
+
+
+async def register_mcp_servers(
+    registry: "ToolRegistry",
+    configs: List["McpServerConfig"],
+) -> dict[str, List[str]]:
+    """Register multiple MCP servers into a registry.
+
+    Args:
+        registry: The ToolRegistry to register tools into
+        configs: List of MCP server configurations
+
+    Returns:
+        Dict mapping server ID to list of registered tool names
+
+    Example:
+        configs = [
+            McpServerConfig(id="fs", transport=McpTransport.STDIO, ...),
+            McpServerConfig(id="git", transport=McpTransport.STDIO, ...),
+        ]
+
+        results = await register_mcp_servers(registry, configs)
+        # -> {"fs": ["fs_read_file", ...], "git": ["git_status", ...]}
+    """
+    results = {}
+
+    for config in configs:
+        try:
+            tool_names = await register_mcp_server(registry, config)
+            results[config.id] = tool_names
+        except Exception as e:
+            logger.error(f"Failed to register MCP server '{config.id}': {e}")
+            results[config.id] = []
+
+    return results

smartify/validator/validate.py

@@ -0,0 +1,271 @@
+"""Grid YAML validation."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional, Set
+import yaml
+from pydantic import ValidationError
+
+from smartify.models.grid import GridSpec, NodeKind
+
+
+@dataclass
+class ValidationResult:
+    """Result of grid validation."""
+    is_valid: bool
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    grid: Optional[GridSpec] = None
+
+
+def validate_grid_file(path: Path) -> ValidationResult:
+    """Validate a Grid YAML file."""
+    errors: List[str] = []
+    warnings: List[str] = []
+    
+    # Read file
+    try:
+        with open(path) as f:
+            data = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        return ValidationResult(
+            is_valid=False,
+            errors=[f"YAML parse error: {e}"],
+        )
+    except Exception as e:
+        return ValidationResult(
+            is_valid=False,
+            errors=[f"Failed to read file: {e}"],
+        )
+    
+    if not data:
+        return ValidationResult(
+            is_valid=False,
+            errors=["File is empty or contains no valid YAML"],
+        )
+    
+    # Parse with Pydantic
+    try:
+        grid = GridSpec.model_validate(data)
+    except ValidationError as e:
+        for error in e.errors():
+            loc = ".".join(str(l) for l in error["loc"])
+            msg = error["msg"]
+            errors.append(f"{loc}: {msg}")
+        return ValidationResult(
+            is_valid=False,
+            errors=errors,
+        )
+    
+    # Semantic validation
+    semantic_errors, semantic_warnings = validate_semantics(grid)
+    errors.extend(semantic_errors)
+    warnings.extend(semantic_warnings)
+    
+    return ValidationResult(
+        is_valid=len(errors) == 0,
+        errors=errors,
+        warnings=warnings,
+        grid=grid if len(errors) == 0 else None,
+    )
+
+
+def validate_semantics(grid: GridSpec) -> tuple[List[str], List[str]]:
+    """Perform semantic validation on a parsed grid."""
+    errors: List[str] = []
+    warnings: List[str] = []
+    
+    nodes = grid.topology.nodes
+    node_ids: Set[str] = set()
+    node_map = {}
+    
+    # Build node map and check for duplicate IDs
+    for node in nodes:
+        if node.id in node_ids:
+            errors.append(f"Duplicate node ID: {node.id}")
+        node_ids.add(node.id)
+        node_map[node.id] = node
+    
+    # Count controllers
+    controllers = [n for n in nodes if n.kind == NodeKind.CONTROLLER]
+    if len(controllers) == 0:
+        errors.append("Grid must have exactly one controller node")
+    elif len(controllers) > 1:
+        errors.append(f"Grid must have exactly one controller node, found {len(controllers)}")
+    
+    # Validate parent references
+    for node in nodes:
+        if node.parent:
+            if node.parent not in node_ids:
+                errors.append(f"Node '{node.id}' references non-existent parent '{node.parent}'")
+            elif node.parent == node.id:
+                errors.append(f"Node '{node.id}' cannot be its own parent")
+    
+    # Validate controller has no parent
+    for node in nodes:
+        if node.kind == NodeKind.CONTROLLER and node.parent:
+            errors.append(f"Controller node '{node.id}' should not have a parent")
+    
+    # Validate relay parents (must be controller or another relay)
+    for node in nodes:
+        if node.kind == NodeKind.RELAY and node.parent:
+            parent = node_map.get(node.parent)
+            if parent and parent.kind not in (NodeKind.CONTROLLER, NodeKind.RELAY):
+                warnings.append(
+                    f"Relay '{node.id}' has parent '{node.parent}' of kind '{parent.kind}', "
+                    "typically relays have controller or relay parents"
+                )
+    
+    # Validate substation parents (must be relay or controller)
+    for node in nodes:
+        if node.kind == NodeKind.SUBSTATION and node.parent:
+            parent = node_map.get(node.parent)
+            if parent and parent.kind not in (NodeKind.CONTROLLER, NodeKind.RELAY):
+                warnings.append(
+                    f"Substation '{node.id}' has parent '{node.parent}' of kind '{parent.kind}', "
+                    "typically substations have relay or controller parents"
+                )
+    
+    # Validate runAfter references
+    for node in nodes:
+        if node.runAfter:
+            for dep in node.runAfter:
+                if dep not in node_ids:
+                    errors.append(f"Node '{node.id}' runAfter references non-existent node '{dep}'")
+                if dep == node.id:
+                    errors.append(f"Node '{node.id}' cannot depend on itself in runAfter")
+    
+    # Validate edges
+    if grid.topology.edges:
+        for edge in grid.topology.edges:
+            from_id = edge.from_
+            if from_id not in node_ids:
+                errors.append(f"Edge from '{from_id}' references non-existent node")
+            
+            targets = edge.to if isinstance(edge.to, list) else [edge.to]
+            for target in targets:
+                if target not in node_ids:
+                    errors.append(f"Edge to '{target}' references non-existent node")
+    
+    # Check for cycles (simplified check)
+    # TODO: Implement full cycle detection
+    
+    # Validate agent references
+    if grid.agents:
+        agent_names = set(grid.agents.keys())
+        for node in nodes:
+            if node.agent and node.agent not in agent_names:
+                errors.append(f"Node '{node.id}' references non-existent agent '{node.agent}'")
+    
+    # Validate foreach nodes have required config
+    for node in nodes:
+        if node.kind == NodeKind.FOREACH:
+            if not node.foreach:
+                errors.append(f"Foreach node '{node.id}' missing foreach configuration")
+            elif not node.foreach.body.get("to"):
+                errors.append(f"Foreach node '{node.id}' missing body.to target")
+    
+    # Validate aggregate nodes have required config
+    for node in nodes:
+        if node.kind == NodeKind.AGGREGATE:
+            if not node.aggregate:
+                errors.append(f"Aggregate node '{node.id}' missing aggregate configuration")
+    
+    # Warn if no guardrails defined
+    if not grid.guardrails:
+        warnings.append("No guardrails defined - grid will run without limits")
+    
+    # Warn about explicit execution mode without edges
+    if grid.topology.executionMode.value == "explicit" and not grid.topology.edges:
+        warnings.append(
+            "executionMode is 'explicit' but no edges defined - "
+            "consider using 'parent' mode or adding edges"
+        )
+    
+    return errors, warnings
+
+
+def validate_grid(data: dict) -> List[str]:
+    """Validate a Grid specification dict.
+    
+    Returns list of error messages (empty if valid).
+    """
+    errors: List[str] = []
+    
+    if not data:
+        return ["Empty grid specification"]
+    
+    # Pre-validation: check required top-level fields
+    if "apiVersion" not in data:
+        errors.append("Missing required field: apiVersion")
+    if "metadata" not in data:
+        errors.append("Missing required field: metadata")
+    elif isinstance(data.get("metadata"), dict):
+        if "id" not in data["metadata"]:
+            errors.append("Missing required field: metadata.id")
+    if "topology" not in data:
+        errors.append("Missing required field: topology")
+    elif isinstance(data.get("topology"), dict):
+        if "nodes" not in data["topology"]:
+            errors.append("Missing required field: topology.nodes")
+    
+    # If pre-validation fails, return early
+    if errors:
+        return errors
+    
+    try:
+        grid = GridSpec.model_validate(data)
+    except ValidationError as e:
+        for error in e.errors():
+            loc = ".".join(str(l) for l in error["loc"])
+            msg = error["msg"]
+            errors.append(f"{loc}: {msg}")
+        return errors
+    
+    semantic_errors, _ = validate_semantics(grid)
+    errors.extend(semantic_errors)
+    
+    return errors
+
+
+def validate_yaml_string(yaml_str: str) -> ValidationResult:
+    """Validate a Grid YAML string."""
+    errors: List[str] = []
+    warnings: List[str] = []
+    
+    try:
+        data = yaml.safe_load(yaml_str)
+    except yaml.YAMLError as e:
+        return ValidationResult(
+            is_valid=False,
+            errors=[f"YAML parse error: {e}"],
+        )
+    
+    if not data:
+        return ValidationResult(
+            is_valid=False,
+            errors=["Empty or invalid YAML"],
+        )
+    
+    try:
+        grid = GridSpec.model_validate(data)
+    except ValidationError as e:
+        for error in e.errors():
+            loc = ".".join(str(l) for l in error["loc"])
+            msg = error["msg"]
+            errors.append(f"{loc}: {msg}")
+        return ValidationResult(
+            is_valid=False,
+            errors=errors,
+        )
+    
+    semantic_errors, semantic_warnings = validate_semantics(grid)
+    errors.extend(semantic_errors)
+    warnings.extend(semantic_warnings)
+    
+    return ValidationResult(
+        is_valid=len(errors) == 0,
+        errors=errors,
+        warnings=warnings,
+        grid=grid if len(errors) == 0 else None,
+    )

smartify/workspace/__init__.py

@@ -0,0 +1,5 @@
+"""Workspace management for isolated grid execution."""
+
+from smartify.workspace.manager import WorkspaceManager, Workspace
+
+__all__ = ["WorkspaceManager", "Workspace"]

smartify/workspace/manager.py

@@ -0,0 +1,248 @@
+"""Workspace management for isolated grid execution.
+
+Each grid run gets its own isolated workspace directory for:
+- File operations (sandboxed)
+- Temporary files
+- Output artifacts
+"""
+
+import logging
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class WorkspaceManager:
+    """Manages isolated workspaces for grid runs.
+    
+    Each run gets a unique directory under the base workspace path.
+    Files created during execution are isolated to that directory.
+    Cleanup happens automatically on completion (configurable).
+    
+    Usage:
+        manager = WorkspaceManager(base_path="/tmp/smartify")
+        
+        # Create workspace for a run
+        ws = manager.create("run-123", "my-grid")
+        
+        # Use workspace
+        print(ws.path)  # /tmp/smartify/my-grid/run-123
+        ws.write_file("output.txt", "Hello!")
+        
+        # Cleanup when done
+        manager.cleanup("run-123")
+    """
+    
+    def __init__(
+        self,
+        base_path: Optional[str] = None,
+        auto_cleanup: bool = True,
+        preserve_on_error: bool = True,
+    ):
+        """Initialize workspace manager.
+        
+        Args:
+            base_path: Base directory for workspaces. Defaults to temp dir.
+            auto_cleanup: Automatically cleanup completed runs
+            preserve_on_error: Keep workspace if run failed (for debugging)
+        """
+        if base_path:
+            self.base_path = Path(base_path)
+            self.base_path.mkdir(parents=True, exist_ok=True)
+        else:
+            self.base_path = Path(tempfile.gettempdir()) / "smartify-workspaces"
+            self.base_path.mkdir(parents=True, exist_ok=True)
+        
+        self.auto_cleanup = auto_cleanup
+        self.preserve_on_error = preserve_on_error
+        self._workspaces: dict[str, "Workspace"] = {}
+        
+        logger.info(f"WorkspaceManager initialized at {self.base_path}")
+    
+    def create(self, run_id: str, grid_id: str) -> "Workspace":
+        """Create a new isolated workspace for a run.
+        
+        Args:
+            run_id: Unique run identifier
+            grid_id: Grid identifier (for organization)
+            
+        Returns:
+            Workspace instance
+        """
+        # Create workspace directory: base/grid_id/run_id
+        workspace_path = self.base_path / grid_id / run_id
+        workspace_path.mkdir(parents=True, exist_ok=True)
+        
+        workspace = Workspace(
+            run_id=run_id,
+            grid_id=grid_id,
+            path=workspace_path,
+        )
+        
+        self._workspaces[run_id] = workspace
+        logger.info(f"Created workspace for run {run_id}: {workspace_path}")
+        
+        return workspace
+    
+    def get(self, run_id: str) -> Optional["Workspace"]:
+        """Get workspace for a run."""
+        return self._workspaces.get(run_id)
+    
+    def cleanup(self, run_id: str, force: bool = False) -> bool:
+        """Cleanup workspace for a run.
+        
+        Args:
+            run_id: Run identifier
+            force: Force cleanup even if preserve_on_error is set
+            
+        Returns:
+            True if cleaned up, False if not found or preserved
+        """
+        workspace = self._workspaces.get(run_id)
+        if not workspace:
+            return False
+        
+        if workspace.has_error and self.preserve_on_error and not force:
+            logger.info(f"Preserving workspace for failed run {run_id}")
+            return False
+        
+        try:
+            if workspace.path.exists():
+                shutil.rmtree(workspace.path)
+                logger.info(f"Cleaned up workspace for run {run_id}")
+            
+            del self._workspaces[run_id]
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to cleanup workspace {run_id}: {e}")
+            return False
+    
+    def list_workspaces(self) -> list[str]:
+        """List all active workspace run IDs."""
+        return list(self._workspaces.keys())
+    
+    def cleanup_all(self, force: bool = False) -> int:
+        """Cleanup all workspaces.
+        
+        Args:
+            force: Force cleanup even for failed runs
+            
+        Returns:
+            Number of workspaces cleaned up
+        """
+        run_ids = list(self._workspaces.keys())
+        count = 0
+        for run_id in run_ids:
+            if self.cleanup(run_id, force=force):
+                count += 1
+        return count
+
+
+class Workspace:
+    """An isolated workspace for a single grid run.
+    
+    Provides sandboxed file operations within the workspace directory.
+    """
+    
+    def __init__(self, run_id: str, grid_id: str, path: Path):
+        self.run_id = run_id
+        self.grid_id = grid_id
+        self.path = path
+        self.created_at = datetime.now()
+        self.has_error = False
+        
+        # Create standard subdirectories
+        (self.path / "output").mkdir(exist_ok=True)
+        (self.path / "temp").mkdir(exist_ok=True)
+    
+    @property
+    def output_dir(self) -> Path:
+        """Directory for output artifacts."""
+        return self.path / "output"
+    
+    @property
+    def temp_dir(self) -> Path:
+        """Directory for temporary files."""
+        return self.path / "temp"
+    
+    def resolve(self, relative_path: str) -> Path:
+        """Resolve a relative path within the workspace.
+        
+        Raises ValueError if path escapes workspace.
+        """
+        resolved = (self.path / relative_path).resolve()
+        
+        # Security check: ensure path is within workspace
+        # Note: resolve both to handle macOS /var -> /private/var symlinks
+        try:
+            resolved.relative_to(self.path.resolve())
+        except ValueError:
+            raise ValueError(f"Path escapes workspace: {relative_path}")
+        
+        return resolved
+    
+    def write_file(self, path: str, content: str, encoding: str = "utf-8") -> Path:
+        """Write a file within the workspace.
+        
+        Args:
+            path: Relative path within workspace
+            content: File content
+            encoding: Text encoding
+            
+        Returns:
+            Absolute path to written file
+        """
+        resolved = self.resolve(path)
+        resolved.parent.mkdir(parents=True, exist_ok=True)
+        resolved.write_text(content, encoding=encoding)
+        return resolved
+    
+    def read_file(self, path: str, encoding: str = "utf-8") -> str:
+        """Read a file from the workspace.
+        
+        Args:
+            path: Relative path within workspace
+            encoding: Text encoding
+            
+        Returns:
+            File content
+        """
+        resolved = self.resolve(path)
+        return resolved.read_text(encoding=encoding)
+    
+    def exists(self, path: str) -> bool:
+        """Check if a path exists within the workspace."""
+        try:
+            resolved = self.resolve(path)
+            return resolved.exists()
+        except ValueError:
+            return False
+    
+    def list_files(self, subdir: str = ".") -> list[Path]:
+        """List files in a subdirectory."""
+        resolved = self.resolve(subdir)
+        if not resolved.is_dir():
+            return []
+        return list(resolved.iterdir())
+    
+    def mark_error(self) -> None:
+        """Mark workspace as having an error (for preservation)."""
+        self.has_error = True
+    
+    def cleanup_temp(self) -> None:
+        """Cleanup temporary files."""
+        temp_dir = self.temp_dir
+        if temp_dir.exists():
+            for item in temp_dir.iterdir():
+                if item.is_file():
+                    item.unlink()
+                elif item.is_dir():
+                    shutil.rmtree(item)
+    
+    def __repr__(self) -> str:
+        return f"Workspace(run_id={self.run_id!r}, path={self.path})"