refactor: [#238] fix Law of Demeter violations and implement consistent delegation

This refactoring addresses two related architectural concerns:

Phase 1 - Application Layer (Law of Demeter):
- Added 4 convenience methods to Environment: database_config(), tracker_config(), admin_token(), prometheus_config()
- Updated docker_compose_templates.rs to use new methods instead of chaining through context
- Eliminates method chaining violations like self.environment.context().user_inputs.tracker.core.database

Phase 2 - Domain Layer (Consistent Delegation):
- Added 13 accessor methods to EnvironmentContext for all directly-accessed fields
- Updated 11 Environment methods to consistently delegate to context methods
- Changes pattern from direct access (self.context.user_inputs.field) to delegation (self.context.field())

Benefits:
- Single source of truth: EnvironmentContext controls field access
- Better encapsulation: Environment doesn't know context's internal structure
- Easier maintenance: Structural changes only affect EnvironmentContext
- Consistent API: All Environment methods follow same delegation pattern
- Improved testability: Can mock EnvironmentContext methods independently

All 1509 tests passing, pre-commit checks passed.

Author: josecelano

src/application/steps/rendering/docker_compose_templates.rs

@@ -109,7 +109,7 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
         let ports = self.build_tracker_ports();
 
         // Create contexts based on database configuration
-        let database_config = &self.environment.context().user_inputs.tracker.core.database;
+        let database_config = self.environment.database_config();
         let (env_context, builder) = match database_config {
             DatabaseConfig::Sqlite { .. } => Self::create_sqlite_contexts(admin_token, ports),
             DatabaseConfig::Mysql {
@@ -147,17 +147,11 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
     }
 
     fn extract_admin_token(&self) -> String {
-        self.environment
-            .context()
-            .user_inputs
-            .tracker
-            .http_api
-            .admin_token
-            .clone()
+        self.environment.admin_token().to_string()
     }
 
     fn build_tracker_ports(&self) -> TrackerPorts {
-        let tracker_config = &self.environment.context().user_inputs.tracker;
+        let tracker_config = self.environment.tracker_config();
         let (udp_tracker_ports, http_tracker_ports, http_api_port) =
             Self::extract_tracker_ports(tracker_config);
 
@@ -212,7 +206,7 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
         &self,
         builder: DockerComposeContextBuilder,
     ) -> DockerComposeContextBuilder {
-        if let Some(prometheus_config) = &self.environment.context().user_inputs.prometheus {
+        if let Some(prometheus_config) = self.environment.prometheus_config() {
             builder.with_prometheus(prometheus_config.clone())
         } else {
             builder

src/domain/environment/context.rs

@@ -282,4 +282,82 @@ impl EnvironmentContext {
     pub fn tofu_templates_dir(&self) -> PathBuf {
         self.internal_config.tofu_templates_dir()
     }
+
+    /// Returns the environment name
+    #[must_use]
+    pub fn name(&self) -> &EnvironmentName {
+        &self.user_inputs.name
+    }
+
+    /// Returns the instance name
+    #[must_use]
+    pub fn instance_name(&self) -> &crate::domain::InstanceName {
+        &self.user_inputs.instance_name
+    }
+
+    /// Returns the provider configuration
+    #[must_use]
+    pub fn provider_config(&self) -> &ProviderConfig {
+        &self.user_inputs.provider_config
+    }
+
+    /// Returns the SSH credentials
+    #[must_use]
+    pub fn ssh_credentials(&self) -> &SshCredentials {
+        &self.user_inputs.ssh_credentials
+    }
+
+    /// Returns the SSH port
+    #[must_use]
+    pub fn ssh_port(&self) -> u16 {
+        self.user_inputs.ssh_port
+    }
+
+    /// Returns the database configuration
+    #[must_use]
+    pub fn database_config(&self) -> &crate::domain::tracker::DatabaseConfig {
+        &self.user_inputs.tracker.core.database
+    }
+
+    /// Returns the tracker configuration
+    #[must_use]
+    pub fn tracker_config(&self) -> &crate::domain::tracker::TrackerConfig {
+        &self.user_inputs.tracker
+    }
+
+    /// Returns the admin token
+    #[must_use]
+    pub fn admin_token(&self) -> &str {
+        &self.user_inputs.tracker.http_api.admin_token
+    }
+
+    /// Returns the Prometheus configuration if enabled
+    #[must_use]
+    pub fn prometheus_config(&self) -> Option<&crate::domain::prometheus::PrometheusConfig> {
+        self.user_inputs.prometheus.as_ref()
+    }
+
+    /// Returns the build directory
+    #[must_use]
+    pub fn build_dir(&self) -> &PathBuf {
+        &self.internal_config.build_dir
+    }
+
+    /// Returns the data directory
+    #[must_use]
+    pub fn data_dir(&self) -> &PathBuf {
+        &self.internal_config.data_dir
+    }
+
+    /// Returns the instance IP address if available
+    #[must_use]
+    pub fn instance_ip(&self) -> Option<std::net::IpAddr> {
+        self.runtime_outputs.instance_ip
+    }
+
+    /// Returns the provision method
+    #[must_use]
+    pub fn provision_method(&self) -> Option<crate::domain::environment::ProvisionMethod> {
+        self.runtime_outputs.provision_method
+    }
 }

src/domain/environment/mod.rs

@@ -131,6 +131,9 @@ pub use crate::domain::tracker::{
     UdpTrackerConfig,
 };
 
+// Re-export Prometheus types for convenience
+pub use crate::domain::prometheus::PrometheusConfig;
+
 use crate::adapters::ssh::SshCredentials;
 use crate::domain::provider::ProviderConfig;
 use crate::domain::{InstanceName, ProfileName};
@@ -400,25 +403,49 @@ impl<S> Environment<S> {
     /// Returns the instance name for this environment
     #[must_use]
     pub fn instance_name(&self) -> &InstanceName {
-        &self.context.user_inputs.instance_name
+        self.context.instance_name()
     }
 
     /// Returns the provider configuration for this environment
     #[must_use]
     pub fn provider_config(&self) -> &ProviderConfig {
-        &self.context.user_inputs.provider_config
+        self.context.provider_config()
     }
 
     /// Returns the SSH credentials for this environment
     #[must_use]
     pub fn ssh_credentials(&self) -> &SshCredentials {
-        &self.context.user_inputs.ssh_credentials
+        self.context.ssh_credentials()
     }
 
     /// Returns the SSH port for this environment
     #[must_use]
     pub fn ssh_port(&self) -> u16 {
-        self.context.user_inputs.ssh_port
+        self.context.ssh_port()
+    }
+
+    /// Returns the database configuration for this environment
+    #[must_use]
+    pub fn database_config(&self) -> &DatabaseConfig {
+        self.context.database_config()
+    }
+
+    /// Returns the tracker configuration for this environment
+    #[must_use]
+    pub fn tracker_config(&self) -> &TrackerConfig {
+        self.context.tracker_config()
+    }
+
+    /// Returns the admin token for the HTTP API
+    #[must_use]
+    pub fn admin_token(&self) -> &str {
+        self.context.admin_token()
+    }
+
+    /// Returns the Prometheus configuration if enabled
+    #[must_use]
+    pub fn prometheus_config(&self) -> Option<&PrometheusConfig> {
+        self.context.prometheus_config()
     }
 
     /// Returns the SSH username for this environment
@@ -442,13 +469,13 @@ impl<S> Environment<S> {
     /// Returns the build directory for this environment
     #[must_use]
     pub fn build_dir(&self) -> &PathBuf {
-        &self.context.internal_config.build_dir
+        self.context.build_dir()
     }
 
     /// Returns the data directory for this environment
     #[must_use]
     pub fn data_dir(&self) -> &PathBuf {
-        &self.context.internal_config.data_dir
+        self.context.data_dir()
     }
 
     /// Returns the instance IP address if available
@@ -496,7 +523,7 @@ impl<S> Environment<S> {
     /// ```
     #[must_use]
     pub fn instance_ip(&self) -> Option<IpAddr> {
-        self.context.runtime_outputs.instance_ip
+        self.context.instance_ip()
     }
 
     /// Returns the provision method for this environment
@@ -511,7 +538,7 @@ impl<S> Environment<S> {
     /// The provision method, if set.
     #[must_use]
     pub fn provision_method(&self) -> Option<ProvisionMethod> {
-        self.context.runtime_outputs.provision_method
+        self.context.provision_method()
     }
 
     /// Returns whether this environment's infrastructure is managed by this tool