class CapabilityImprover:
    def __init__(self):
        self.registry = {}  # Key: capability name (str), Value: capability code (str)
        self.repository = {}  # Key: capability name (str), Value: capability object or module

    def onboard_capability(self, name: str, description: str, code: str) -> None:
        """Onboards a new capability into the system."""
        if name.lower() not in self.registry:
            optimized_name = f"optimized_{name}" if "optimized" not in name else name
            # Add both non-optimized and optimized versions to the repository
            self.repository[name] = {"description": description, "code": code}
            self.repository[optimized_name] = {
                "description": f"{description} Optimized Version",
                "code": f"Optimized version of {name}"
            }
            # Update the registry with the capability's information
            self.registry[name.lower()] = (description, optimized_name)

    def optimize_capability(self, name: str) -> None:
        """Optimizes an existing capability."""
        if name in self.repository:
            current_version = self.repository[name]
            # Check if already optimized
            if "optimized" not in name:
                new_name = f"{name}_optimized"
                # Create an optimized version
                optimized_code = f"This is the optimized version of {name}"
                self.repository[new_name] = {
                    "description": current_version["description"] + " (Optimized)",
                    "code": optimized_code
                }
            else:
                print(f"Capability {name} is already optimized.")

    def manage_dependencies(self, capability_name: str) -> None:
        """Manages dependencies for a given capability."""
        if capability_name in self.repository:
            dependencies = self.get_dependencies(capability_name)
            # Build dependencies first
            for dep in dependencies:
                self.build_capability(dep)
            # Then build the main capability
            print(f"Building {capability_name} after its dependencies.")

    def get_dependencies(self, capability_name: str) -> list:
        """Returns a list of dependencies for the given capability."""
        if capability_name in self.repository:
            return [dep["name"] for dep in self.registry.get("dependencies", [])]
        return []

    def build_capability(self, name: str) -> None:
        """Orchestrates the building process of a capability."""
        print(f"Building capability: {name}")
        # Onboard if not present
        if name.lower() not in self.registry:
            self.onboard_capability(name, "Default Description", "Sample code for new capability")
        # Optimize if needed
        self.optimize_capability(name)
        # Manage dependencies
        self.manage_dependencies(name)
        print(f"Successfully built: {name}")

# Example usage:
improver = CapabilityImprover()
improver.build_capability("basic_arithmetic")  # Onboards and builds
improver.build_capability("optimized_basic_arithmetic")  # Uses optimized version