rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/observability/skill_analytics.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module RubynCode
+  module Observability
+    # Tracks per-skill usage and ROI metrics. Records when skills are loaded,
+    # how long they stay in context, whether suggestions from them are accepted,
+    # and their token cost. Enables monthly pruning of low-usage skills.
+    class SkillAnalytics
+      TABLE_NAME = 'skill_usage'
+
+      Entry = Data.define(
+        :skill_name, :loaded_at_turn, :last_referenced_turn,
+        :tokens_cost, :accepted, :session_id
+      )
+
+      attr_reader :entries
+
+      def initialize(db: nil)
+        @db = db
+        @entries = []
+      end
+
+      # Record a skill usage event.
+      def record(skill_name:, loaded_at_turn:, last_referenced_turn: nil, tokens_cost: 0, accepted: nil)
+        entry = Entry.new(
+          skill_name: skill_name.to_s,
+          loaded_at_turn: loaded_at_turn,
+          last_referenced_turn: last_referenced_turn || loaded_at_turn,
+          tokens_cost: tokens_cost.to_i,
+          accepted: accepted,
+          session_id: nil
+        )
+        @entries << entry
+        persist(entry) if @db
+        entry
+      end
+
+      # Calculate usage statistics across all recorded entries.
+      def usage_stats
+        return {} if @entries.empty?
+
+        by_skill = @entries.group_by(&:skill_name)
+        by_skill.transform_values do |entries|
+          {
+            load_count: entries.size,
+            total_tokens: entries.sum(&:tokens_cost),
+            avg_tokens: (entries.sum(&:tokens_cost).to_f / entries.size).round(0),
+            acceptance_rate: acceptance_rate(entries),
+            avg_lifespan: avg_lifespan(entries)
+          }
+        end
+      end
+
+      # Returns skills with usage rate below threshold (candidates for pruning).
+      def low_usage_skills(threshold: 0.05)
+        stats = usage_stats
+        total = @entries.size.to_f
+        return [] if total.zero?
+
+        stats.select do |_, s|
+          (s[:load_count] / total) < threshold
+        end.keys
+      end
+
+      # Returns skills sorted by ROI (accepted suggestions per token spent).
+      def roi_ranking
+        stats = usage_stats
+        stats.sort_by do |_, s|
+          tokens = s[:total_tokens]
+          rate = s[:acceptance_rate] || 0
+          tokens.positive? ? -(rate / tokens) : 0
+        end.map(&:first)
+      end
+
+      # Format a report for the /cost command.
+      def report
+        stats = usage_stats
+        return 'No skill usage data.' if stats.empty?
+
+        lines = ['Skill Usage:']
+        stats.each do |name, s|
+          lines << "  #{name}: #{s[:load_count]}x loaded, #{s[:total_tokens]} tokens"
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def acceptance_rate(entries)
+        rated = entries.reject { |e| e.accepted.nil? }
+        return nil if rated.empty?
+
+        (rated.count(&:accepted).to_f / rated.size).round(3)
+      end
+
+      def avg_lifespan(entries)
+        spans = entries.map { |e| e.last_referenced_turn - e.loaded_at_turn }
+        (spans.sum.to_f / spans.size).round(1)
+      end
+
+      def persist(entry)
+        @db.execute(
+          "INSERT INTO #{TABLE_NAME} (skill_name, loaded_at_turn, last_referenced_turn, " \
+          'tokens_cost, accepted, created_at) VALUES (?, ?, ?, ?, ?, ?)',
+          [entry.skill_name, entry.loaded_at_turn, entry.last_referenced_turn,
+           entry.tokens_cost, entry.accepted ? 1 : 0, Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')]
+        )
+      rescue StandardError => e
+        RubynCode::Debug.warn("SkillAnalytics: #{e.message}")
+      end
+    end
+  end
+end

data/lib/rubyn_code/observability/token_analytics.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Observability
+    # Tracks detailed token usage breakdown by category (system prompt,
+    # skills, context files, conversation, tool output) and reports
+    # savings from efficiency features. Powers the enhanced /cost command.
+    class TokenAnalytics
+      CHARS_PER_TOKEN = 4
+
+      CATEGORIES = %i[
+        system_prompt skills_loaded context_files
+        conversation tool_output code_written
+        explanations tool_calls
+      ].freeze
+
+      attr_reader :input_breakdown, :output_breakdown, :savings
+
+      def initialize
+        @input_breakdown = Hash.new(0)
+        @output_breakdown = Hash.new(0)
+        @savings = Hash.new(0)
+        @start_time = Time.now
+        @turn_count = 0
+      end
+
+      # Record input token usage by category.
+      def record_input(category, tokens)
+        @input_breakdown[category.to_sym] += tokens.to_i
+      end
+
+      # Record output token usage by category.
+      def record_output(category, tokens)
+        @output_breakdown[category.to_sym] += tokens.to_i
+      end
+
+      # Record tokens saved by an efficiency feature.
+      def record_savings(feature, tokens)
+        @savings[feature.to_sym] += tokens.to_i
+      end
+
+      # Increment the turn counter.
+      def record_turn!
+        @turn_count += 1
+      end
+
+      # Total input tokens across all categories.
+      def total_input_tokens
+        @input_breakdown.values.sum
+      end
+
+      # Total output tokens across all categories.
+      def total_output_tokens
+        @output_breakdown.values.sum
+      end
+
+      # Total tokens saved across all features.
+      def total_tokens_saved
+        @savings.values.sum
+      end
+
+      # Session duration in minutes.
+      def session_minutes
+        ((Time.now - @start_time) / 60.0).round(1)
+      end
+
+      # Format a complete analytics report.
+      def report(**)
+        lines = [header]
+        lines.concat(input_section)
+        lines << ''
+        lines.concat(output_section)
+        lines << ''
+        lines.concat(savings_section) if @savings.any?
+        lines.join("\n")
+      end
+
+      private
+
+      def header
+        duration = session_minutes
+        "Session: #{duration} min | #{@turn_count} turns"
+      end
+
+      def input_section
+        total = total_input_tokens
+        lines = ['Input tokens:'.rjust(20) + "  #{fmt(total)}"]
+
+        @input_breakdown.each do |cat, tokens|
+          pct = total.positive? ? ((tokens.to_f / total) * 100).round(0) : 0
+          lines << ("  #{humanize(cat)}:".ljust(22) + "#{fmt(tokens).rjust(8)}  (#{pct}%)")
+        end
+
+        lines
+      end
+
+      def output_section
+        total = total_output_tokens
+        lines = ['Output tokens:'.rjust(20) + "  #{fmt(total)}"]
+
+        @output_breakdown.each do |cat, tokens|
+          pct = total.positive? ? ((tokens.to_f / total) * 100).round(0) : 0
+          lines << ("  #{humanize(cat)}:".ljust(22) + "#{fmt(tokens).rjust(8)}  (#{pct}%)")
+        end
+
+        lines
+      end
+
+      def savings_section
+        total = total_tokens_saved
+        lines = ['Savings applied:']
+
+        @savings.each do |feature, tokens|
+          lines << ("  #{humanize(feature)}:".ljust(22) + "-#{fmt(tokens)} tokens saved")
+        end
+
+        lines << ('  Total saved:'.ljust(22) + "-#{fmt(total)} tokens")
+        lines
+      end
+
+      def humanize(sym)
+        sym.to_s.tr('_', ' ').capitalize
+      end
+
+      def fmt(num)
+        num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\1,').reverse
+      end
+    end
+  end
+end

data/lib/rubyn_code/observability/usage_reporter.rb

@@ -27,24 +27,8 @@ module RubynCode
 
         return "No usage data for session #{session_id}." if rows.empty?
 
-        total_input   = rows.sum { |r| fetch_int(r, 'input_tokens') }
-        total_output  = rows.sum { |r| fetch_int(r, 'output_tokens') }
-        total_cost    = rows.sum { |r| fetch_float(r, 'cost_usd') }
-        turns         = rows.size
-        avg_cost      = turns.positive? ? total_cost / turns : 0.0
-
-        lines = [
-          header('Session Summary'),
-          field('Session', session_id),
-          field('Turns', turns.to_s),
-          field('Input tokens', format_number(total_input)),
-          field('Output tokens', format_number(total_output)),
-          field('Total tokens', format_number(total_input + total_output)),
-          field('Total cost', format_usd(total_cost)),
-          field('Avg cost/turn', format_usd(avg_cost))
-        ]
-
-        lines.join("\n")
+        totals = compute_session_totals(rows)
+        build_session_summary_lines(session_id, rows.size, totals).join("\n")
       end
 
       # Returns a formatted summary of today's total cost across all sessions.
@@ -52,31 +36,11 @@ module RubynCode
       # @return [String] multi-line formatted summary
       def daily_summary
         today = Time.now.utc.strftime('%Y-%m-%d')
-        rows = @db.query(
-          'SELECT session_id, SUM(input_tokens) AS input_tokens, SUM(output_tokens) AS output_tokens, ' \
-          "SUM(cost_usd) AS cost_usd, COUNT(*) AS turns FROM #{TABLE_NAME} " \
-          'WHERE created_at >= ? GROUP BY session_id',
-          ["#{today}T00:00:00Z"]
-        ).to_a
+        rows = query_daily_rows(today)
 
         return 'No usage data for today.' if rows.empty?
 
-        total_input  = rows.sum { |r| fetch_int(r, 'input_tokens') }
-        total_output = rows.sum { |r| fetch_int(r, 'output_tokens') }
-        total_cost   = rows.sum { |r| fetch_float(r, 'cost_usd') }
-        total_turns  = rows.sum { |r| fetch_int(r, 'turns') }
-        sessions     = rows.size
-
-        lines = [
-          header("Daily Summary (#{today})"),
-          field('Sessions', sessions.to_s),
-          field('Total turns', total_turns.to_s),
-          field('Input tokens', format_number(total_input)),
-          field('Output tokens', format_number(total_output)),
-          field('Total cost', format_usd(total_cost))
-        ]
-
-        lines.join("\n")
+        build_daily_summary_lines(today, rows).join("\n")
       end
 
       # Returns a cost breakdown by model for a given session.
@@ -84,28 +48,12 @@ module RubynCode
       # @param session_id [String]
       # @return [String] multi-line formatted breakdown
       def model_breakdown(session_id)
-        rows = @db.query(
-          'SELECT model, SUM(input_tokens) AS input_tokens, SUM(output_tokens) AS output_tokens, ' \
-          "SUM(cost_usd) AS cost_usd, COUNT(*) AS calls FROM #{TABLE_NAME} " \
-          'WHERE session_id = ? GROUP BY model ORDER BY cost_usd DESC',
-          [session_id]
-        ).to_a
+        rows = query_model_breakdown_rows(session_id)
 
         return "No usage data for session #{session_id}." if rows.empty?
 
         lines = [header('Cost by Model')]
-
-        rows.each do |row|
-          model   = row['model'] || row[:model]
-          cost    = fetch_float(row, 'cost_usd')
-          calls   = fetch_int(row, 'calls')
-          input_t = fetch_int(row, 'input_tokens')
-          output_t = fetch_int(row, 'output_tokens')
-
-          lines << "  #{@formatter.pastel.bold(model)}"
-          lines << "    Calls: #{calls}  |  Input: #{format_number(input_t)}  |  Output: #{format_number(output_t)}  |  Cost: #{format_usd(cost)}"
-        end
-
+        rows.each { |row| append_model_row(lines, row) }
         lines.join("\n")
       end
 
@@ -121,11 +69,81 @@ module RubynCode
       end
 
       def format_usd(amount)
-        '$%.4f' % amount
+        format('$%.4f', amount)
+      end
+
+      def compute_session_totals(rows)
+        {
+          input: rows.sum { |r| fetch_int(r, 'input_tokens') },
+          output: rows.sum { |r| fetch_int(r, 'output_tokens') },
+          cost: rows.sum { |r| fetch_float(r, 'cost_usd') }
+        }
+      end
+
+      def build_session_summary_lines(session_id, turns, totals) # rubocop:disable Metrics/AbcSize -- assembles multi-field summary
+        avg_cost = turns.positive? ? totals[:cost] / turns : 0.0
+        [
+          header('Session Summary'),
+          field('Session', session_id),
+          field('Turns', turns.to_s),
+          field('Input tokens', format_number(totals[:input])),
+          field('Output tokens', format_number(totals[:output])),
+          field('Total tokens', format_number(totals[:input] + totals[:output])),
+          field('Total cost', format_usd(totals[:cost])),
+          field('Avg cost/turn', format_usd(avg_cost))
+        ]
+      end
+
+      def query_daily_rows(today)
+        @db.query(
+          'SELECT session_id, SUM(input_tokens) AS input_tokens, ' \
+          'SUM(output_tokens) AS output_tokens, SUM(cost_usd) AS cost_usd, ' \
+          "COUNT(*) AS turns FROM #{TABLE_NAME} " \
+          'WHERE created_at >= ? GROUP BY session_id',
+          ["#{today}T00:00:00Z"]
+        ).to_a
+      end
+
+      def build_daily_summary_lines(today, rows) # rubocop:disable Metrics/AbcSize -- assembles multi-field daily summary
+        total_input  = rows.sum { |r| fetch_int(r, 'input_tokens') }
+        total_output = rows.sum { |r| fetch_int(r, 'output_tokens') }
+        total_cost   = rows.sum { |r| fetch_float(r, 'cost_usd') }
+        total_turns  = rows.sum { |r| fetch_int(r, 'turns') }
+
+        [
+          header("Daily Summary (#{today})"),
+          field('Sessions', rows.size.to_s),
+          field('Total turns', total_turns.to_s),
+          field('Input tokens', format_number(total_input)),
+          field('Output tokens', format_number(total_output)),
+          field('Total cost', format_usd(total_cost))
+        ]
+      end
+
+      def query_model_breakdown_rows(session_id)
+        @db.query(
+          'SELECT model, SUM(input_tokens) AS input_tokens, ' \
+          'SUM(output_tokens) AS output_tokens, SUM(cost_usd) AS cost_usd, ' \
+          "COUNT(*) AS calls FROM #{TABLE_NAME} " \
+          'WHERE session_id = ? GROUP BY model ORDER BY cost_usd DESC',
+          [session_id]
+        ).to_a
+      end
+
+      def append_model_row(lines, row)
+        model = row['model'] || row[:model]
+        lines << "  #{@formatter.pastel.bold(model)}"
+        lines << format(
+          '    Calls: %<calls>s  |  Input: %<input>s  |  Output: %<output>s  |  Cost: %<cost>s',
+          calls: fetch_int(row, 'calls'),
+          input: format_number(fetch_int(row, 'input_tokens')),
+          output: format_number(fetch_int(row, 'output_tokens')),
+          cost: format_usd(fetch_float(row, 'cost_usd'))
+        )
       end
 
-      def format_number(n)
-        n.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+      def format_number(num)
+        num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
       end
 
       def fetch_int(row, key)

data/lib/rubyn_code/output/diff_renderer.rb

@@ -37,18 +37,20 @@ module RubynCode
         hunks = compute_hunks(old_lines, new_lines)
         return pastel.dim('No differences found.') if hunks.empty?
 
-        parts = []
-        parts << render_header(filename)
-        hunks.each { |hunk| parts << render_hunk(hunk) }
-        parts << ''
-
-        result = parts.join("\n")
+        result = assemble_output(hunks, filename)
         $stdout.puts(result)
         result
       end
 
       private
 
+      def assemble_output(hunks, filename)
+        parts = [render_header(filename)]
+        hunks.each { |hunk| parts << render_hunk(hunk) }
+        parts << ''
+        parts.join("\n")
+      end
+
       def render_header(filename)
         [
           pastel.bold("--- a/#{filename}"),
@@ -84,54 +86,68 @@ module RubynCode
 
       # Builds the LCS length table for two arrays of lines.
       def build_lcs_table(old_lines, new_lines)
-        m = old_lines.size
-        n = new_lines.size
-        table = Array.new(m + 1) { Array.new(n + 1, 0) }
-
-        (1..m).each do |i|
-          (1..n).each do |j|
-            table[i][j] = if old_lines[i - 1] == new_lines[j - 1]
-                            table[i - 1][j - 1] + 1
-                          else
-                            [table[i - 1][j], table[i][j - 1]].max
-                          end
-          end
+        row_count = old_lines.size
+        col_count = new_lines.size
+        table = Array.new(row_count + 1) { Array.new(col_count + 1, 0) }
+
+        (1..row_count).each do |row|
+          fill_lcs_row(table, row, old_lines, new_lines, col_count)
         end
 
         table
       end
 
+      def fill_lcs_row(table, row, old_lines, new_lines, col_count) # rubocop:disable Metrics/AbcSize -- LCS algorithm step
+        (1..col_count).each do |col|
+          table[row][col] = if old_lines[row - 1] == new_lines[col - 1]
+                              table[row - 1][col - 1] + 1
+                            else
+                              [table[row - 1][col], table[row][col - 1]].max
+                            end
+        end
+      end
+
       # Backtracks through the LCS table to produce a sequence of diff operations.
       # Returns an array of [:equal, :delete, :add] paired with line indices.
       def backtrack_diff(table, old_lines, new_lines)
         result = []
-        i = old_lines.size
-        j = new_lines.size
-
-        while i.positive? || j.positive?
-          if i.positive? && j.positive? && old_lines[i - 1] == new_lines[j - 1]
-            result.unshift([:equal, i - 1, j - 1])
-            i -= 1
-            j -= 1
-          elsif j.positive? && (i.zero? || table[i][j - 1] >= table[i - 1][j])
-            result.unshift([:add, nil, j - 1])
-            j -= 1
-          elsif i.positive?
-            result.unshift([:delete, i - 1, nil])
-            i -= 1
-          end
+        old_idx = old_lines.size
+        new_idx = new_lines.size
+
+        while old_idx.positive? || new_idx.positive?
+          old_idx, new_idx = backtrack_step(result, table, old_lines, new_lines, old_idx, new_idx)
         end
 
         result
       end
 
+      def backtrack_step(result, table, old_lines, new_lines, old_idx, new_idx) # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists -- LCS backtrack step requires all state
+        if lines_match?(old_lines, new_lines, old_idx, new_idx)
+          result.unshift([:equal, old_idx - 1, new_idx - 1])
+          [old_idx - 1, new_idx - 1]
+        elsif new_idx.positive? && (old_idx.zero? || table[old_idx][new_idx - 1] >= table[old_idx - 1][new_idx])
+          result.unshift([:add, nil, new_idx - 1])
+          [old_idx, new_idx - 1]
+        else
+          result.unshift([:delete, old_idx - 1, nil])
+          [old_idx - 1, new_idx]
+        end
+      end
+
+      def lines_match?(old_lines, new_lines, old_idx, new_idx)
+        old_idx.positive? && new_idx.positive? && old_lines[old_idx - 1] == new_lines[new_idx - 1]
+      end
+
       # Groups raw diff operations into hunks with surrounding context lines.
       def group_into_hunks(raw_diff, old_lines, new_lines)
-        # Identify change indices (non-equal operations)
         change_indices = raw_diff.each_index.reject { |idx| raw_diff[idx][0] == :equal }
         return [] if change_indices.empty?
 
-        # Group changes that are within context_lines of each other
+        groups = cluster_changes(change_indices)
+        groups.map { |group| build_hunk(group, raw_diff, old_lines, new_lines) }
+      end
+
+      def cluster_changes(change_indices)
         groups = []
         current_group = [change_indices.first]
 
@@ -144,54 +160,63 @@ module RubynCode
           end
         end
         groups << current_group
+      end
 
-        # Build hunks from groups
-        groups.map do |group|
-          range_start = [group.first - @context_lines, 0].max
-          range_end = [group.last + @context_lines, raw_diff.size - 1].min
-
-          lines = []
-          old_start = nil
-          new_start = nil
-          old_count = 0
-          new_count = 0
-
-          (range_start..range_end).each do |idx|
-            op, old_idx, new_idx = raw_diff[idx]
-
-            case op
-            when :equal
-              old_start ||= old_idx + 1
-              new_start ||= new_idx + 1
-              lines << DiffLine.new(type: :context, content: old_lines[old_idx])
-              old_count += 1
-              new_count += 1
-            when :delete
-              old_start ||= old_idx + 1
-              new_start ||= (new_idx || find_new_start(raw_diff, idx)) + 1
-              lines << DiffLine.new(type: :delete, content: old_lines[old_idx])
-              old_count += 1
-            when :add
-              old_start ||= (old_idx || find_old_start(raw_diff, idx)) + 1
-              new_start ||= new_idx + 1
-              lines << DiffLine.new(type: :add, content: new_lines[new_idx])
-              new_count += 1
-            end
-          end
+      def build_hunk(group, raw_diff, old_lines, new_lines)
+        range_start = [group.first - @context_lines, 0].max
+        range_end = [group.last + @context_lines, raw_diff.size - 1].min
+
+        lines, old_start, new_start, old_count, new_count =
+          collect_hunk_lines(range_start, range_end, raw_diff, old_lines, new_lines)
+
+        Hunk.new(
+          old_start: old_start || 1, old_count: old_count,
+          new_start: new_start || 1, new_count: new_count,
+          lines: lines.freeze
+        )
+      end
+
+      def collect_hunk_lines(range_start, range_end, raw_diff, old_lines, new_lines)
+        acc = { lines: [], old_start: nil, new_start: nil, old_count: 0, new_count: 0 }
 
-          old_start ||= 1
-          new_start ||= 1
+        (range_start..range_end).each do |idx|
+          apply_diff_entry(acc, raw_diff, idx, old_lines, new_lines)
+        end
+
+        acc.values_at(:lines, :old_start, :new_start, :old_count, :new_count)
+      end
 
-          Hunk.new(
-            old_start: old_start,
-            old_count: old_count,
-            new_start: new_start,
-            new_count: new_count,
-            lines: lines.freeze
-          )
+      def apply_diff_entry(acc, raw_diff, idx, old_lines, new_lines)
+        op, old_idx, new_idx = raw_diff[idx]
+        case op
+        when :equal  then apply_equal_entry(acc, old_lines, old_idx, new_idx)
+        when :delete then apply_delete_entry(acc, raw_diff, idx, old_lines, old_idx, new_idx)
+        when :add    then apply_add_entry(acc, raw_diff, idx, new_lines, old_idx, new_idx)
         end
       end
 
+      def apply_equal_entry(acc, old_lines, old_idx, new_idx)
+        acc[:old_start] ||= old_idx + 1
+        acc[:new_start] ||= new_idx + 1
+        acc[:lines] << DiffLine.new(type: :context, content: old_lines[old_idx])
+        acc[:old_count] += 1
+        acc[:new_count] += 1
+      end
+
+      def apply_delete_entry(acc, raw_diff, idx, old_lines, old_idx, new_idx) # rubocop:disable Metrics/ParameterLists -- diff entry requires context from caller
+        acc[:old_start] ||= old_idx + 1
+        acc[:new_start] ||= (new_idx || find_new_start(raw_diff, idx)) + 1
+        acc[:lines] << DiffLine.new(type: :delete, content: old_lines[old_idx])
+        acc[:old_count] += 1
+      end
+
+      def apply_add_entry(acc, raw_diff, idx, new_lines, old_idx, new_idx) # rubocop:disable Metrics/ParameterLists -- diff entry requires context from caller
+        acc[:old_start] ||= (old_idx || find_old_start(raw_diff, idx)) + 1
+        acc[:new_start] ||= new_idx + 1
+        acc[:lines] << DiffLine.new(type: :add, content: new_lines[new_idx])
+        acc[:new_count] += 1
+      end
+
       # Find the nearest new-side line number for context when a delete has no new_idx.
       def find_new_start(raw_diff, from_idx)
         ((from_idx + 1)...raw_diff.size).each do |i|

data/lib/rubyn_code/output/formatter.rb

@@ -55,20 +55,20 @@ module RubynCode
       end
 
       def diff(text)
-        lines = text.each_line.map do |line|
-          case line
-          when /\A\+{3}\s/  then pastel.bold(line)
-          when /\A-{3}\s/   then pastel.bold(line)
-          when /\A@@/        then pastel.cyan(line)
-          when /\A\+/        then pastel.green(line)
-          when /\A-/         then pastel.red(line)
-          else                    pastel.dim(line)
-          end
-        end
-
+        lines = text.each_line.map { |line| colorize_diff_line(line) }
         output lines.join
       end
 
+      def colorize_diff_line(line)
+        case line
+        when /\A[+-]{3}\s/ then pastel.bold(line)
+        when /\A@@/        then pastel.cyan(line)
+        when /\A\+/        then pastel.green(line)
+        when /\A-/         then pastel.red(line)
+        else                    pastel.dim(line)
+        end
+      end
+
       def tool_call(tool_name, arguments = {})
         header = pastel.magenta.bold("#{TOOL_ICON} #{tool_name}")
         parts = [header]