From cf3727f50dd4acb011c18c40920cca9872b36f0e Mon Sep 17 00:00:00 2001 From: "Dhanji R. Prasanna" Date: Sun, 11 Jan 2026 16:41:41 +0530 Subject: [PATCH] refactor(g3-cli): Extract focused modules from lib.rs for improved readability Extract three cohesive modules from the monolithic lib.rs (3188 -> 2785 lines): - metrics.rs (147 lines): Turn metrics tracking and histogram generation - TurnMetrics struct - format_elapsed_time() for human-readable durations - generate_turn_histogram() for performance visualization - Added unit tests for core functions - project_files.rs (181 lines): Project file reading utilities - read_agents_config() for AGENTS.md loading - read_project_readme() for README detection - read_project_memory() for .g3/memory.md - extract_readme_heading() for display - Added unit tests - coach_feedback.rs (129 lines): Coach feedback extraction from session logs - extract_from_logs() main entry point - Helper functions for log parsing and text extraction All modules have clear single responsibilities, improved documentation, and maintain identical behavior to the original inline functions. Agent: carmack --- crates/g3-cli/src/coach_feedback.rs | 129 +++++++++ crates/g3-cli/src/lib.rs | 431 +--------------------------- crates/g3-cli/src/metrics.rs | 147 ++++++++++ crates/g3-cli/src/project_files.rs | 181 ++++++++++++ 4 files changed, 471 insertions(+), 417 deletions(-) create mode 100644 crates/g3-cli/src/coach_feedback.rs create mode 100644 crates/g3-cli/src/metrics.rs create mode 100644 crates/g3-cli/src/project_files.rs diff --git a/crates/g3-cli/src/coach_feedback.rs b/crates/g3-cli/src/coach_feedback.rs new file mode 100644 index 0000000..313262d --- /dev/null +++ b/crates/g3-cli/src/coach_feedback.rs @@ -0,0 +1,129 @@ +//! Coach feedback extraction from session logs. +//! +//! Extracts feedback from the coach agent's session logs for the coach-player loop. + +use anyhow::Result; +use std::path::Path; + +use g3_core::Agent; + +use crate::simple_output::SimpleOutput; +use crate::ui_writer_impl::ConsoleUiWriter; + +/// Extract coach feedback by reading from the coach agent's specific log file. +/// +/// Uses the coach agent's session ID to find the exact log file. +pub fn extract_from_logs( + coach_result: &g3_core::TaskResult, + coach_agent: &Agent, + output: &SimpleOutput, +) -> Result { + let session_id = coach_agent + .get_session_id() + .ok_or_else(|| anyhow::anyhow!("Coach agent has no session ID"))?; + + let log_file_path = resolve_log_path(&session_id); + + // Try to extract from session log + if let Some(feedback) = try_extract_from_log(&log_file_path) { + output.print(&format!("āœ… Extracted coach feedback from session: {}", session_id)); + return Ok(feedback); + } + + // Fallback: use the TaskResult's extract_summary method + let fallback = coach_result.extract_summary(); + if !fallback.is_empty() { + output.print(&format!( + "āœ… Extracted coach feedback from response: {} chars", + fallback.len() + )); + return Ok(fallback); + } + + Err(anyhow::anyhow!( + "Could not extract coach feedback from session: {}\n\ + Log file path: {:?}\n\ + Log file exists: {}\n\ + Coach result response length: {} chars", + session_id, + log_file_path, + log_file_path.exists(), + coach_result.response.len() + )) +} + +/// Resolve the log file path, trying new path first then falling back to old. +fn resolve_log_path(session_id: &str) -> std::path::PathBuf { + let new_path = g3_core::get_session_file(session_id); + if new_path.exists() { + new_path + } else { + Path::new("logs").join(format!("g3_session_{}.json", session_id)) + } +} + +/// Extract feedback from a session log file. +/// +/// Searches backwards for the last assistant message with substantial text content. +fn try_extract_from_log(log_file_path: &Path) -> Option { + if !log_file_path.exists() { + return None; + } + + let log_content = std::fs::read_to_string(log_file_path).ok()?; + let log_json: serde_json::Value = serde_json::from_str(&log_content).ok()?; + + let messages = log_json + .get("context_window")? + .get("conversation_history")? + .as_array()?; + + // Search backwards for the last assistant message with text content + for msg in messages.iter().rev() { + if let Some(feedback) = extract_assistant_text(msg) { + return Some(feedback); + } + } + + None +} + +/// Extract text content from an assistant message. +fn extract_assistant_text(msg: &serde_json::Value) -> Option { + let role = msg.get("role").and_then(|v| v.as_str())?; + if !role.eq_ignore_ascii_case("assistant") { + return None; + } + + let content = msg.get("content")?; + + // Handle string content + if let Some(content_str) = content.as_str() { + return filter_substantial_text(content_str); + } + + // Handle array content (native tool calling format) + if let Some(content_array) = content.as_array() { + for block in content_array { + if block.get("type").and_then(|v| v.as_str()) == Some("text") { + if let Some(text) = block.get("text").and_then(|v| v.as_str()) { + if let Some(result) = filter_substantial_text(text) { + return Some(result); + } + } + } + } + } + + None +} + +/// Filter out empty or very short responses (likely just tool calls). +fn filter_substantial_text(text: &str) -> Option { + let trimmed = text.trim(); + if !trimmed.is_empty() && trimmed.len() > 10 { + Some(trimmed.to_string()) + } else { + None + } +} diff --git a/crates/g3-cli/src/lib.rs b/crates/g3-cli/src/lib.rs index e753542..e9fa0fd 100644 --- a/crates/g3-cli/src/lib.rs +++ b/crates/g3-cli/src/lib.rs @@ -1,253 +1,17 @@ -// JSON tool call filtering for display (moved from g3-core) +//! G3 CLI - Command-line interface for the G3 AI coding agent. + pub mod filter_json; +pub mod metrics; +pub mod project_files; pub mod streaming_markdown; +mod coach_feedback; +mod machine_ui_writer; +mod simple_output; +mod ui_writer_impl; + use anyhow::Result; use crossterm::style::{Color, ResetColor, SetForegroundColor}; -use std::time::{Duration, Instant}; - -#[derive(Debug, Clone)] -struct TurnMetrics { - turn_number: usize, - tokens_used: u32, - wall_clock_time: Duration, -} - -/// Generate a histogram showing tokens used and wall clock time per turn -fn generate_turn_histogram(turn_metrics: &[TurnMetrics]) -> String { - if turn_metrics.is_empty() { - return " No turn data available".to_string(); - } - - let mut histogram = String::new(); - - // Find max values for scaling - let max_tokens = turn_metrics - .iter() - .map(|t| t.tokens_used) - .max() - .unwrap_or(1); - let max_time_ms = turn_metrics - .iter() - .map(|t| t.wall_clock_time.as_millis().min(u32::MAX as u128) as u32) - .max() - .unwrap_or(1); - - // Constants for histogram display - const MAX_BAR_WIDTH: usize = 40; - const TOKEN_CHAR: char = 'ā–ˆ'; - const TIME_CHAR: char = 'ā–“'; - - histogram.push_str("\nšŸ“Š Per-Turn Performance Histogram:\n"); - histogram.push_str(&format!( - " {} = Tokens Used (max: {})\n", - TOKEN_CHAR, max_tokens - )); - histogram.push_str(&format!( - " {} = Wall Clock Time (max: {:.1}s)\n\n", - TIME_CHAR, - max_time_ms as f64 / 1000.0 - )); - - for metrics in turn_metrics { - let turn_time_ms = metrics.wall_clock_time.as_millis().min(u32::MAX as u128) as u32; - - // Calculate bar lengths (proportional to max values) - let token_bar_len = if max_tokens > 0 { - ((metrics.tokens_used as f64 / max_tokens as f64) * MAX_BAR_WIDTH as f64) as usize - } else { - 0 - }; - - let time_bar_len = if max_time_ms > 0 { - ((turn_time_ms as f64 / max_time_ms as f64) * MAX_BAR_WIDTH as f64) as usize - } else { - 0 - }; - - // Format time duration - let time_str = if turn_time_ms < 1000 { - format!("{}ms", turn_time_ms) - } else if turn_time_ms < 60_000 { - format!("{:.1}s", turn_time_ms as f64 / 1000.0) - } else { - let minutes = turn_time_ms / 60_000; - let seconds = (turn_time_ms % 60_000) as f64 / 1000.0; - format!("{}m{:.1}s", minutes, seconds) - }; - - // Create the bars - let token_bar = TOKEN_CHAR.to_string().repeat(token_bar_len); - let time_bar = TIME_CHAR.to_string().repeat(time_bar_len); - - // Add turn information - histogram.push_str(&format!( - " Turn {:2}: {:>6} tokens ā”‚{:<40}ā”‚\n", - metrics.turn_number, metrics.tokens_used, token_bar - )); - histogram.push_str(&format!( - " {:>6} ā”‚{:<40}ā”‚\n", - time_str, time_bar - )); - - // Add separator line between turns (except for last turn) - if metrics.turn_number != turn_metrics.last().unwrap().turn_number { - histogram - .push_str(" ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”¼ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”¤\n"); - } - } - - // Add summary statistics - let total_tokens: u32 = turn_metrics.iter().map(|t| t.tokens_used).sum(); - let total_time: Duration = turn_metrics.iter().map(|t| t.wall_clock_time).sum(); - let avg_tokens = total_tokens as f64 / turn_metrics.len() as f64; - let avg_time_ms = total_time.as_millis() as f64 / turn_metrics.len() as f64; - - histogram.push_str("\nšŸ“ˆ Summary Statistics:\n"); - histogram.push_str(&format!( - " ā€¢ Total Tokens: {} across {} turns\n", - total_tokens, - turn_metrics.len() - )); - histogram.push_str(&format!(" ā€¢ Average Tokens/Turn: {:.1}\n", avg_tokens)); - histogram.push_str(&format!( - " ā€¢ Total Time: {:.1}s\n", - total_time.as_secs_f64() - )); - histogram.push_str(&format!( - " ā€¢ Average Time/Turn: {:.1}s\n", - avg_time_ms / 1000.0 - )); - - histogram -} - -/// Format a Duration as human-readable elapsed time (e.g., "1h 23m 45s", "5m 30s", "45s") -fn format_elapsed_time(duration: Duration) -> String { - let total_secs = duration.as_secs(); - let hours = total_secs / 3600; - let minutes = (total_secs % 3600) / 60; - let seconds = total_secs % 60; - - if hours > 0 { - format!("{}h {}m {}s", hours, minutes, seconds) - } else if minutes > 0 { - format!("{}m {}s", minutes, seconds) - } else if seconds > 0 { - format!("{}s", seconds) - } else { - // For very short durations, show milliseconds - format!("{}ms", duration.as_millis()) - } -} - -/// Extract coach feedback by reading from the coach agent's specific log file -/// Uses the coach agent's session ID to find the exact log file -fn extract_coach_feedback_from_logs( - coach_result: &g3_core::TaskResult, - coach_agent: &g3_core::Agent, - output: &SimpleOutput, -) -> Result { - // Get the coach agent's session ID - let session_id = coach_agent - .get_session_id() - .ok_or_else(|| anyhow::anyhow!("Coach agent has no session ID"))?; - - // Try new .g3/sessions//session.json path first - let log_file_path = g3_core::get_session_file(&session_id); - - // Fall back to old logs/ path if new path doesn't exist - let log_file_path = if log_file_path.exists() { - log_file_path - } else { - let logs_dir = std::path::Path::new("logs"); - logs_dir.join(format!("g3_session_{}.json", session_id)) - }; - - // Try to extract from session log - if let Some(feedback) = try_extract_feedback_from_log(&log_file_path, output) { - output.print(&format!( - "āœ… Extracted coach feedback from session: {}", - session_id - )); - return Ok(feedback); - } - - // Fallback: use the TaskResult's extract_summary method - let fallback = coach_result.extract_summary(); - if !fallback.is_empty() { - output.print(&format!( - "āœ… Extracted coach feedback from response: {} chars", - fallback.len() - )); - return Ok(fallback); - } - - // Last resort: return an error instead of panicking - Err(anyhow::anyhow!( - "Could not extract coach feedback from session: {}\n\ - Log file path: {:?}\n\ - Log file exists: {}\n\ - Coach result response length: {} chars", - session_id, - log_file_path, - log_file_path.exists(), - coach_result.response.len() - )) -} - -/// Helper function to extract feedback from a session log file -/// Looks for the last assistant message with substantial text content -fn try_extract_feedback_from_log( - log_file_path: &std::path::Path, - _output: &SimpleOutput, -) -> Option { - if !log_file_path.exists() { - return None; - } - - let log_content = std::fs::read_to_string(log_file_path).ok()?; - let log_json: serde_json::Value = serde_json::from_str(&log_content).ok()?; - - let messages = log_json - .get("context_window")? - .get("conversation_history")? - .as_array()?; - - // Search backwards for the last assistant message with text content - for msg in messages.iter().rev() { - let role = msg.get("role").and_then(|v| v.as_str())?; - - if role.eq_ignore_ascii_case("assistant") { - if let Some(content) = msg.get("content") { - // Handle string content - if let Some(content_str) = content.as_str() { - let trimmed = content_str.trim(); - // Skip empty or very short responses (likely just tool calls) - if !trimmed.is_empty() && trimmed.len() > 10 { - return Some(trimmed.to_string()); - } - } - // Handle array content (native tool calling format) - if let Some(content_array) = content.as_array() { - for block in content_array { - if block.get("type").and_then(|v| v.as_str()) == Some("text") { - if let Some(text) = block.get("text").and_then(|v| v.as_str()) { - let trimmed = text.trim(); - if !trimmed.is_empty() && trimmed.len() > 10 { - return Some(trimmed.to_string()); - } - } - } - } - } - } - } - } - - None -} - use clap::Parser; use g3_config::Config; use g3_core::{project::Project, ui_writer::UiWriter, Agent, DiscoveryOptions}; @@ -257,15 +21,15 @@ use sha2::{Digest, Sha256}; use std::path::Path; use std::path::PathBuf; use std::process::exit; +use std::time::Instant; use tokio_util::sync::CancellationToken; use tracing::{debug, error}; use g3_core::error_handling::{classify_error, ErrorType, RecoverableError}; -mod simple_output; -mod ui_writer_impl; -use simple_output::SimpleOutput; -mod machine_ui_writer; use machine_ui_writer::MachineUiWriter; +use metrics::{format_elapsed_time, generate_turn_histogram, TurnMetrics}; +use project_files::{extract_readme_heading, read_agents_config, read_project_memory, read_project_readme}; +use simple_output::SimpleOutput; use ui_writer_impl::ConsoleUiWriter; #[derive(Parser, Clone)] @@ -1423,173 +1187,6 @@ async fn run_with_machine_mode( } /// Check if we're in a project directory and read AGENTS.md if available -fn read_agents_config(workspace_dir: &Path) -> Option { - // Look for AGENTS.md in the current directory - let agents_path = workspace_dir.join("AGENTS.md"); - - if agents_path.exists() { - match std::fs::read_to_string(&agents_path) { - Ok(content) => { - // Return the content with a note about which file was read - Some(format!( - "šŸ¤– Agent Configuration (from AGENTS.md):\n\n{}", - content - )) - } - Err(e) => { - // Log the error but continue without the agents config - error!("Failed to read AGENTS.md: {}", e); - None - } - } - } else { - // Check for alternative names - let alt_path = workspace_dir.join("agents.md"); - if alt_path.exists() { - match std::fs::read_to_string(&alt_path) { - Ok(content) => Some(format!( - "šŸ¤– Agent Configuration (from agents.md):\n\n{}", - content - )), - Err(e) => { - error!("Failed to read agents.md: {}", e); - None - } - } - } else { - None - } - } -} - -/// Check if we're in a project directory and read README if available -fn read_project_readme(workspace_dir: &Path) -> Option { - // Check if we're in a project directory (contains .g3 or .git) - let is_project_dir = workspace_dir.join(".g3").exists() || workspace_dir.join(".git").exists(); - - if !is_project_dir { - return None; - } - - // Look for README files in common formats - let readme_names = [ - "README.md", - "README.MD", - "readme.md", - "Readme.md", - "README", - "README.txt", - "README.rst", - ]; - - for readme_name in &readme_names { - let readme_path = workspace_dir.join(readme_name); - if readme_path.exists() { - match std::fs::read_to_string(&readme_path) { - Ok(content) => { - // Return the content with a note about which file was read - return Some(format!( - "šŸ“š Project README (from {}):\n\n{}", - readme_name, content - )); - } - Err(e) => { - // Log the error but continue looking for other README files - error!("Failed to read {}: {}", readme_path.display(), e); - } - } - } - } - - None -} - -/// Read project memory if available -fn read_project_memory(workspace_dir: &Path) -> Option { - let memory_path = workspace_dir.join(".g3").join("memory.md"); - - if memory_path.exists() { - match std::fs::read_to_string(&memory_path) { - Ok(content) => { - let size = if content.len() < 1000 { - format!("{} chars", content.len()) - } else { - format!("{:.1}k chars", content.len() as f64 / 1000.0) - }; - Some(format!( - "šŸ§  Project Memory ({}):\n\n{}", - size, content - )) - } - Err(_) => None, - } - } else { - None - } -} - -/// Extract the main heading or title from README content -fn extract_readme_heading(readme_content: &str) -> Option { - // Find the README section in the combined content - // The README section starts with "šŸ“š Project README (from" - let readme_start = readme_content.find("šŸ“š Project README (from"); - - // If we can't find the README marker, the content might be just README - // or might not contain README at all - let content_to_search = match readme_start { - Some(pos) => &readme_content[pos..], - None => readme_content, - }; - - // Process the content line by line, skipping the prefix line - let mut content_lines = Vec::new(); - for line in content_to_search.lines() { - // Skip the "šŸ“š Project README (from ...):" line - if line.starts_with("šŸ“š Project README") { - continue; - } - content_lines.push(line); - } - let content = content_lines.join("\n"); - - // Look for the first markdown heading - for line in content.lines() { - let trimmed = line.trim(); - - // Check for H1 heading (# Title) - if let Some(stripped) = trimmed.strip_prefix("# ") { - let title = stripped.trim(); - if !title.is_empty() { - // Return the full title (including any description after dash) - return Some(title.to_string()); - } - } - - // Skip other markdown headings for now (##, ###, etc.) - // We're only looking for the main H1 heading - } - - // If no H1 heading found, look for the first non-empty, non-metadata line as a fallback - for line in content.lines().take(5) { - let trimmed = line.trim(); - // Skip empty lines, other heading markers, and metadata - if !trimmed.is_empty() - && !trimmed.starts_with("šŸ“š") - && !trimmed.starts_with('#') - && !trimmed.starts_with("==") - && !trimmed.starts_with("--") - { - // Limit length for display - return Some(if trimmed.len() > 100 { - format!("{}...", &trimmed[..97]) - } else { - trimmed.to_string() - }); - } - } - None -} - async fn run_interactive( mut agent: Agent, show_prompt: bool, @@ -3063,7 +2660,7 @@ Remember: Be clear in your review and concise in your feedback. APPROVE iff the // Extract the complete coach feedback from the response let coach_feedback_text = - extract_coach_feedback_from_logs(&coach_result, &coach_agent, &output)?; + coach_feedback::extract_from_logs(&coach_result, &coach_agent, &output)?; // Log the size of the feedback for debugging debug!( diff --git a/crates/g3-cli/src/metrics.rs b/crates/g3-cli/src/metrics.rs new file mode 100644 index 0000000..6b3fa2d --- /dev/null +++ b/crates/g3-cli/src/metrics.rs @@ -0,0 +1,147 @@ +//! Turn metrics and histogram generation for performance visualization. + +use std::time::Duration; + +/// Metrics captured for a single turn of interaction. +#[derive(Debug, Clone)] +pub struct TurnMetrics { + pub turn_number: usize, + pub tokens_used: u32, + pub wall_clock_time: Duration, +} + +/// Format a Duration as human-readable elapsed time (e.g., "1h 23m 45s"). +pub fn format_elapsed_time(duration: Duration) -> String { + let total_secs = duration.as_secs(); + let hours = total_secs / 3600; + let minutes = (total_secs % 3600) / 60; + let seconds = total_secs % 60; + + match (hours, minutes, seconds) { + (h, m, s) if h > 0 => format!("{}h {}m {}s", h, m, s), + (_, m, s) if m > 0 => format!("{}m {}s", m, s), + (_, _, s) if s > 0 => format!("{}s", s), + _ => format!("{}ms", duration.as_millis()), + } +} + +/// Generate a histogram showing tokens used and wall clock time per turn. +pub fn generate_turn_histogram(turn_metrics: &[TurnMetrics]) -> String { + if turn_metrics.is_empty() { + return " No turn data available".to_string(); + } + + const MAX_BAR_WIDTH: usize = 40; + const TOKEN_CHAR: char = 'ā–ˆ'; + const TIME_CHAR: char = 'ā–“'; + + let max_tokens = turn_metrics.iter().map(|t| t.tokens_used).max().unwrap_or(1); + let max_time_ms = turn_metrics + .iter() + .map(|t| t.wall_clock_time.as_millis().min(u32::MAX as u128) as u32) + .max() + .unwrap_or(1); + + let mut histogram = String::new(); + histogram.push_str("\nšŸ“Š Per-Turn Performance Histogram:\n"); + histogram.push_str(&format!(" {} = Tokens Used (max: {})\n", TOKEN_CHAR, max_tokens)); + histogram.push_str(&format!( + " {} = Wall Clock Time (max: {:.1}s)\n\n", + TIME_CHAR, + max_time_ms as f64 / 1000.0 + )); + + for metrics in turn_metrics { + let turn_time_ms = metrics.wall_clock_time.as_millis().min(u32::MAX as u128) as u32; + + let token_bar_len = scale_bar(metrics.tokens_used, max_tokens, MAX_BAR_WIDTH); + let time_bar_len = scale_bar(turn_time_ms, max_time_ms, MAX_BAR_WIDTH); + + let time_str = format_duration_ms(turn_time_ms); + let token_bar = TOKEN_CHAR.to_string().repeat(token_bar_len); + let time_bar = TIME_CHAR.to_string().repeat(time_bar_len); + + histogram.push_str(&format!( + " Turn {:2}: {:>6} tokens ā”‚{:<40}ā”‚\n", + metrics.turn_number, metrics.tokens_used, token_bar + )); + histogram.push_str(&format!(" {:>6} ā”‚{:<40}ā”‚\n", time_str, time_bar)); + + // Separator between turns (except for last) + if metrics.turn_number != turn_metrics.last().unwrap().turn_number { + histogram.push_str( + " ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”¼ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”¤\n", + ); + } + } + + append_summary_statistics(&mut histogram, turn_metrics); + histogram +} + +/// Scale a value to a bar length proportional to max. +fn scale_bar(value: u32, max: u32, max_width: usize) -> usize { + if max == 0 { + 0 + } else { + ((value as f64 / max as f64) * max_width as f64) as usize + } +} + +/// Format milliseconds as a human-readable duration string. +fn format_duration_ms(ms: u32) -> String { + match ms { + ms if ms < 1000 => format!("{}ms", ms), + ms if ms < 60_000 => format!("{:.1}s", ms as f64 / 1000.0), + ms => { + let minutes = ms / 60_000; + let seconds = (ms % 60_000) as f64 / 1000.0; + format!("{}m{:.1}s", minutes, seconds) + } + } +} + +/// Append summary statistics to the histogram output. +fn append_summary_statistics(histogram: &mut String, turn_metrics: &[TurnMetrics]) { + let total_tokens: u32 = turn_metrics.iter().map(|t| t.tokens_used).sum(); + let total_time: Duration = turn_metrics.iter().map(|t| t.wall_clock_time).sum(); + let avg_tokens = total_tokens as f64 / turn_metrics.len() as f64; + let avg_time_ms = total_time.as_millis() as f64 / turn_metrics.len() as f64; + + histogram.push_str("\nšŸ“ˆ Summary Statistics:\n"); + histogram.push_str(&format!( + " ā€¢ Total Tokens: {} across {} turns\n", + total_tokens, + turn_metrics.len() + )); + histogram.push_str(&format!(" ā€¢ Average Tokens/Turn: {:.1}\n", avg_tokens)); + histogram.push_str(&format!(" ā€¢ Total Time: {:.1}s\n", total_time.as_secs_f64())); + histogram.push_str(&format!(" ā€¢ Average Time/Turn: {:.1}s\n", avg_time_ms / 1000.0)); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_format_elapsed_time() { + assert_eq!(format_elapsed_time(Duration::from_millis(500)), "500ms"); + assert_eq!(format_elapsed_time(Duration::from_secs(45)), "45s"); + assert_eq!(format_elapsed_time(Duration::from_secs(90)), "1m 30s"); + assert_eq!(format_elapsed_time(Duration::from_secs(3661)), "1h 1m 1s"); + } + + #[test] + fn test_empty_histogram() { + let result = generate_turn_histogram(&[]); + assert!(result.contains("No turn data available")); + } + + #[test] + fn test_scale_bar() { + assert_eq!(scale_bar(50, 100, 40), 20); + assert_eq!(scale_bar(100, 100, 40), 40); + assert_eq!(scale_bar(0, 100, 40), 0); + assert_eq!(scale_bar(50, 0, 40), 0); + } +} diff --git a/crates/g3-cli/src/project_files.rs b/crates/g3-cli/src/project_files.rs new file mode 100644 index 0000000..e74887d --- /dev/null +++ b/crates/g3-cli/src/project_files.rs @@ -0,0 +1,181 @@ +//! Project file reading utilities. +//! +//! Reads AGENTS.md, README.md, and project memory files from the workspace. + +use std::path::Path; +use tracing::error; + +/// Read AGENTS.md configuration from the workspace directory. +/// Returns formatted content with emoji prefix, or None if not found. +pub fn read_agents_config(workspace_dir: &Path) -> Option { + // Try AGENTS.md first, then agents.md + let paths = [ + (workspace_dir.join("AGENTS.md"), "AGENTS.md"), + (workspace_dir.join("agents.md"), "agents.md"), + ]; + + for (path, name) in &paths { + if path.exists() { + match std::fs::read_to_string(path) { + Ok(content) => { + return Some(format!("šŸ¤– Agent Configuration (from {}):{}\n{}", name, "\n", content)); + } + Err(e) => { + error!("Failed to read {}: {}", name, e); + } + } + } + } + None +} + +/// Read README from the workspace directory if it's a project directory. +/// Returns formatted content with emoji prefix, or None if not found. +pub fn read_project_readme(workspace_dir: &Path) -> Option { + // Only read README if we're in a project directory + let is_project_dir = workspace_dir.join(".g3").exists() || workspace_dir.join(".git").exists(); + if !is_project_dir { + return None; + } + + const README_NAMES: &[&str] = &[ + "README.md", + "README.MD", + "readme.md", + "Readme.md", + "README", + "README.txt", + "README.rst", + ]; + + for name in README_NAMES { + let path = workspace_dir.join(name); + if path.exists() { + match std::fs::read_to_string(&path) { + Ok(content) => { + return Some(format!("šŸ“š Project README (from {}):{}\n{}", name, "\n", content)); + } + Err(e) => { + error!("Failed to read {}: {}", path.display(), e); + } + } + } + } + None +} + +/// Read project memory from .g3/memory.md in the workspace directory. +/// Returns formatted content with emoji prefix and size info, or None if not found. +pub fn read_project_memory(workspace_dir: &Path) -> Option { + let memory_path = workspace_dir.join(".g3").join("memory.md"); + + if !memory_path.exists() { + return None; + } + + match std::fs::read_to_string(&memory_path) { + Ok(content) => { + let size = format_size(content.len()); + Some(format!("šŸ§  Project Memory ({}):{}\n{}", size, "\n", content)) + } + Err(_) => None, + } +} + +/// Format a byte size for display. +fn format_size(len: usize) -> String { + if len < 1000 { + format!("{} chars", len) + } else { + format!("{:.1}k chars", len as f64 / 1000.0) + } +} + +/// Extract the first H1 heading from README content for display. +pub fn extract_readme_heading(readme_content: &str) -> Option { + // Find where the actual README content starts (after any prefix markers) + let readme_start = readme_content.find("šŸ“š Project README (from"); + + let content_to_search = match readme_start { + Some(pos) => &readme_content[pos..], + None => readme_content, + }; + + // Skip the prefix line and collect content + let content: String = content_to_search + .lines() + .filter(|line| !line.starts_with("šŸ“š Project README")) + .collect::>() + .join("\n"); + + // Look for H1 heading + for line in content.lines() { + let trimmed = line.trim(); + if let Some(stripped) = trimmed.strip_prefix("# ") { + let title = stripped.trim(); + if !title.is_empty() { + return Some(title.to_string()); + } + } + } + + // Fallback: first non-empty, non-metadata line + find_fallback_title(&content) +} + +/// Find a fallback title from the first few lines of content. +fn find_fallback_title(content: &str) -> Option { + for line in content.lines().take(5) { + let trimmed = line.trim(); + if !trimmed.is_empty() + && !trimmed.starts_with("šŸ“š") + && !trimmed.starts_with('#') + && !trimmed.starts_with("==") + && !trimmed.starts_with("--") + { + return Some(truncate_for_display(trimmed, 100)); + } + } + None +} + +/// Truncate a string for display, adding ellipsis if needed. +fn truncate_for_display(s: &str, max_len: usize) -> String { + if s.len() > max_len { + format!("{}...", &s[..max_len - 3]) + } else { + s.to_string() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_extract_readme_heading() { + let content = "# My Project\n\nSome description"; + assert_eq!(extract_readme_heading(content), Some("My Project".to_string())); + } + + #[test] + fn test_extract_readme_heading_with_prefix() { + let content = "šŸ“š Project README (from README.md):\n# Cool App\n\nDescription"; + assert_eq!(extract_readme_heading(content), Some("Cool App".to_string())); + } + + #[test] + fn test_format_size() { + assert_eq!(format_size(500), "500 chars"); + assert_eq!(format_size(1500), "1.5k chars"); + } + + #[test] + fn test_truncate_for_display() { + assert_eq!(truncate_for_display("short", 100), "short"); + let long = "a".repeat(150); + let truncated = truncate_for_display(&long, 100); + assert!(truncated.ends_with("...")); + assert_eq!(truncated.len(), 100); + } +}