Fix calculation for num-lines contributed by q-cli (#2738)

Author: kkashilk

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

@@ -13,6 +13,10 @@ pub struct FileLineTracker {
     pub before_fswrite_lines: usize,
     /// Line count after `fs_write` executes
     pub after_fswrite_lines: usize,
+    /// Lines added by agent in the current operation
+    pub lines_added_by_agent: usize,
+    /// Lines removed by agent in the current operation
+    pub lines_removed_by_agent: usize,
     /// Whether or not this is the first `fs_write` invocation
     pub is_first_write: bool,
 }
@@ -23,6 +27,8 @@ impl Default for FileLineTracker {
             prev_fswrite_lines: 0,
             before_fswrite_lines: 0,
             after_fswrite_lines: 0,
+            lines_added_by_agent: 0,
+            lines_removed_by_agent: 0,
             is_first_write: true,
         }
     }
@@ -34,7 +40,6 @@ impl FileLineTracker {
     }
 
     pub fn lines_by_agent(&self) -> isize {
-        let lines = (self.after_fswrite_lines as isize) - (self.before_fswrite_lines as isize);
-        lines.abs()
+        (self.lines_added_by_agent + self.lines_removed_by_agent) as isize
     }
 }

crates/chat-cli/src/cli/chat/tools/fs_write.rs

@@ -247,11 +247,57 @@ impl FsWrite {
 
         let tracker = line_tracker.entry(path.to_string_lossy().to_string()).or_default();
         tracker.after_fswrite_lines = after_lines;
+
+        // Calculate actual lines added and removed by analyzing the diff
+        let (lines_added, lines_removed) = self.calculate_diff_lines(os).await?;
+        tracker.lines_added_by_agent = lines_added;
+        tracker.lines_removed_by_agent = lines_removed;
+
         tracker.is_first_write = false;
 
         Ok(())
     }
 
+    async fn calculate_diff_lines(&self, os: &Os) -> Result<(usize, usize)> {
+        let path = self.path(os);
+
+        let result = match self {
+            FsWrite::Create { .. } => {
+                // For create operations, all lines in the new file are added
+                let new_content = os.fs.read_to_string(&path).await?;
+                let lines_added = new_content.lines().count();
+                (lines_added, 0)
+            },
+            FsWrite::StrReplace { old_str, new_str, .. } => {
+                // Use actual diff analysis for accurate line counting
+                let diff = similar::TextDiff::from_lines(old_str, new_str);
+                let mut lines_added = 0;
+                let mut lines_removed = 0;
+
+                for change in diff.iter_all_changes() {
+                    match change.tag() {
+                        similar::ChangeTag::Insert => lines_added += 1,
+                        similar::ChangeTag::Delete => lines_removed += 1,
+                        similar::ChangeTag::Equal => {},
+                    }
+                }
+                (lines_added, lines_removed)
+            },
+            FsWrite::Insert { new_str, .. } => {
+                // For insert operations, all lines in new_str are added
+                let lines_added = new_str.lines().count();
+                (lines_added, 0)
+            },
+            FsWrite::Append { new_str, .. } => {
+                // For append operations, all lines in new_str are added
+                let lines_added = new_str.lines().count();
+                (lines_added, 0)
+            },
+        };
+
+        Ok(result)
+    }
+
     pub fn queue_description(&self, os: &Os, output: &mut impl Write) -> Result<()> {
         let cwd = os.env.current_dir()?;
         self.print_relative_path(os, output)?;