Fallback behavior for Paths & Env Variables (#3360)

- Path fall back .amazonq to .kiro migration functionality
- Support workspace and global path migration
- Maintain backward compatibility with existing .amazonq configs
- Follow proper precedence rules (kiro > amazonq when both exist)
- Add comprehensive unit tests covering all migration scenarios

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/agent_config/mod.rs

@@ -34,8 +34,6 @@ use tracing::{
 use super::util::directories::{
     global_agents_path,
     legacy_global_mcp_config_path,
-};
-use crate::agent::util::directories::{
     legacy_workspace_mcp_config_path,
     local_agents_path,
 };

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

@@ -14,7 +14,6 @@ use super::error::{
 use crate::agent::util::consts::env_var::CLI_DATA_DIR;
 
 const DATA_DIR_NAME: &str = "amazon-q";
-const AWS_DIR_NAME: &str = "amazonq";
 
 type Result<T, E = UtilError> = std::result::Result<T, E>;
 
@@ -57,28 +56,50 @@ pub fn settings_schema_path(base: impl AsRef<Path>) -> PathBuf {
     base.as_ref().join("settings_schema.json")
 }
 
+fn resolve_migrated_path(is_global: bool, subpath: &str) -> Result<PathBuf> {
+    let (kiro_base, amazonq_base) = if is_global {
+        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")?;
+        (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);
+            Ok(kiro_base.join(subpath))
+        },
+        (false, true) => {
+            warn!("Migration notice: Using .amazonq {} configs", scope);
+            Ok(amazonq_base.join(subpath))
+        },
+        (true, true) => {
+            warn!("Both .amazonq and .kiro {} configs exist, using .amazonq", scope);
+            Ok(amazonq_base.join(subpath))
+        },
+        (false, false) => Ok(kiro_base.join(subpath)), // Default to kiro
+    }
+}
+
 /// Path to the directory containing local agent configs.
 pub fn local_agents_path() -> Result<PathBuf> {
-    Ok(env::current_dir()
-        .context("unable to get the current directory")?
-        .join(format!(".{AWS_DIR_NAME}"))
-        .join("cli-agents"))
+    resolve_migrated_path(false, "cli-agents")
 }
 
 /// Path to the directory containing global agent configs.
 pub fn global_agents_path() -> Result<PathBuf> {
-    Ok(home_dir()?.join(".aws").join(AWS_DIR_NAME).join("cli-agents"))
+    resolve_migrated_path(true, "cli-agents")
 }
 
 /// Legacy workspace MCP server config path
 pub fn legacy_workspace_mcp_config_path() -> Result<PathBuf> {
-    Ok(env::current_dir()
-        .context("unable to get the current directory")?
-        .join(format!(".{AWS_DIR_NAME}"))
-        .join("mcp.json"))
+    resolve_migrated_path(false, "mcp.json")
 }
 
 /// Legacy global MCP server config path
 pub fn legacy_global_mcp_config_path() -> Result<PathBuf> {
-    Ok(home_dir()?.join(".aws").join(AWS_DIR_NAME).join("mcp.json"))
+    resolve_migrated_path(true, "mcp.json")
 }

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

@@ -197,7 +197,6 @@ impl Default for Agent {
             resources: {
                 let mut resources = Vec::new();
                 resources.extend(paths::workspace::DEFAULT_AGENT_RESOURCES.iter().map(|&s| s.into()));
-                resources.push(format!("file://{}", paths::workspace::RULES_PATTERN).into());
                 resources
             },
             hooks: Default::default(),
@@ -740,6 +739,13 @@ impl Agents {
 
             all_agents.push({
                 let mut agent = Agent::default();
+
+                // Add rules pattern using dynamic path resolution
+                if let Ok(rules_dir) = resolver.workspace().rules_dir() {
+                    let rules_pattern = paths::workspace::RULES_PATTERN.replace("{}", &rules_dir.display().to_string());
+                    agent.resources.push(rules_pattern.into());
+                }
+
                 if mcp_enabled {
                     'load_legacy_mcp_json: {
                         if global_mcp_config.is_none() {

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

@@ -25,7 +25,6 @@ use super::{
 use crate::database::settings::Setting;
 use crate::os::Os;
 use crate::theme::StyledText;
-use crate::util::paths;
 use crate::util::paths::PathResolver;
 
 #[derive(Clone, Debug, Subcommand, PartialEq, Eq)]
@@ -336,7 +335,7 @@ pub async fn create_agent(
             bail!("Path must be a directory");
         }
 
-        path.join(paths::workspace::AGENTS_DIR)
+        PathResolver::new(os).workspace().agents_dir()?
     } else {
         PathResolver::new(os).global().agents_dir()?
     };

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

@@ -733,10 +733,14 @@ impl PromptsArgs {
             }
 
             if !global_prompts.is_empty() {
+                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 ({}):", crate::util::paths::global::PROMPTS_DIR)),
+                    style::Print(&format!("Global ({global_dir}):")),
                     StyledText::reset_attributes(),
                     style::Print("\n"),
                 )?;
@@ -750,10 +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_or_else(|_| "local prompts".to_string(), |p| p.display().to_string());
                 queue!(
                     session.stderr,
                     style::SetAttribute(Attribute::Bold),
-                    style::Print(&format!("Local ({}):", crate::util::paths::workspace::PROMPTS_DIR)),
+                    style::Print(&format!("Local ({local_dir}):")),
                     StyledText::reset_attributes(),
                     style::Print("\n"),
                 )?;
@@ -2069,8 +2077,8 @@ mod tests {
         let temp_dir = TempDir::new().unwrap();
 
         // Create test prompts in temp directory structure
-        let global_dir = temp_dir.path().join(crate::util::paths::global::PROMPTS_DIR);
-        let local_dir = temp_dir.path().join(crate::util::paths::workspace::PROMPTS_DIR);
+        let global_dir = temp_dir.path().join(".aws/amazonq/prompts");
+        let local_dir = temp_dir.path().join(".amazonq/prompts");
 
         create_prompt_file(&global_dir, "global_only", "Global content");
         create_prompt_file(&global_dir, "shared", "Global shared");
@@ -2090,8 +2098,8 @@ mod tests {
         let temp_dir = TempDir::new().unwrap();
 
         // Create global and local directories
-        let global_dir = temp_dir.path().join(crate::util::paths::global::PROMPTS_DIR);
-        let local_dir = temp_dir.path().join(crate::util::paths::workspace::PROMPTS_DIR);
+        let global_dir = temp_dir.path().join(".aws/amazonq/prompts");
+        let local_dir = temp_dir.path().join(".amazonq/prompts");
 
         // Create prompts: one with same name in both directories, one unique to each
         create_prompt_file(&global_dir, "shared", "Global version");

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))
 }