Implement fall back behavior for Q_ / KIRO_ / Paths

Author: dk19y

Cargo.toml

@@ -178,7 +178,7 @@ manual_ok_or = "warn"
 map_err_ignore = "warn"
 map_flatten = "warn"
 map_unwrap_or = "warn"
-match_on_vec_items = "warn"
+
 # match_same_arms = "warn"
 match_wild_err_arm = "warn"
 match_wildcard_for_single_variants = "warn"

crates/agent/src/agent/util/directories.rs

@@ -61,13 +61,12 @@ fn resolve_migrated_path(is_global: bool, subpath: &str) -> Result<PathBuf> {
         let home = home_dir()?;
         (home.join(".aws/kiro"), home.join(".aws/amazonq"))
     } else {
-        let cwd = env::current_dir()
-            .context("unable to get the current directory")?;
+        let cwd = env::current_dir().context("unable to get the current directory")?;
         (cwd.join(".kiro"), cwd.join(".amazonq"))
     };
-    
+
     let scope = if is_global { "global" } else { "workspace" };
-    
+
     match (kiro_base.exists(), amazonq_base.exists()) {
         (true, false) => {
             warn!("Using .kiro {} configuration", scope);

crates/chat-cli/src/cli/agent/mod.rs

@@ -741,16 +741,20 @@ impl Agents {
 
             all_agents.push({
                 let mut agent = Agent::default();
-                
+
                 // Update rules pattern to use dynamic path resolution
                 if let Ok(rules_dir) = resolver.workspace().rules_dir() {
                     let rules_pattern = format!("{}/**/*.md", rules_dir.display());
                     // Replace the hardcoded rules pattern with the dynamic one
-                    if let Some(pos) = agent.resources.iter().position(|r| r.as_str().contains(".amazonq/rules/")) {
-                        agent.resources[pos] = format!("file://{}", rules_pattern).into();
+                    if let Some(pos) = agent
+                        .resources
+                        .iter()
+                        .position(|r| r.as_str().contains(".amazonq/rules/"))
+                    {
+                        agent.resources[pos] = format!("file://{rules_pattern}").into();
                     }
                 }
-                
+
                 if mcp_enabled {
                     'load_legacy_mcp_json: {
                         if global_mcp_config.is_none() {

crates/chat-cli/src/cli/chat/cli/prompts.rs

@@ -733,13 +733,14 @@ impl PromptsArgs {
             }
 
             if !global_prompts.is_empty() {
-                let global_dir = PathResolver::new(os).global().prompts_dir()
-                    .map(|p| p.display().to_string())
-                    .unwrap_or_else(|_| "global prompts".to_string());
+                let global_dir = PathResolver::new(os)
+                    .global()
+                    .prompts_dir()
+                    .map_or_else(|_| "global prompts".to_string(), |p| p.display().to_string());
                 queue!(
                     session.stderr,
                     style::SetAttribute(Attribute::Bold),
-                    style::Print(&format!("Global ({}):", global_dir)),
+                    style::Print(&format!("Global ({global_dir}):")),
                     StyledText::reset_attributes(),
                     style::Print("\n"),
                 )?;
@@ -753,13 +754,14 @@ impl PromptsArgs {
                 if !global_prompts.is_empty() {
                     queue!(session.stderr, style::Print("\n"))?;
                 }
-                let local_dir = PathResolver::new(os).workspace().prompts_dir()
-                    .map(|p| p.display().to_string())
-                    .unwrap_or_else(|_| "local prompts".to_string());
+                let local_dir = PathResolver::new(os)
+                    .workspace()
+                    .prompts_dir()
+                    .map_or_else(|_| "local prompts".to_string(), |p| p.display().to_string());
                 queue!(
                     session.stderr,
                     style::SetAttribute(Attribute::Bold),
-                    style::Print(&format!("Local ({}):", local_dir)),
+                    style::Print(&format!("Local ({local_dir}):")),
                     StyledText::reset_attributes(),
                     style::Print("\n"),
                 )?;

crates/chat-cli/src/cli/chat/tool_manager.rs

@@ -2213,8 +2213,8 @@ mod tests {
         let path = workspace_mcp_config_path(&os)?;
         let path_str = path.to_string_lossy();
 
-        // Should end with .amazonq/mcp.json
-        assert!(path_str.ends_with(".amazonq/mcp.json"));
+        // Should end with .kiro/mcp.json (default fallback)
+        assert!(path_str.ends_with(".kiro/mcp.json"));
 
         Ok(())
     }

crates/chat-cli/src/util/consts.rs

@@ -35,69 +35,93 @@ pub mod env_var {
 
         /// The current parent socket to connect to
         Q_PARENT = "Q_PARENT",
+        KIRO_PARENT = "KIRO_PARENT",
 
-        /// Set the [`Q_PARENT`] parent socket to connect to
+        /// Set the parent socket to connect to
         Q_SET_PARENT = "Q_SET_PARENT",
+        KIRO_SET_PARENT = "KIRO_SET_PARENT",
 
-        /// Guard for the [`Q_SET_PARENT`] check
+        /// Guard for the set parent check
         Q_SET_PARENT_CHECK = "Q_SET_PARENT_CHECK",
+        KIRO_SET_PARENT_CHECK = "KIRO_SET_PARENT_CHECK",
 
         /// Set if qterm is running, contains the version
         Q_TERM = "Q_TERM",
+        KIRO_TERM = "KIRO_TERM",
 
         /// Sets the current log level
         Q_LOG_LEVEL = "Q_LOG_LEVEL",
+        KIRO_LOG_LEVEL = "KIRO_LOG_LEVEL",
 
         /// Overrides the ZDOTDIR environment variable
         Q_ZDOTDIR = "Q_ZDOTDIR",
+        KIRO_ZDOTDIR = "KIRO_ZDOTDIR",
 
         /// Indicates a process was launched by Kiro
         PROCESS_LAUNCHED_BY_Q = "PROCESS_LAUNCHED_BY_Q",
+        PROCESS_LAUNCHED_BY_KIRO = "PROCESS_LAUNCHED_BY_KIRO",
 
         /// The shell to use in qterm
         Q_SHELL = "Q_SHELL",
+        KIRO_SHELL = "KIRO_SHELL",
 
         /// Indicates the user is debugging the shell
         Q_DEBUG_SHELL = "Q_DEBUG_SHELL",
+        KIRO_DEBUG_SHELL = "KIRO_DEBUG_SHELL",
 
         /// Indicates the user is using zsh autosuggestions which disables Inline
         Q_USING_ZSH_AUTOSUGGESTIONS = "Q_USING_ZSH_AUTOSUGGESTIONS",
+        KIRO_USING_ZSH_AUTOSUGGESTIONS = "KIRO_USING_ZSH_AUTOSUGGESTIONS",
 
         /// Overrides the path to the bundle metadata released with certain desktop builds.
         Q_BUNDLE_METADATA_PATH = "Q_BUNDLE_METADATA_PATH",
+        KIRO_BUNDLE_METADATA_PATH = "KIRO_BUNDLE_METADATA_PATH",
 
         /// Identifier for the client application or service using the chat-cli
         Q_CLI_CLIENT_APPLICATION = "Q_CLI_CLIENT_APPLICATION",
+        KIRO_CLI_CLIENT_APPLICATION = "KIRO_CLI_CLIENT_APPLICATION",
 
         /// Shows continuation IDs in chat output for debugging/development
         Q_SHOW_CONTINUATION_IDS = "Q_SHOW_CONTINUATION_IDS",
-
-        /// Flag for running integration tests
-        CLI_IS_INTEG_TEST = "Q_CLI_IS_INTEG_TEST",
-
-        /// Enable logging to stdout
-        Q_LOG_STDOUT = "Q_LOG_STDOUT",
-
-        /// Disable telemetry collection
-        Q_DISABLE_TELEMETRY = "Q_DISABLE_TELEMETRY",
+        KIRO_SHOW_CONTINUATION_IDS = "KIRO_SHOW_CONTINUATION_IDS",
 
         /// Mock chat response for testing
         Q_MOCK_CHAT_RESPONSE = "Q_MOCK_CHAT_RESPONSE",
+        KIRO_MOCK_CHAT_RESPONSE = "KIRO_MOCK_CHAT_RESPONSE",
 
-        /// Disable truecolor terminal support
+        /// Disable truecolor output
         Q_DISABLE_TRUECOLOR = "Q_DISABLE_TRUECOLOR",
+        KIRO_DISABLE_TRUECOLOR = "KIRO_DISABLE_TRUECOLOR",
+
+        /// Log to stdout
+        Q_LOG_STDOUT = "Q_LOG_STDOUT",
+        KIRO_LOG_STDOUT = "KIRO_LOG_STDOUT",
+
+        /// Disable telemetry
+        Q_DISABLE_TELEMETRY = "Q_DISABLE_TELEMETRY",
+        KIRO_DISABLE_TELEMETRY = "KIRO_DISABLE_TELEMETRY",
 
-        /// Fake remote environment for testing
+        /// Fake remote environment
         Q_FAKE_IS_REMOTE = "Q_FAKE_IS_REMOTE",
+        KIRO_FAKE_IS_REMOTE = "KIRO_FAKE_IS_REMOTE",
 
-        /// Codespaces environment indicator
+        /// Codespaces environment
         Q_CODESPACES = "Q_CODESPACES",
+        KIRO_CODESPACES = "KIRO_CODESPACES",
 
-        /// CI environment indicator
+        /// CI environment
         Q_CI = "Q_CI",
+        KIRO_CI = "KIRO_CI",
 
         /// Telemetry client ID
         Q_TELEMETRY_CLIENT_ID = "Q_TELEMETRY_CLIENT_ID",
+        KIRO_TELEMETRY_CLIENT_ID = "KIRO_TELEMETRY_CLIENT_ID",
+
+        /// Chat shell for Unix systems
+        KIRO_CHAT_SHELL = "KIRO_CHAT_SHELL",
+
+        /// Flag for running integration tests
+        CLI_IS_INTEG_TEST = "Q_CLI_IS_INTEG_TEST",
 
         /// Amazon Q SigV4 authentication
         AMAZON_Q_SIGV4 = "AMAZON_Q_SIGV4",

crates/chat-cli/src/util/env_var.rs

@@ -1,54 +1,62 @@
 use crate::os::Env;
 use crate::util::consts::env_var::*;
 
-/// Get log level from environment
+/// Get log level from environment with fallback
 pub fn get_log_level(env: &Env) -> Result<String, std::env::VarError> {
-    env.get(Q_LOG_LEVEL)
+    env.get(KIRO_LOG_LEVEL).or_else(|_| env.get(Q_LOG_LEVEL))
 }
 
 /// Get chat shell with default fallback
 #[cfg(unix)]
 pub fn get_chat_shell() -> String {
-    Env::new()
-        .get(AMAZON_Q_CHAT_SHELL)
+    let env = Env::new();
+    env.get(KIRO_CHAT_SHELL)
+        .or_else(|_| env.get(AMAZON_Q_CHAT_SHELL))
         .unwrap_or_else(|_| "bash".to_string())
 }
 
 /// Check if stdout logging is enabled
 pub fn is_log_stdout_enabled() -> bool {
-    Env::new().get_os(Q_LOG_STDOUT).is_some()
+    let env = Env::new();
+    env.get_os(KIRO_LOG_STDOUT).is_some() || env.get_os(Q_LOG_STDOUT).is_some()
 }
 
 /// Check if telemetry is disabled
 pub fn is_telemetry_disabled() -> bool {
-    Env::new().get_os(Q_DISABLE_TELEMETRY).is_some()
+    let env = Env::new();
+    env.get_os(KIRO_DISABLE_TELEMETRY).is_some() || env.get_os(Q_DISABLE_TELEMETRY).is_some()
 }
 
 /// Get mock chat response for testing
 pub fn get_mock_chat_response(env: &Env) -> Option<String> {
-    env.get(Q_MOCK_CHAT_RESPONSE).ok()
+    env.get(KIRO_MOCK_CHAT_RESPONSE)
+        .or_else(|_| env.get(Q_MOCK_CHAT_RESPONSE))
+        .ok()
 }
 
 /// Check if truecolor is disabled
 pub fn is_truecolor_disabled() -> bool {
-    Env::new().get_os(Q_DISABLE_TRUECOLOR).is_some_and(|s| !s.is_empty())
+    let env = Env::new();
+    env.get_os(KIRO_DISABLE_TRUECOLOR).is_some_and(|s| !s.is_empty())
+        || env.get_os(Q_DISABLE_TRUECOLOR).is_some_and(|s| !s.is_empty())
 }
 
 /// Check if remote environment is faked
 pub fn is_remote_fake() -> bool {
-    Env::new().get_os(Q_FAKE_IS_REMOTE).is_some()
+    let env = Env::new();
+    env.get_os(KIRO_FAKE_IS_REMOTE).is_some() || env.get_os(Q_FAKE_IS_REMOTE).is_some()
 }
 
 /// Check if running in Codespaces
 pub fn in_codespaces() -> bool {
     let env = Env::new();
-    env.get_os(CODESPACES).is_some() || env.get_os(Q_CODESPACES).is_some()
+    env.get_os(CODESPACES).is_some() || env.get_os(KIRO_CODESPACES).is_some() || env.get_os(Q_CODESPACES).is_some()
 }
 
 /// Check if running in CI
 pub fn in_ci() -> bool {
     let env = Env::new();
-    env.get_os(CI).is_some() || env.get_os(Q_CI).is_some()
+    env.get_os(CI).is_some() || env.get_os(KIRO_CI).is_some() || env.get_os(Q_CI).is_some()
 }
 
 pub fn is_integ_test() -> bool {
@@ -57,7 +65,10 @@ pub fn is_integ_test() -> bool {
 
 /// Get CLI client application
 pub fn get_cli_client_application() -> Option<String> {
-    Env::new().get(Q_CLI_CLIENT_APPLICATION).ok()
+    let env = Env::new();
+    env.get(KIRO_CLI_CLIENT_APPLICATION)
+        .or_else(|_| env.get(Q_CLI_CLIENT_APPLICATION))
+        .ok()
 }
 
 /// Get editor with default fallback
@@ -92,5 +103,6 @@ pub fn get_all_env_vars() -> std::env::Vars {
 
 /// Get telemetry client ID
 pub fn get_telemetry_client_id(env: &Env) -> Result<String, std::env::VarError> {
-    env.get(Q_TELEMETRY_CLIENT_ID)
+    env.get(KIRO_TELEMETRY_CLIENT_ID)
+        .or_else(|_| env.get(Q_TELEMETRY_CLIENT_ID))
 }