earl-bot 0.1.0

data/bin/ci

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "open3"
+
+steps = []
+failures = []
+
+def run_step(name, command, steps, failures)
+  print "  #{name}... "
+  $stdout.flush
+  output, status = Open3.capture2e(command)
+  if status.success?
+    puts "OK"
+    steps << { name: name, status: :ok }
+  else
+    puts "FAIL"
+    failures << { name: name, output: output }
+    steps << { name: name, status: :fail }
+  end
+rescue Errno::ENOENT => e
+  puts "FAIL"
+  failures << { name: name, output: "Command not found: #{e.message}" }
+  steps << { name: name, status: :fail }
+end
+
+puts "Running CI pipeline..."
+puts ""
+
+run_step("Style: RuboCop", "bundle exec rubocop --no-server", steps, failures)
+run_step("Quality: Reek", "bundle exec reek", steps, failures)
+run_step("Security: Bundler audit", "bundle exec bundle-audit check --update", steps, failures)
+run_step("Security: Semgrep", "semgrep --config=r/ruby --metrics=off --error --quiet lib/", steps, failures)
+run_step("Lint: Actionlint", "actionlint .github/workflows/*.yml", steps, failures)
+run_step("Tests: Minitest", "bundle exec rake test", steps, failures)
+run_step("Coverage: Report", "ruby bin/coverage", steps, failures)
+
+puts ""
+if failures.empty?
+  puts "All #{steps.size} steps passed!"
+else
+  puts "#{failures.size} of #{steps.size} steps failed:"
+  failures.each do |f|
+    puts ""
+    puts "--- #{f[:name]} ---"
+    puts f[:output]
+  end
+  exit 1
+end

data/bin/claude-context

@@ -0,0 +1,155 @@
+#!/usr/bin/env bash
+# Scrape Claude Code /context output via tmux.
+# Resumes an existing session, runs /context, captures output, exits.
+#
+# Usage:
+#   bin/claude-context <session-id>          # Human-readable output
+#   bin/claude-context <session-id> --json   # JSON output for programmatic use
+#
+# Requires: tmux, claude CLI
+set -euo pipefail
+
+SESSION_ID="${1:?Usage: $0 <session-id> [--json]}"
+JSON_MODE=false
+if [[ "${2:-}" == "--json" ]]; then
+  JSON_MODE=true
+fi
+
+TMUX_SESSION="earl-ctx-$$"
+TIMEOUT=30
+
+cleanup() { tmux kill-session -t "$TMUX_SESSION" 2>/dev/null || true; }
+trap cleanup EXIT
+
+# Resume the Claude session in detached tmux (wide to avoid text wrapping)
+tmux new-session -d -s "$TMUX_SESSION" -x 200 -y 80 "CLAUDECODE= claude --resume $SESSION_ID --fork-session 2>&1; sleep 30"
+
+# Wait for the session to be ready (prompt indicators)
+for _ in $(seq 1 "$TIMEOUT"); do
+  sleep 1
+  if tmux capture-pane -t "$TMUX_SESSION" -p -S -20 2>/dev/null | grep -q 'PR #\|Try \|Welcome\|INSERT'; then
+    break
+  fi
+done
+
+# Extra settle time after prompt appears
+sleep 5
+
+# Clear any pending input and send /context
+# NOTE: Do NOT send Escape — Claude TUI uses vim-style modes and Escape
+# switches from INSERT to NORMAL mode, where "/" starts a search.
+# First Enter triggers autocomplete menu, second Enter selects /context
+tmux send-keys -t "$TMUX_SESSION" C-u
+sleep 0.5
+tmux send-keys -t "$TMUX_SESSION" '/context' Enter
+sleep 2
+tmux send-keys -t "$TMUX_SESSION" Enter
+sleep 5
+
+# Capture the pane content (large scrollback to get full /context output)
+OUTPUT=$(tmux capture-pane -t "$TMUX_SESSION" -p -S -200 2>/dev/null)
+
+# Exit Claude cleanly
+tmux send-keys -t "$TMUX_SESSION" C-u
+sleep 0.5
+tmux send-keys -t "$TMUX_SESSION" '/exit' Enter
+sleep 1
+
+# /context output uses unicode icons (⛁ ⛶ ⛝) as prefixes for each category line.
+# We anchor our greps on these icons to avoid matching conversation history that may
+# contain similar text (e.g., diffs of this very script).
+#
+# Example lines:
+#   ⛁ System prompt: 3k tokens (1.5%)
+#   ⛶ Free space: 133k (66.7%)
+#   ⛝ Autocompact buffer: 33k tokens (16.5%)
+
+# Parse the context summary line: "claude-opus-4-6 · 34k/200k tokens (17%)"
+# The · is a UTF-8 middle dot (U+00B7), match with [^a-z]*
+# Take the LAST match in case scrollback has older /context outputs
+summary_line=$(echo "$OUTPUT" | grep -o '[a-z0-9-]* [^a-z]* [0-9.]*k*/[0-9.]*k* tokens ([0-9.]*%)' | tail -1 || echo "")
+
+if [[ -z "$summary_line" ]]; then
+  if [[ "$JSON_MODE" == true ]]; then
+    echo '{"error": "Could not parse context data"}'
+  else
+    echo "⚠️  Could not parse context data."
+    echo "Raw output (last 30 lines):"
+    echo "$OUTPUT" | tail -30
+  fi
+  exit 1
+fi
+
+model=$(echo "$summary_line" | sed 's/ [^a-z].*//')
+used_tokens=$(echo "$summary_line" | grep -o '[0-9.]*k*/' | sed 's/\///')
+total_tokens=$(echo "$summary_line" | grep -o '/[0-9.]*k* tokens' | sed 's|^/||' | sed 's/ tokens//')
+percent=$(echo "$summary_line" | grep -o '([0-9.]*%)' | tr -d '()')
+
+# Helper: extract token count from a /context category line.
+# Anchors on unicode icons (⛁ ⛶ ⛝) to avoid matching conversation history.
+parse_tokens() {
+  echo "$OUTPUT" | grep "[⛁⛶⛝] $1" | tail -1 | grep -o '[0-9.]*k* tokens' | sed 's/ tokens//' || echo ""
+}
+
+# Helper: extract percentage from a /context category line
+parse_pct() {
+  echo "$OUTPUT" | grep "[⛁⛶⛝] $1" | tail -1 | grep -o '([0-9.]*%)' | tr -d '()' || echo ""
+}
+
+# Parse category breakdowns
+system_prompt=$(parse_tokens 'System prompt:')
+system_tools=$(parse_tokens 'System tools:')
+custom_agents=$(parse_tokens 'Custom agents:')
+memory_files=$(parse_tokens 'Memory files:')
+skills_val=$(parse_tokens 'Skills:')
+messages=$(parse_tokens 'Messages:')
+free_space=$(echo "$OUTPUT" | grep '[⛁⛶⛝] Free space:' | tail -1 | grep -o '[0-9.]*k*' | head -1 || echo "")
+autocompact=$(echo "$OUTPUT" | grep '[⛁⛶⛝] Autocompact buffer:' | tail -1 | grep -o '[0-9.]*k* tokens' | sed 's/ tokens//' || echo "")
+
+# Parse percentage breakdowns
+system_prompt_pct=$(parse_pct 'System prompt:')
+system_tools_pct=$(parse_pct 'System tools:')
+custom_agents_pct=$(parse_pct 'Custom agents:')
+memory_files_pct=$(parse_pct 'Memory files:')
+skills_pct=$(parse_pct 'Skills:')
+messages_pct=$(parse_pct 'Messages:')
+free_space_pct=$(parse_pct 'Free space:')
+autocompact_pct=$(echo "$OUTPUT" | grep '[⛁⛶⛝] Autocompact buffer:' | tail -1 | grep -o '([0-9.]*%)' | tr -d '()' || echo "")
+
+if [[ "$JSON_MODE" == true ]]; then
+  # Helper to output a JSON string or null
+  json_str() { if [[ -n "$1" ]]; then echo "\"$1\""; else echo "null"; fi; }
+
+  cat <<JSON
+{
+  "model": "$model",
+  "used_tokens": "$used_tokens",
+  "total_tokens": "$total_tokens",
+  "percent_used": "$percent",
+  "categories": {
+    "system_prompt": {"tokens": $(json_str "$system_prompt"), "percent": $(json_str "$system_prompt_pct")},
+    "system_tools": {"tokens": $(json_str "$system_tools"), "percent": $(json_str "$system_tools_pct")},
+    "custom_agents": {"tokens": $(json_str "$custom_agents"), "percent": $(json_str "$custom_agents_pct")},
+    "memory_files": {"tokens": $(json_str "$memory_files"), "percent": $(json_str "$memory_files_pct")},
+    "skills": {"tokens": $(json_str "$skills_val"), "percent": $(json_str "$skills_pct")},
+    "messages": {"tokens": $(json_str "$messages"), "percent": $(json_str "$messages_pct")},
+    "free_space": {"tokens": $(json_str "$free_space"), "percent": $(json_str "$free_space_pct")},
+    "autocompact_buffer": {"tokens": $(json_str "$autocompact"), "percent": $(json_str "$autocompact_pct")}
+  }
+}
+JSON
+else
+  echo "📊 Claude Context Usage"
+  echo ""
+  echo "  Model:    $model"
+  echo "  Context:  $used_tokens / $total_tokens tokens ($percent)"
+  echo ""
+  [[ -n "$messages" ]] && echo "  Messages:          $messages tokens ($messages_pct)"
+  [[ -n "$system_prompt" ]] && echo "  System prompt:     $system_prompt tokens ($system_prompt_pct)"
+  [[ -n "$system_tools" ]] && echo "  System tools:      $system_tools tokens ($system_tools_pct)"
+  [[ -n "$custom_agents" ]] && echo "  Custom agents:     $custom_agents tokens ($custom_agents_pct)"
+  [[ -n "$memory_files" ]] && echo "  Memory files:      $memory_files tokens ($memory_files_pct)"
+  [[ -n "$skills_val" ]] && echo "  Skills:            $skills_val tokens ($skills_pct)"
+  [[ -n "$free_space" ]] && echo "  Free space:        $free_space ($free_space_pct)"
+  [[ -n "$autocompact" ]] && echo "  Autocompact buf:   $autocompact tokens ($autocompact_pct)"
+fi

data/bin/claude-usage

@@ -0,0 +1,110 @@
+#!/usr/bin/env bash
+# Scrape Claude Code /usage output via tmux.
+# Spawns an interactive Claude session, runs /usage, captures output, exits.
+#
+# Usage:
+#   bin/claude-usage          # Human-readable output
+#   bin/claude-usage --json   # JSON output for programmatic use
+#
+# Requires: tmux, claude CLI
+set -euo pipefail
+
+SESSION="claude-usage-$$"
+TIMEOUT=15
+
+cleanup() { tmux kill-session -t "$SESSION" 2>/dev/null || true; }
+trap cleanup EXIT
+
+# Start interactive Claude in detached tmux (wide to avoid text wrapping)
+tmux new-session -d -s "$SESSION" -x 200 -y 50 "CLAUDECODE= claude 2>&1"
+
+# Wait for the welcome screen
+for _ in $(seq 1 "$TIMEOUT"); do
+  sleep 1
+  if tmux capture-pane -t "$SESSION" -p 2>/dev/null | grep -q "Welcome\|Opus\|Claude"; then
+    break
+  fi
+done
+
+# Send /usage — first Enter selects from autocomplete, second confirms
+tmux send-keys -t "$SESSION" '/usage' Enter
+sleep 1
+tmux send-keys -t "$SESSION" Enter
+sleep 3
+
+# Capture the pane content
+OUTPUT=$(tmux capture-pane -t "$SESSION" -p 2>/dev/null)
+
+# Exit Claude cleanly
+tmux send-keys -t "$SESSION" C-u
+sleep 0.5
+tmux send-keys -t "$SESSION" '/exit' Enter
+sleep 1
+
+# Parse the captured output
+session_pct=$(echo "$OUTPUT" | grep -A1 "Current session" | grep -o '[0-9]*% used' | grep -o '[0-9]*' || echo "")
+session_reset=$(echo "$OUTPUT" | grep -A2 "Current session" | grep "Resets" | sed 's/^[[:space:]]*//' | sed 's/Resets //' || echo "")
+
+# "Current week (all models)" — use head -1 to pick only the first match
+week_pct=$(echo "$OUTPUT" | grep -A1 "Current week (all models)" | grep -o '[0-9]*% used' | head -1 | grep -o '[0-9]*' || echo "")
+week_reset=$(echo "$OUTPUT" | grep -A2 "Current week (all models)" | grep "Resets" | head -1 | sed 's/^[[:space:]]*//' | sed 's/Resets //' || echo "")
+
+# "Current week (Sonnet only)" — separate field
+sonnet_pct=$(echo "$OUTPUT" | grep -A1 "Current week (Sonnet only)" | grep -o '[0-9]*% used' | head -1 | grep -o '[0-9]*' || echo "")
+sonnet_reset=$(echo "$OUTPUT" | grep -A2 "Current week (Sonnet only)" | grep "Resets" | head -1 | sed 's/^[[:space:]]*//' | sed 's/Resets //' || echo "")
+
+# Fallback: if "all models" label not found, try plain "Current week" (older CLI)
+if [[ -z "$week_pct" ]]; then
+  week_pct=$(echo "$OUTPUT" | grep -A1 "Current week" | grep -o '[0-9]*% used' | head -1 | grep -o '[0-9]*' || echo "")
+  week_reset=$(echo "$OUTPUT" | grep -A2 "Current week" | grep "Resets" | head -1 | sed 's/^[[:space:]]*//' | sed 's/Resets //' || echo "")
+fi
+
+extra_pct=$(echo "$OUTPUT" | grep -A1 "Extra usage" | grep -o '[0-9]*% used' | grep -o '[0-9]*' || echo "")
+extra_detail=$(echo "$OUTPUT" | grep -A2 "Extra usage" | grep "spent" | sed 's/^[[:space:]]*//' || echo "")
+extra_reset=$(echo "$extra_detail" | sed 's/.*Resets //' || echo "")
+extra_spent=$(echo "$extra_detail" | grep -o '\$[0-9.]*' | head -1 || echo "")
+extra_budget=$(echo "$extra_detail" | grep -o '\$[0-9.]*' | tail -1 || echo "")
+
+if [[ "${1:-}" == "--json" ]]; then
+  cat <<JSON
+{
+  "session": {
+    "percent_used": ${session_pct:-null},
+    "resets": "${session_reset}"
+  },
+  "week": {
+    "percent_used": ${week_pct:-null},
+    "resets": "${week_reset}"
+  },
+  "sonnet_week": {
+    "percent_used": ${sonnet_pct:-null},
+    "resets": "${sonnet_reset}"
+  },
+  "extra": {
+    "percent_used": ${extra_pct:-null},
+    "spent": "${extra_spent}",
+    "budget": "${extra_budget}",
+    "resets": "${extra_reset}"
+  }
+}
+JSON
+else
+  echo "📊 Claude Usage"
+  echo ""
+  if [[ -n "$session_pct" ]]; then
+    echo "  Session:  ${session_pct}% used — resets ${session_reset}"
+  fi
+  if [[ -n "$week_pct" ]]; then
+    echo "  Week:     ${week_pct}% used — resets ${week_reset}"
+  fi
+  if [[ -n "$sonnet_pct" ]]; then
+    echo "  Sonnet:   ${sonnet_pct}% used — resets ${sonnet_reset}"
+  fi
+  if [[ -n "$extra_pct" ]]; then
+    echo "  Extra:    ${extra_pct}% used (${extra_spent} / ${extra_budget}) — resets ${extra_reset}"
+  fi
+  if [[ -z "$session_pct" && -z "$week_pct" ]]; then
+    echo "  ⚠️  Could not parse usage data. Raw output:"
+    echo "$OUTPUT" | sed -n '/Current session/,/Esc to cancel/p'
+  fi
+fi

data/bin/coverage

@@ -0,0 +1,221 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile do
+  source "https://rubygems.org"
+  gem "nokogiri"
+end
+
+# Path to the SimpleCov HTML report
+coverage_file = File.join(Dir.pwd, "coverage", "index.html")
+
+unless File.exist?(coverage_file)
+  puts "❌ No coverage report found at #{coverage_file}"
+  puts "Run tests first: bundle exec rake test"
+  exit 1
+end
+
+# Parse the HTML file
+doc = Nokogiri::HTML(File.read(coverage_file))
+
+# Extract overall line coverage
+line_percent = doc.css(".covered_percent span").first&.text&.strip
+total_lines = doc.css(".t-line-summary b").first&.text&.strip
+covered_lines = doc.css(".t-line-summary .green b").first&.text&.strip
+missed_lines = doc.css(".t-line-summary .red b").first&.text&.strip
+
+# Extract overall branch coverage (first t-branch-summary is the overall stats)
+overall_branch_summary = doc.css(".t-branch-summary").first
+if overall_branch_summary
+  branch_percent = overall_branch_summary.css("span").last.text.strip.gsub(/[()]/, "")
+  branch_summary_spans = overall_branch_summary.css("span b")
+  overall_total_branches = branch_summary_spans[0]&.text&.strip
+  overall_covered_branches = branch_summary_spans[1]&.text&.strip
+  overall_missed_branches = branch_summary_spans[2]&.text&.strip
+else
+  # No branch coverage available
+  branch_percent = nil
+  overall_total_branches = nil
+  overall_covered_branches = nil
+  overall_missed_branches = nil
+end
+
+# Extract timestamp
+timestamp = doc.css(".timestamp .timeago").first&.attr("title")
+
+puts "## 📊 SimpleCov Coverage Report"
+puts "Generated: #{timestamp}"
+puts ""
+
+puts "### 📈 Line Coverage: #{line_percent}"
+puts "  ✅ #{covered_lines}/#{total_lines} lines covered"
+puts "  ❌ #{missed_lines} lines missed"
+puts ""
+
+if branch_percent
+  puts "### 🌳 Branch Coverage: #{branch_percent}"
+  puts "  ✅ #{overall_covered_branches}/#{overall_total_branches} branches covered"
+  puts "  ❌ #{overall_missed_branches} branches missed"
+  puts ""
+end
+
+# Show file-by-file breakdown if there are missed lines or branches
+if missed_lines.to_i.positive? || overall_missed_branches&.to_i&.positive?
+  # First, collect all files with missing coverage
+  files_with_issues = []
+  files_shown = Set.new
+
+  doc.css("tbody .t-file").each do |row|
+    file_name = row.css(".t-file__name a").first&.text&.strip
+    line_coverage = row.css(".t-file__coverage").first&.text&.strip
+    branch_coverage = row.css(".t-file__branch-coverage").first&.text&.strip
+
+    # Only include files that aren't 100% covered and haven't been seen yet
+    should_skip = files_shown.include?(file_name) ||
+                  (line_coverage == "100.00 %" && (!branch_coverage || branch_coverage == "100.00 %"))
+    next if should_skip
+
+    files_shown.add(file_name)
+    files_with_issues << row
+  end
+
+  total_files_with_issues = files_with_issues.length
+  files_to_show = files_with_issues.take(50)
+
+  puts "### 📋 Files with missing coverage:"
+  puts ""
+  if total_files_with_issues > 50
+    puts "Showing top 50 of #{total_files_with_issues} files with missing coverage:"
+    puts ""
+  end
+
+  files_to_show.each do |row|
+    file_name = row.css(".t-file__name a").first&.text&.strip
+    line_coverage = row.css(".t-file__coverage").first&.text&.strip
+    branch_coverage = row.css(".t-file__branch-coverage").first&.text&.strip
+    file_link = row.css(".t-file__name a").first&.attr("href")
+
+    # Extract detailed line information for this file
+    missed_lines = []
+    missed_branches = []
+    total_file_lines = 0
+    covered_file_lines = 0
+
+    if file_link
+      file_id = file_link.gsub("#", "")
+      file_section = doc.css("##{file_id}")
+
+      if file_section.any?
+        # Get the actual counts from SimpleCov's summary
+        line_summary = file_section.css(".t-line-summary")
+        if line_summary.any?
+          summary_text = line_summary.text
+          # Extract numbers from text like "13 relevant lines. 12 lines covered and 1 lines missed."
+          total_file_lines = Regexp.last_match(1).to_i if summary_text.match(/(\d+)\s+relevant\s+lines/)
+          covered_file_lines = Regexp.last_match(1).to_i if summary_text.match(/(\d+)\s+lines\s+covered/)
+        end
+
+        # Find missed lines and branches
+        file_section.css("li").each do |line_item|
+          line_number = line_item.attr("data-linenumber")
+          line_class = line_item.attr("class")
+
+          if line_class&.include?("missed") && !line_class.include?("missed-branch")
+            missed_lines << line_number
+          elsif line_class&.include?("missed-branch")
+            missed_branches << line_number
+          end
+        end
+      end
+    end
+
+    # Format the line ranges more clearly
+    def format_line_ranges(lines)
+      return "" if lines.empty?
+
+      ranges = []
+      current_range = [lines.first.to_i]
+
+      lines.map(&:to_i).sort[1..]&.each do |line|
+        if line == current_range.last + 1
+          current_range << line
+        else
+          ranges << format_range(current_range)
+          current_range = [line]
+        end
+      end
+      ranges << format_range(current_range)
+
+      "L#{ranges.join(", L")}"
+    end
+
+    def format_range(range)
+      if range.length == 1
+        range.first.to_s
+      else
+        "#{range.first}-#{range.last}"
+      end
+    end
+
+    # Get branch counts from the file section
+    covered_branches = 0
+    total_branches = 0
+
+    if file_link
+      file_id = file_link.gsub("#", "")
+      file_section = doc.css("##{file_id}")
+      branch_summary = file_section.css(".t-branch-summary")
+
+      if branch_summary.any?
+        branch_spans = branch_summary.css("span b")
+        total_branches = branch_spans[0]&.text.to_i
+        covered_branches = branch_spans[1]&.text.to_i
+      end
+    end
+
+    branch_display = branch_coverage ? "Branch: #{branch_coverage}" : "Branch: N/A"
+    puts "  #{file_name} (Line: #{line_coverage}, #{branch_display}):"
+
+    line_info = "📍 Lines: #{covered_file_lines}/#{total_file_lines}"
+    line_info += " (missed: #{format_line_ranges(missed_lines)})" unless missed_lines.empty?
+    puts "         #{line_info}"
+
+    if total_branches.positive?
+      branch_info = "🌿 Branches: #{covered_branches}/#{total_branches}"
+      branch_info += " (missed: #{format_line_ranges(missed_branches)})" unless missed_branches.empty?
+      puts "         #{branch_info}"
+    end
+
+    puts ""
+  end
+end
+
+# Write to GitHub Actions job summary if available
+if ENV["GITHUB_STEP_SUMMARY"]
+  File.open(ENV["GITHUB_STEP_SUMMARY"], "a") do |f|
+    f.puts ""
+    f.puts "## 📊 Test Coverage Report"
+    f.puts ""
+    f.puts "**Line Coverage:** #{line_percent} (#{covered_lines}/#{total_lines} lines)"
+    f.puts ""
+
+    if branch_percent
+      f.puts "**Branch Coverage:** #{branch_percent} (#{overall_covered_branches}/#{overall_total_branches} branches)"
+      f.puts ""
+    end
+
+    # Add visual indicators
+    line_pct_value = line_percent.gsub("%", "").to_f
+    branch_pct_value = branch_percent&.gsub("%", "")&.to_f
+
+    if line_pct_value >= 95 && (!branch_pct_value || branch_pct_value >= 95)
+      f.puts "✅ Coverage meets quality thresholds"
+    elsif line_pct_value >= 80 && (!branch_pct_value || branch_pct_value >= 80)
+      f.puts "⚠️ Coverage is acceptable but could be improved"
+    else
+      f.puts "❌ Coverage is below recommended thresholds"
+    end
+  end
+end

data/bin/rubocop

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler/setup"
+
+# Explicit RuboCop config increases performance slightly while avoiding config confusion.
+ARGV.unshift("--config", File.expand_path("../.rubocop.yml", __dir__))
+
+load Gem.bin_path("rubocop", "rubocop")