feat(62.1-01): add environment fields to PlatformSession

Alex Holmberg · claude · Alex Holmberg · commit 41ec59b70381 · 2026-01-17T19:13:45.000+01:00
- Add environment_id and environment_name fields to PlatformSession
- Add with_environment() constructor for full context
- Add is_environment_selected() method
- Add clear_environment() method (keeps project, clears env)
- Update display_context() to show [org/project/env] format
- Update org select to include environment fields
- Add comprehensive tests for environment functionality

Co-Authored-By: Claude &lt;noreply@anthropic.com&gt;
diff --git a/src/lib.rs b/src/lib.rs
@@ -516,12 +516,14 @@ pub async fn run_command(command: Commands) -> Result<()> {
 
                     match client.get_organization(&id).await {
                         Ok(org) => {
-                            // Create session with org only (clear any project selection)
+                            // Create session with org only (clear any project/env selection)
                             let session = PlatformSession {
                                 project_id: None,
                                 project_name: None,
                                 org_id: Some(org.id.clone()),
                                 org_name: Some(org.name.clone()),
+                                environment_id: None,
+                                environment_name: None,
                                 last_updated: Some(chrono::Utc::now()),
                             };
 
diff --git a/src/platform/session.rs b/src/platform/session.rs
@@ -9,10 +9,10 @@ use std::fs;
 use std::io;
 use std::path::PathBuf;
 
-/// Platform session state - tracks selected project and organization
+/// Platform session state - tracks selected project, organization, and environment
 ///
 /// This is a separate system from conversation persistence - it tracks
-/// which platform project/org the user has selected for platform operations.
+/// which platform project/org/environment the user has selected for platform operations.
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct PlatformSession {
     /// Selected platform project UUID
@@ -23,6 +23,10 @@ pub struct PlatformSession {
     pub org_id: Option<String>,
     /// Organization name
     pub org_name: Option<String>,
+    /// Selected environment UUID
+    pub environment_id: Option<String>,
+    /// Human-readable environment name
+    pub environment_name: Option<String>,
     /// When the session was last updated
     pub last_updated: Option<DateTime<Utc>>,
 }
@@ -45,16 +49,47 @@ impl PlatformSession {
             project_name: Some(project_name),
             org_id: Some(org_id),
             org_name: Some(org_name),
+            environment_id: None,
+            environment_name: None,
             last_updated: Some(Utc::now()),
         }
     }
 
-    /// Clears the selected project
+    /// Creates a platform session with a selected project and environment
+    pub fn with_environment(
+        project_id: String,
+        project_name: String,
+        org_id: String,
+        org_name: String,
+        environment_id: String,
+        environment_name: String,
+    ) -> Self {
+        Self {
+            project_id: Some(project_id),
+            project_name: Some(project_name),
+            org_id: Some(org_id),
+            org_name: Some(org_name),
+            environment_id: Some(environment_id),
+            environment_name: Some(environment_name),
+            last_updated: Some(Utc::now()),
+        }
+    }
+
+    /// Clears the selected project and environment
     pub fn clear(&mut self) {
         self.project_id = None;
         self.project_name = None;
         self.org_id = None;
         self.org_name = None;
+        self.environment_id = None;
+        self.environment_name = None;
+        self.last_updated = Some(Utc::now());
+    }
+
+    /// Clears only the selected environment (keeps project)
+    pub fn clear_environment(&mut self) {
+        self.environment_id = None;
+        self.environment_name = None;
         self.last_updated = Some(Utc::now());
     }
 
@@ -63,6 +98,11 @@ impl PlatformSession {
         self.project_id.is_some()
     }
 
+    /// Returns true if an environment is currently selected
+    pub fn is_environment_selected(&self) -> bool {
+        self.environment_id.is_some()
+    }
+
     /// Returns the path to the platform session file
     ///
     /// Location: `~/.syncable/platform-session.json`
@@ -105,11 +145,13 @@ impl PlatformSession {
 
     /// Returns a display string for the current context
     ///
-    /// Format: "[org/project]" or "[no project selected]"
+    /// Format: "[org/project/env]", "[org/project]", or "[no project selected]"
     pub fn display_context(&self) -> String {
-        match (&self.org_name, &self.project_name) {
-            (Some(org), Some(project)) => format!("[{}/{}]", org, project),
-            (None, Some(project)) => format!("[{}]", project),
+        match (&self.org_name, &self.project_name, &self.environment_name) {
+            (Some(org), Some(project), Some(env)) => format!("[{}/{}/{}]", org, project, env),
+            (Some(org), Some(project), None) => format!("[{}/{}]", org, project),
+            (None, Some(project), Some(env)) => format!("[{}/{}]", project, env),
+            (None, Some(project), None) => format!("[{}]", project),
             _ => "[no project selected]".to_string(),
         }
     }
@@ -157,7 +199,18 @@ mod tests {
 
     #[test]
     fn test_display_context() {
-        // Full context
+        // Full context with environment
+        let session = PlatformSession::with_environment(
+            "id".to_string(),
+            "project".to_string(),
+            "oid".to_string(),
+            "org".to_string(),
+            "env-id".to_string(),
+            "prod".to_string(),
+        );
+        assert_eq!(session.display_context(), "[org/project/prod]");
+
+        // Project only (no env)
         let session = PlatformSession::with_project(
             "id".to_string(),
             "project".to_string(),
@@ -172,6 +225,8 @@ mod tests {
             project_name: Some("project".to_string()),
             org_id: None,
             org_name: None,
+            environment_id: None,
+            environment_name: None,
             last_updated: None,
         };
         assert_eq!(session.display_context(), "[project]");
@@ -181,6 +236,69 @@ mod tests {
         assert_eq!(session.display_context(), "[no project selected]");
     }
 
+    #[test]
+    fn test_with_environment() {
+        let session = PlatformSession::with_environment(
+            "proj-123".to_string(),
+            "my-project".to_string(),
+            "org-456".to_string(),
+            "my-org".to_string(),
+            "env-789".to_string(),
+            "production".to_string(),
+        );
+
+        assert!(session.is_project_selected());
+        assert!(session.is_environment_selected());
+        assert_eq!(session.project_id, Some("proj-123".to_string()));
+        assert_eq!(session.environment_id, Some("env-789".to_string()));
+        assert_eq!(session.environment_name, Some("production".to_string()));
+        assert_eq!(session.display_context(), "[my-org/my-project/production]");
+    }
+
+    #[test]
+    fn test_clear_environment() {
+        let mut session = PlatformSession::with_environment(
+            "proj-123".to_string(),
+            "my-project".to_string(),
+            "org-456".to_string(),
+            "my-org".to_string(),
+            "env-789".to_string(),
+            "production".to_string(),
+        );
+
+        assert!(session.is_environment_selected());
+
+        session.clear_environment();
+
+        assert!(session.is_project_selected()); // Project still selected
+        assert!(!session.is_environment_selected()); // Environment cleared
+        assert_eq!(session.display_context(), "[my-org/my-project]");
+    }
+
+    #[test]
+    fn test_is_environment_selected() {
+        let session = PlatformSession::new();
+        assert!(!session.is_environment_selected());
+
+        let session = PlatformSession::with_project(
+            "proj-123".to_string(),
+            "my-project".to_string(),
+            "org-456".to_string(),
+            "my-org".to_string(),
+        );
+        assert!(!session.is_environment_selected());
+
+        let session = PlatformSession::with_environment(
+            "proj-123".to_string(),
+            "my-project".to_string(),
+            "org-456".to_string(),
+            "my-org".to_string(),
+            "env-789".to_string(),
+            "staging".to_string(),
+        );
+        assert!(session.is_environment_selected());
+    }
+
     #[test]
     fn test_save_and_load() {
         // Use a temp directory for testing
