class MetaCapabilityManager:
    def __init__(self):
        """Initialize the META-capability manager to handle capability registration and management."""
        self.capabilities = {}  # Dictionary to store registered capabilities
        self_capability_id = "META-Capability-Manager"
        self.register_capability(self_capability_id, 
                                "Meta Capability Manager",
                                "Manages and improves other capabilities",
                                "1.0.0")

    def register_capability(self, capability_id: str, name: str, description: str, version: str):
        """Register a new capability with the system."""
        if capability_id in self.capabilities:
            raise ValueError(f"Capability with ID {capability_id} already exists.")
        
        # Create a Capability object and store it
        self.capabilities[capability_id] = {
            "id": capability_id,
            "name": name,
            "description": description,
            "version": version,
            "dependencies": [],
            "handlers": {}  # Key: task (build, deploy), Value: handler function
        }

    def unregister_capability(self, capability_id: str):
        """Unregister an existing capability."""
        if capability_id not in self.capabilities:
            raise ValueError(f"Capability with ID {capability_id} does not exist.")
        
        del self.capabilities[capability_id]

    def list_capabilities(self) -> dict:
        """List all registered capabilities and their details."""
        return {
            "total": len(self.capabilities),
            "capabilities": [
                {
                    "id": cap["id"],
                    "name": cap["name"],
                    "description": cap["description"],
                    "version": cap["version"]
                }
                for cap in self.capabilities.values()
            ]
        }

    def has_capability(self, capability_id: str) -> bool:
        """Check if a capability is registered."""
        return capability_id in self.capabilities

    def call_capabilities(self, task: str):
        """Call all capabilities that can handle the specified task (e.g., build, deploy)."""
        for cap_id, capability in self.capabilities.items():
            handler = capability["handlers"].get(task)
            if handler:
                try:
                    result = handler()
                    # Record success
                    capability["success"] = True
                except Exception as e:
                    # Record failure
                    capability["success"] = False
                    raise RuntimeError(f"Capability {cap_id} failed to handle {task}: {str(e)}")
            else:
                pass  # No handler for this task

    def visualize_capabilities(self):
        """Visualize the capabilities and their dependencies using graphviz."""
        import graphviz
        
        dot = graphviz.Digraph()
        
        for cap in self.capabilities.values():
            node_id = f"node_{cap['id']}"
            label = (
                f"{cap['name']}\n"
                f"ID: {cap['id']}\n"
                f"Version: {cap['version']}\n"
                f"Dependencies: {', '.join(cap['dependencies']) if cap['dependencies'] else 'None'}\n"
                f"Success Status: {'✓' if 'success' in cap and cap['success'] else '✗'}"
            )
            dot.node(node_id, label)
            
            # Add edges based on dependencies
            for dep in cap.get('dependencies', []):
                if dep in self.capabilities:
                    dep_node = f"node_{dep}"
                    dot.edge(node_id, dep_node)
        
        return dot

    def __repr__(self) -> str:
        """String representation of the Meta Capability Manager."""
        return (
            f"MetaCapabilityManager(\n"
            f"\tCapabilities: {list(self.capabilities.keys())},\n"
            f"\tTotal capabilities: {len(self.capabilities)}\n)"
        )

# Example usage:
if __name__ == "__main__":
    manager = MetaCapabilityManager()

    # Register a new capability
    def build_capability():
        print("Building capability...")

    def deploy_capability():
        print("Deploying capability...")

    manager.register_capability(
        "CAP-001",
        "Basic Build Capability",
        "Handles basic building functionality.",
        "0.9.0",
        ["META-Capability-Manager"],
        {
            "build": build_capability,
            "deploy": deploy_capability
        }
    )

    # List capabilities
    print(manager.list_capabilities())

    # Test capability registration and execution
    try:
        manager.call_capabilities("build")
    except RuntimeError as e:
        print(f"Error during capability execution: {str(e)}")

    # Visualize the capability graph
    dot_graph = manager.visualize_capabilities()
    dot_graph.view()  # This will create a temporary file and open it in your default viewer