//
// -----------------------------------------------------------------------------
// SMART FORMATTER: Surface What Matters
//
// This formatter transforms a wall of files into actionable intelligence.
// Instead of "here's everything", it says "here's what you need to know."
//
// Output is grouped by interest level:
// - SECURITY: Critical findings that need immediate attention
// - IMPORTANT: Key files, recent changes, high-interest items
// - CHANGES: What's different since last scan
// - NOTABLE: Worth knowing but not urgent
// - BACKGROUND: Summary count (not listed individually)
//
// "Don't list everything. Surface what matters." - The Smart Tree Philosophy
// -----------------------------------------------------------------------------
//
use crate::formatters::{Formatter, PathDisplayMode};
use crate::scanner::{FileNode, TreeStats};
use crate::scanner_interest::InterestLevel;
use crate::security_scan::RiskLevel;
use anyhow::Result;
use std::collections::HashMap;
use std::io::Write;
use std::path::Path;
use std::time::SystemTime;
/// Smart Formatter - Groups output by interest level
pub struct SmartFormatter {
/// Use colors in output
use_color: bool,
/// Use emoji in output
use_emoji: bool,
/// Show background files individually (default: just count)
show_background: bool,
/// Path display mode
path_mode: PathDisplayMode,
/// Minimum interest level to show individually
min_level: InterestLevel,
}
impl SmartFormatter {
pub fn new(use_color: bool, use_emoji: bool) -> Self {
Self {
use_color,
use_emoji,
show_background: false,
path_mode: PathDisplayMode::Relative,
min_level: InterestLevel::Background,
}
}
/// Set whether to show background files individually
pub fn with_show_background(mut self, show: bool) -> Self {
self.show_background = show;
self
}
/// Set path display mode
pub fn with_path_mode(mut self, mode: PathDisplayMode) -> Self {
self.path_mode = mode;
self
}
/// Set minimum interest level to display
pub fn with_min_level(mut self, level: InterestLevel) -> Self {
self.min_level = level;
self
}
/// Format a path for display
fn format_path<'a>(&self, path: &'a Path, root: &Path) -> std::borrow::Cow<'a, str> {
match self.path_mode {
PathDisplayMode::Off => path
.file_name()
.map(|n| n.to_string_lossy())
.unwrap_or_else(|| path.to_string_lossy()),
PathDisplayMode::Relative => path
.strip_prefix(root)
.map(|p| p.to_string_lossy())
.unwrap_or_else(|_| path.to_string_lossy()),
PathDisplayMode::Full => path.to_string_lossy(),
}
}
/// Get color code for interest level
fn level_color(&self, level: InterestLevel) -> &'static str {
if !self.use_color {
return "";
}
match level {
InterestLevel::Critical => "\x1b[1;31m", // Bold red
InterestLevel::Important => "\x1b[1;33m", // Bold yellow
InterestLevel::Notable => "\x1b[36m", // Cyan
InterestLevel::Background => "\x1b[90m", // Gray
InterestLevel::Boring => "\x1b[90m", // Gray
}
}
/// Get color code for risk level
fn risk_color(&self, risk: RiskLevel) -> &'static str {
if !self.use_color {
return "";
}
match risk {
RiskLevel::Critical => "\x1b[1;31m", // Bold red
RiskLevel::High => "\x1b[31m", // Red
RiskLevel::Medium => "\x1b[33m", // Yellow
RiskLevel::Low => "\x1b[36m", // Cyan
}
}
/// Reset color
fn reset(&self) -> &'static str {
if self.use_color {
"\x1b[0m"
} else {
""
}
}
/// Get emoji for section
fn section_emoji(&self, section: &str) -> &'static str {
if !self.use_emoji {
return "";
}
match section {
"security" => "⚠️ ",
"important" => "🔥 ",
"changes" => "📝 ",
"notable" => "📌 ",
"background" => "📦 ",
"project" => "🌳 ",
_ => "",
}
}
/// Format time ago string
fn time_ago(&self, modified: SystemTime) -> String {
let now = SystemTime::now();
let duration = now.duration_since(modified).unwrap_or_default();
let secs = duration.as_secs();
if secs < 60 {
"just now".to_string()
} else if secs < 3600 {
format!("{}m ago", secs / 60)
} else if secs < 86400 {
format!("{}h ago", secs / 3600)
} else if secs < 604800 {
format!("{}d ago", secs / 86400)
} else {
format!("{}w ago", secs / 604800)
}
}
/// Detect project type from nodes
fn detect_project_type(&self, nodes: &[FileNode]) -> Option<(&'static str, Option<String>)> {
for node in nodes {
if node.is_dir {
continue;
}
let name = node.path.file_name()?.to_str()?;
match name.to_lowercase().as_str() {
"cargo.toml" => return Some(("Rust", node.git_branch.clone())),
"package.json" => return Some(("Node.js", node.git_branch.clone())),
"pyproject.toml" | "setup.py" => return Some(("Python", node.git_branch.clone())),
"go.mod" => return Some(("Go", node.git_branch.clone())),
"gemfile" => return Some(("Ruby", node.git_branch.clone())),
"pom.xml" | "build.gradle" => return Some(("Java", node.git_branch.clone())),
_ => continue,
}
}
// Check for git branch in any node
for node in nodes {
if let Some(ref branch) = node.git_branch {
return Some(("Project", Some(branch.clone())));
}
}
None
}
/// Group nodes by interest level
fn group_by_interest<'a>(&self, nodes: &'a [FileNode]) -> HashMap<InterestLevel, Vec<&'a FileNode>> {
let mut groups: HashMap<InterestLevel, Vec<&'a FileNode>> = HashMap::new();
for node in nodes {
let level = node
.interest
.as_ref()
.map(|i| i.level)
.unwrap_or(InterestLevel::Background);
groups.entry(level).or_default().push(node);
}
groups
}
/// Collect all security findings from nodes
fn collect_security_findings<'a>(&self, nodes: &'a [FileNode]) -> Vec<(&'a FileNode, &'a crate::security_scan::SecurityFinding)> {
let mut findings = Vec::new();
for node in nodes {
for finding in &node.security_findings {
findings.push((node, finding));
}
}
// Sort by risk level (critical first)
findings.sort_by(|a, b| b.1.risk_level.cmp(&a.1.risk_level));
findings
}
/// Collect changed files
fn collect_changes<'a>(&self, nodes: &'a [FileNode]) -> (Vec<&'a FileNode>, Vec<&'a FileNode>, Vec<&'a FileNode>) {
let mut added = Vec::new();
let mut modified = Vec::new();
let mut deleted = Vec::new(); // We won't have deleted in nodes, but for completeness
for node in nodes {
if let Some(ref change) = node.change_status {
match change {
crate::scanner_interest::ChangeType::Added => added.push(node),
crate::scanner_interest::ChangeType::Modified
| crate::scanner_interest::ChangeType::PermissionChanged
| crate::scanner_interest::ChangeType::TypeChanged
| crate::scanner_interest::ChangeType::Renamed => modified.push(node),
crate::scanner_interest::ChangeType::Deleted => deleted.push(node),
}
}
}
(added, modified, deleted)
}
}
impl Formatter for SmartFormatter {
fn format(
&self,
writer: &mut dyn Write,
nodes: &[FileNode],
stats: &TreeStats,
root_path: &Path,
) -> Result<()> {
// === HEADER: Project info ===
let project_name = root_path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| ".".to_string());
let (project_type, git_branch) = self.detect_project_type(nodes).unwrap_or(("", None));
write!(writer, "{}", self.section_emoji("project"))?;
write!(writer, "{}{}{}", self.level_color(InterestLevel::Important), project_name, self.reset())?;
if !project_type.is_empty() {
write!(writer, " ({})", project_type)?;
}
if let Some(branch) = git_branch {
write!(writer, " [{}]", branch)?;
}
writeln!(writer)?;
writeln!(writer)?;
// === SECURITY SECTION ===
let security_findings = self.collect_security_findings(nodes);
if !security_findings.is_empty() {
writeln!(
writer,
"{}{}SECURITY ({} finding{}){}",
self.section_emoji("security"),
self.level_color(InterestLevel::Critical),
security_findings.len(),
if security_findings.len() == 1 { "" } else { "s" },
self.reset()
)?;
for (node, finding) in security_findings.iter().take(10) {
let path = self.format_path(&node.path, root_path);
writeln!(
writer,
" {}{}: {}{}",
self.risk_color(finding.risk_level),
path,
finding.description,
self.reset()
)?;
}
if security_findings.len() > 10 {
writeln!(
writer,
" {}... and {} more{}",
self.level_color(InterestLevel::Background),
security_findings.len() - 10,
self.reset()
)?;
}
writeln!(writer)?;
}
// === CHANGES SECTION ===
let (added, modified, _deleted) = self.collect_changes(nodes);
if !added.is_empty() || !modified.is_empty() {
writeln!(
writer,
"{}{}CHANGES{}",
self.section_emoji("changes"),
self.level_color(InterestLevel::Notable),
self.reset()
)?;
// Show added files
for node in added.iter().take(5) {
let path = self.format_path(&node.path, root_path);
writeln!(
writer,
" {}+ {}{}",
self.level_color(InterestLevel::Notable),
path,
self.reset()
)?;
}
// Show modified files
for node in modified.iter().take(5) {
let path = self.format_path(&node.path, root_path);
let time = self.time_ago(node.modified);
writeln!(
writer,
" {}~ {} [{}]{}",
self.level_color(InterestLevel::Notable),
path,
time,
self.reset()
)?;
}
let total_changes = added.len() + modified.len();
if total_changes > 10 {
writeln!(
writer,
" {}... and {} more changes{}",
self.level_color(InterestLevel::Background),
total_changes - 10,
self.reset()
)?;
}
writeln!(writer)?;
}
// === IMPORTANT SECTION ===
let groups = self.group_by_interest(nodes);
if let Some(critical) = groups.get(&InterestLevel::Critical) {
if !critical.is_empty() {
writeln!(
writer,
"{}{}CRITICAL{}",
self.section_emoji("important"),
self.level_color(InterestLevel::Critical),
self.reset()
)?;
for node in critical.iter().take(10) {
let path = self.format_path(&node.path, root_path);
let time = self.time_ago(node.modified);
let score = node.interest.as_ref().map(|i| i.score).unwrap_or(0.0);
writeln!(
writer,
" {} [{}] {:.0}%",
path,
time,
score * 100.0
)?;
}
writeln!(writer)?;
}
}
if let Some(important) = groups.get(&InterestLevel::Important) {
if !important.is_empty() {
writeln!(
writer,
"{}{}IMPORTANT{}",
self.section_emoji("important"),
self.level_color(InterestLevel::Important),
self.reset()
)?;
for node in important.iter().take(10) {
let path = self.format_path(&node.path, root_path);
let time = self.time_ago(node.modified);
writeln!(writer, " {} [{}]", path, time)?;
}
if important.len() > 10 {
writeln!(
writer,
" {}... and {} more{}",
self.level_color(InterestLevel::Background),
important.len() - 10,
self.reset()
)?;
}
writeln!(writer)?;
}
}
// === NOTABLE SECTION ===
if let Some(notable) = groups.get(&InterestLevel::Notable) {
if !notable.is_empty() && self.min_level <= InterestLevel::Notable {
writeln!(
writer,
"{}{}NOTABLE ({}){}",
self.section_emoji("notable"),
self.level_color(InterestLevel::Notable),
notable.len(),
self.reset()
)?;
for node in notable.iter().take(5) {
let path = self.format_path(&node.path, root_path);
writeln!(writer, " {}", path)?;
}
if notable.len() > 5 {
writeln!(
writer,
" {}... and {} more{}",
self.level_color(InterestLevel::Background),
notable.len() - 5,
self.reset()
)?;
}
writeln!(writer)?;
}
}
// === BACKGROUND SUMMARY ===
let background_count = groups
.get(&InterestLevel::Background)
.map(|v| v.len())
.unwrap_or(0)
+ groups
.get(&InterestLevel::Boring)
.map(|v| v.len())
.unwrap_or(0);
if background_count > 0 {
writeln!(
writer,
"{}{}BACKGROUND: {} files, {} dirs ({}){}",
self.section_emoji("background"),
self.level_color(InterestLevel::Background),
stats.total_files,
stats.total_dirs,
humansize::format_size(stats.total_size, humansize::BINARY),
self.reset()
)?;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::scanner::{FileCategory, FileType, FilesystemType};
use std::path::PathBuf;
fn make_test_node(path: &str, is_dir: bool) -> FileNode {
FileNode {
path: PathBuf::from(path),
is_dir,
size: 1000,
permissions: 0o644,
uid: 1000,
gid: 1000,
modified: SystemTime::now(),
is_symlink: false,
is_hidden: false,
permission_denied: false,
is_ignored: false,
depth: path.matches('/').count(),
file_type: if is_dir {
FileType::Directory
} else {
FileType::RegularFile
},
category: FileCategory::Unknown,
search_matches: None,
filesystem_type: FilesystemType::Unknown,
git_branch: None,
traversal_context: None,
interest: None,
security_findings: Vec::new(),
change_status: None,
content_hash: None,
}
}
#[test]
fn test_smart_formatter_basic() {
let formatter = SmartFormatter::new(false, false);
let nodes = vec![
make_test_node("src", true),
make_test_node("src/main.rs", false),
make_test_node("Cargo.toml", false),
];
let stats = TreeStats {
total_files: 2,
total_dirs: 1,
total_size: 2000,
file_types: std::collections::HashMap::new(),
largest_files: vec![],
newest_files: vec![],
oldest_files: vec![],
};
let mut output = Vec::new();
formatter
.format(&mut output, &nodes, &stats, Path::new("/project"))
.unwrap();
let output_str = String::from_utf8(output).unwrap();
assert!(output_str.contains("BACKGROUND"));
}
#[test]
fn test_time_ago() {
let formatter = SmartFormatter::new(false, false);
let now = SystemTime::now();
assert_eq!(formatter.time_ago(now), "just now");
let hour_ago = now - std::time::Duration::from_secs(3600);
assert_eq!(formatter.time_ago(hour_ago), "1h ago");
let day_ago = now - std::time::Duration::from_secs(86400);
assert_eq!(formatter.time_ago(day_ago), "1d ago");
}
}
