support file details when expand

evanliu048 · evanliu048 · commit a44f8142ec68 · 2025-09-16T19:46:34.000-07:00
diff --git a/crates/chat-cli/src/cli/chat/capture.rs b/crates/chat-cli/src/cli/chat/capture.rs
@@ -9,6 +9,7 @@ use chrono::{
     DateTime,
     Local,
 };
+use crossterm::style::Stylize;
 use eyre::{
     Result,
     bail,
@@ -21,7 +22,6 @@ use serde::{
 
 use crate::cli::ConversationState;
 use crate::os::Os;
-
 // The shadow repo path that MUST be appended with a session-specific directory
 // pub const SHADOW_REPO_DIR: &str = "/Users/aws/.amazonq/cli-captures/";
 
@@ -43,6 +43,16 @@ pub struct CaptureManager {
     /// If true, delete the current session's shadow repo directory when dropped.
     #[serde(default)]
     pub clean_on_drop: bool,
+    /// Track file changes for each capture
+    #[serde(default)]
+    pub file_changes: HashMap<String, FileChangeStats>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct FileChangeStats {
+    pub added: usize,
+    pub modified: usize,
+    pub deleted: usize,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -109,9 +119,82 @@ impl CaptureManager {
             last_user_message: None,
             user_message_lock: false,
             clean_on_drop: false,
+            file_changes: HashMap::new(),
         })
     }
 
+    pub fn get_file_changes(&self, tag: &str) -> Result<FileChangeStats> {
+        let git_dir_arg = format!("--git-dir={}", self.shadow_repo_path.display());
+
+        // Get diff stats against previous tag
+        let prev_tag = if tag == "0" {
+            return Ok(FileChangeStats::default());
+        } else {
+            self.get_previous_tag(tag)?
+        };
+
+        let output = Command::new("git")
+            .args([&git_dir_arg, "diff", "--name-status", &prev_tag, tag])
+            .output()?;
+
+        if !output.status.success() {
+            bail!("Failed to get diff stats: {}", String::from_utf8_lossy(&output.stderr));
+        }
+
+        let mut stats = FileChangeStats::default();
+        for line in String::from_utf8_lossy(&output.stdout).lines() {
+            if let Some(first_char) = line.chars().next() {
+                match first_char {
+                    'A' => stats.added += 1,
+                    'M' => stats.modified += 1,
+                    'D' => stats.deleted += 1,
+                    _ => {},
+                }
+            }
+        }
+
+        Ok(stats)
+    }
+
+    fn get_previous_tag(&self, tag: &str) -> Result<String> {
+        // Parse tag format "X" or "X.Y" to get previous
+        if let Ok(turn) = tag.parse::<usize>() {
+            if turn > 0 {
+                return Ok((turn - 1).to_string());
+            }
+        } else if tag.contains('.') {
+            let parts: Vec<&str> = tag.split('.').collect();
+            if parts.len() == 2 {
+                if let Ok(tool_num) = parts[1].parse::<usize>() {
+                    if tool_num > 1 {
+                        return Ok(format!("{}.{}", parts[0], tool_num - 1));
+                    } else {
+                        return Ok(parts[0].to_string());
+                    }
+                }
+            }
+        }
+        Ok("0".to_string())
+    }
+
+    pub fn create_capture_with_stats(
+        &mut self,
+        tag: &str,
+        commit_message: &str,
+        history_index: usize,
+        is_turn: bool,
+        tool_name: Option<String>,
+    ) -> Result<()> {
+        self.create_capture(tag, commit_message, history_index, is_turn, tool_name)?;
+
+        // Store file change stats
+        if let Ok(stats) = self.get_file_changes(tag) {
+            self.file_changes.insert(tag.to_string(), stats);
+        }
+
+        Ok(())
+    }
+
     pub fn create_capture(
         &mut self,
         tag: &str,
@@ -199,20 +282,40 @@ impl CaptureManager {
         Ok(())
     }
 
-    pub fn diff(&self, tag1: &str, tag2: &str) -> Result<String> {
-        let _ = self.get_capture(tag1)?;
-        let _ = self.get_capture(tag2)?;
+    pub fn diff_detailed(&self, tag1: &str, tag2: &str) -> Result<String> {
         let git_dir_arg = format!("--git-dir={}", self.shadow_repo_path.display());
 
+        let output = Command::new("git")
+            .args([&git_dir_arg, "diff", "--name-status", tag1, tag2])
+            .output()?;
+
+        if !output.status.success() {
+            bail!("Failed to get diff: {}", String::from_utf8_lossy(&output.stderr));
+        }
+
+        let mut result = String::new();
+
+        for line in String::from_utf8_lossy(&output.stdout).lines() {
+            if let Some((status, file)) = line.split_once('\t') {
+                match status {
+                    "A" => result.push_str(&format!("  + {} (added)\n", file).green().to_string()),
+                    "M" => result.push_str(&format!("  ~ {} (modified)\n", file).yellow().to_string()),
+                    "D" => result.push_str(&format!("  - {} (deleted)\n", file).red().to_string()),
+                    _ => {},
+                }
+            }
+        }
+
         let output = Command::new("git")
             .args([&git_dir_arg, "diff", tag1, tag2, "--stat", "--color=always"])
             .output()?;
 
         if output.status.success() {
-            Ok(String::from_utf8_lossy(&output.stdout).to_string())
-        } else {
-            bail!("Failed to get diff: {}", String::from_utf8_lossy(&output.stderr));
+            result.push_str("\n");
+            result.push_str(&String::from_utf8_lossy(&output.stdout));
         }
+
+        Ok(result)
     }
 
     fn get_capture(&self, tag: &str) -> Result<&Capture> {
diff --git a/crates/chat-cli/src/cli/chat/cli/capture.rs b/crates/chat-cli/src/cli/chat/cli/capture.rs
@@ -15,6 +15,7 @@ use eyre::Result;
 use crate::cli::chat::capture::{
     Capture,
     CaptureManager,
+    FileChangeStats,
 };
 use crate::cli::chat::{
     ChatError,
@@ -56,7 +57,11 @@ pub enum CaptureSubcommand {
     Expand { tag: String },
 
     /// Display a diff between two checkpoints
-    Diff { tag1: String, tag2: String },
+    Diff {
+        tag1: String,
+        #[arg(required = false)]
+        tag2: Option<String>,
+    },
 }
 
 impl CaptureSubcommand {
@@ -196,9 +201,22 @@ impl CaptureSubcommand {
                     ));
                 },
             },
-            Self::Diff { tag1, tag2 } => match manager.diff(&tag1, &tag2) {
-                Ok(diff) => execute!(session.stderr, style::Print(diff))?,
-                Err(e) => return Err(ChatError::Custom(format!("Could not display diff: {e}").into())),
+            Self::Diff { tag1, tag2 } => {
+                // if only provide tag1, compare with current status
+                let to_tag = tag2.unwrap_or_else(|| "HEAD".to_string());
+
+                let comparison_text = if to_tag == "HEAD" {
+                    format!("Comparing current state with checkpoint [{}]:\n", tag1)
+                } else {
+                    format!("Comparing checkpoint [{}] with [{}]:\n", tag1, to_tag)
+                };
+
+                match manager.diff_detailed(&tag1, &to_tag) {
+                    Ok(diff) => {
+                        execute!(session.stderr, style::Print(comparison_text.blue()), style::Print(diff))?;
+                    },
+                    Err(e) => return Err(ChatError::Custom(format!("Could not display diff: {e}").into())),
+                }
             },
         }
 
@@ -242,6 +260,45 @@ impl TryFrom<&Capture> for CaptureDisplayEntry {
     }
 }
 
+impl CaptureDisplayEntry {
+    fn with_file_stats(capture: &Capture, manager: &CaptureManager) -> Result<Self> {
+        let mut entry = Self::try_from(capture)?;
+
+        if let Some(stats) = manager.file_changes.get(&capture.tag) {
+            let stats_str = format_file_stats(stats);
+            if !stats_str.is_empty() {
+                entry.display_parts.push(format!(" ({})", stats_str).dark_grey());
+            }
+        }
+
+        Ok(entry)
+    }
+}
+
+fn format_file_stats(stats: &FileChangeStats) -> String {
+    let mut parts = Vec::new();
+
+    if stats.added > 0 {
+        parts.push(format!(
+            "+{} file{}",
+            stats.added,
+            if stats.added == 1 { "" } else { "s" }
+        ));
+    }
+    if stats.modified > 0 {
+        parts.push(format!("modified {}", stats.modified));
+    }
+    if stats.deleted > 0 {
+        parts.push(format!(
+            "-{} file{}",
+            stats.deleted,
+            if stats.deleted == 1 { "" } else { "s" }
+        ));
+    }
+
+    parts.join(", ")
+}
+
 impl std::fmt::Display for CaptureDisplayEntry {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         for part in self.display_parts.iter() {
@@ -265,7 +322,7 @@ fn gather_all_turn_captures(manager: &CaptureManager) -> Result<Vec<CaptureDispl
         if !capture.is_turn {
             continue;
         }
-        displays.push(CaptureDisplayEntry::try_from(capture).unwrap());
+        displays.push(CaptureDisplayEntry::with_file_stats(capture, manager)?);
     }
     Ok(displays)
 }
@@ -279,7 +336,7 @@ fn expand_capture(manager: &CaptureManager, output: &mut impl Write, tag: String
         },
     };
     let capture = &manager.captures[*capture_index];
-    let display_entry = CaptureDisplayEntry::try_from(capture)?;
+    let display_entry = CaptureDisplayEntry::with_file_stats(capture, manager)?;
     execute!(output, style::Print(display_entry), style::Print("\n"))?;
 
     // If the user tries to expand a tool-level checkpoint, return early
@@ -292,7 +349,7 @@ fn expand_capture(manager: &CaptureManager, output: &mut impl Write, tag: String
             if capture.is_turn {
                 break;
             }
-            display_vec.push(CaptureDisplayEntry::try_from(&manager.captures[i])?);
+            display_vec.push(CaptureDisplayEntry::with_file_stats(&manager.captures[i], manager)?);
         }
 
         for entry in display_vec.iter().rev() {
diff --git a/crates/chat-cli/src/cli/chat/mod.rs b/crates/chat-cli/src/cli/chat/mod.rs
@@ -2362,7 +2362,7 @@ impl ChatSession {
                             None => tool.tool.display_name(),
                         };
 
-                        match manager.create_capture(
+                        match manager.create_capture_with_stats(
                             &tag,
                             &commit_message,
                             self.conversation.history().len() + 1,
@@ -2853,7 +2853,7 @@ impl ChatSession {
                     manager.num_turns += 1;
                     manager.num_tools_this_turn = 0;
 
-                    match manager.create_capture(
+                    match manager.create_capture_with_stats(
                         &manager.num_turns.to_string(),
                         &truncate_message(&user_message, CAPTURE_MESSAGE_MAX_LENGTH),
                         self.conversation.history().len(),
