//
// -----------------------------------------------------------------------------
// INTEREST CALCULATOR: The Scoring Engine
//
// This is where the magic happens. We take raw file metadata and turn it into
// actionable intelligence: "Is this file interesting right now?"
//
// The calculator weighs multiple factors:
// - Recency: Modified in the last 24h? That's hot.
// - Security: Suspicious patterns? Critical.
// - Key files: README, Cargo.toml, package.json? Important.
// - Changes: Different from last scan? Notable.
// - Context: Inside node_modules? Probably boring (unless suspicious).
//
// "Interest is contextual. A config file is boring until it changes." - Omni
// -----------------------------------------------------------------------------
//
use crate::scanner::{FileCategory, FileNode, FilesystemType};
use crate::scanner_interest::{
ChangeType, DependencyManager, InterestFactor, InterestLevel, InterestScore,
InterestWeights, KeyFileType, RiskLevel, TraversalContext, TraversalPath,
};
use crate::scanner_state::{FileSignature, ScanState};
use crate::security_scan::{SecurityFinding, SecurityScanner};
use std::collections::HashSet;
use std::path::Path;
use std::time::SystemTime;
/// The Interest Calculator - determines what's worth showing
pub struct InterestCalculator {
/// Weights for different interest factors
weights: InterestWeights,
/// Previous scan state for change detection
previous_state: Option<ScanState>,
/// Directories marked as "hot" (frequent changes)
hot_dirs: HashSet<std::path::PathBuf>,
/// Security scanner for detecting suspicious patterns
security_scanner: Option<SecurityScanner>,
/// Current time (cached for consistency during scan)
now: SystemTime,
}
impl InterestCalculator {
/// Create a new interest calculator with default weights
pub fn new() -> Self {
Self {
weights: InterestWeights::default(),
previous_state: None,
hot_dirs: HashSet::new(),
security_scanner: Some(SecurityScanner::new()),
now: SystemTime::now(),
}
}
/// Create with custom weights
pub fn with_weights(weights: InterestWeights) -> Self {
Self {
weights,
previous_state: None,
hot_dirs: HashSet::new(),
security_scanner: Some(SecurityScanner::new()),
now: SystemTime::now(),
}
}
/// Set the previous state for change detection
pub fn with_previous_state(mut self, state: ScanState) -> Self {
self.previous_state = Some(state);
self
}
/// Set hot directories to watch
pub fn with_hot_dirs(mut self, dirs: HashSet<std::path::PathBuf>) -> Self {
self.hot_dirs = dirs;
self
}
/// Disable security scanning (for performance)
pub fn without_security(mut self) -> Self {
self.security_scanner = None;
self
}
/// Calculate the interest score for a file node
pub fn calculate(&self, node: &FileNode) -> InterestScore {
let mut factors = Vec::new();
// Factor 1: Recently modified
if let Some(factor) = self.check_recency(node) {
factors.push(factor);
}
// Factor 2: Key project file
if let Some(factor) = self.check_key_file(node) {
factors.push(factor);
}
// Factor 3: Changed since last scan
if let Some(factor) = self.check_changed(node) {
factors.push(factor);
}
// Factor 4: In hot directory
if let Some(factor) = self.check_hot_dir(node) {
factors.push(factor);
}
// Factor 5: Inside dependency tree (negative weight)
if let Some(factor) = self.check_dependency_context(node) {
factors.push(factor);
}
// Factor 6: Virtual filesystem (usually boring)
if let Some(factor) = self.check_filesystem_type(node) {
factors.push(factor);
}
// Factor 7: File category boost
if let Some(factor) = self.check_category_boost(node) {
factors.push(factor);
}
InterestScore::from_factors(factors)
}
/// Calculate interest and include security findings
pub fn calculate_with_security(
&self,
node: &FileNode,
content: Option<&str>,
) -> (InterestScore, Vec<SecurityFinding>) {
let mut factors = Vec::new();
let mut findings = Vec::new();
// Run security scan if enabled and we have content
if let (Some(scanner), Some(content)) = (&self.security_scanner, content) {
let file_findings = scanner.scan_file_content(&node.path, content);
for finding in &file_findings {
let risk_level = match finding.risk_level {
crate::security_scan::RiskLevel::Critical => RiskLevel::Critical,
crate::security_scan::RiskLevel::High => RiskLevel::High,
crate::security_scan::RiskLevel::Medium => RiskLevel::Medium,
crate::security_scan::RiskLevel::Low => RiskLevel::Low,
};
factors.push(InterestFactor::SecurityPattern {
risk: risk_level,
description: finding.description.clone(),
weight: match finding.risk_level {
crate::security_scan::RiskLevel::Critical => 1.0,
crate::security_scan::RiskLevel::High => 0.8,
crate::security_scan::RiskLevel::Medium => 0.5,
crate::security_scan::RiskLevel::Low => 0.2,
},
});
}
findings = file_findings;
}
// Add all other factors
if let Some(factor) = self.check_recency(node) {
factors.push(factor);
}
if let Some(factor) = self.check_key_file(node) {
factors.push(factor);
}
if let Some(factor) = self.check_changed(node) {
factors.push(factor);
}
if let Some(factor) = self.check_hot_dir(node) {
factors.push(factor);
}
if let Some(factor) = self.check_dependency_context(node) {
factors.push(factor);
}
if let Some(factor) = self.check_filesystem_type(node) {
factors.push(factor);
}
if let Some(factor) = self.check_category_boost(node) {
factors.push(factor);
}
(InterestScore::from_factors(factors), findings)
}
/// Check if file was recently modified
fn check_recency(&self, node: &FileNode) -> Option<InterestFactor> {
let duration = self.now.duration_since(node.modified).ok()?;
let hours = duration.as_secs_f32() / 3600.0;
// Interest decays over time
let weight = if hours < 1.0 {
self.weights.recent_modification * 1.5 // Very recent boost
} else if hours < 24.0 {
self.weights.recent_modification * (1.0 - hours / 48.0)
} else if hours < 168.0 {
// Within a week
self.weights.recent_modification * 0.3 * (1.0 - hours / 336.0)
} else {
return None; // Too old to matter
};
if weight > 0.05 {
Some(InterestFactor::RecentlyModified {
hours_ago: hours,
weight,
})
} else {
None
}
}
/// Check if this is a key project file
fn check_key_file(&self, node: &FileNode) -> Option<InterestFactor> {
if node.is_dir {
return None;
}
let file_name = node.path.file_name()?.to_str()?;
let file_name_lower = file_name.to_lowercase();
let key_type = match file_name_lower.as_str() {
// Documentation
"readme.md" | "readme" | "readme.txt" | "changelog.md" | "changelog" | "history.md" => {
Some(KeyFileType::Documentation)
}
// Build configs
"cargo.toml" | "package.json" | "pyproject.toml" | "go.mod" | "gemfile"
| "build.gradle" | "pom.xml" | "makefile" | "cmakelists.txt" => {
Some(KeyFileType::BuildConfig)
}
// Configuration
".env" | ".env.local" | ".env.example" | "config.toml" | "config.yaml"
| "config.json" | "settings.toml" | "settings.yaml" => Some(KeyFileType::Configuration),
// Entry points
"main.rs" | "lib.rs" | "mod.rs" | "index.js" | "index.ts" | "main.py" | "__init__.py"
| "app.py" | "main.go" | "main.java" => Some(KeyFileType::EntryPoint),
// License
"license" | "license.md" | "license.txt" | "copying" => Some(KeyFileType::License),
// CI/CD
".gitlab-ci.yml" | "jenkinsfile" | ".travis.yml" | "azure-pipelines.yml" => {
Some(KeyFileType::CiConfig)
}
// Container
"dockerfile" | "docker-compose.yml" | "docker-compose.yaml" | "containerfile" => {
Some(KeyFileType::Container)
}
// AI config
"claude.md" | ".cursorrules" | ".aider" | "copilot.md" => Some(KeyFileType::AiConfig),
_ => None,
};
// Also check for GitHub workflows
let key_type = key_type.or_else(|| {
if node.path.to_string_lossy().contains(".github/workflows") {
Some(KeyFileType::CiConfig)
} else {
None
}
});
key_type.map(|file_type| InterestFactor::KeyProjectFile {
file_type,
weight: self.weights.key_file,
})
}
/// Check if file changed since last scan
fn check_changed(&self, node: &FileNode) -> Option<InterestFactor> {
let prev_state = self.previous_state.as_ref()?;
let prev_sig = prev_state.signatures.get(&node.path);
match prev_sig {
None => {
// File is new
Some(InterestFactor::ChangedSinceLastScan {
change: ChangeType::Added,
weight: self.weights.changed_since_scan,
})
}
Some(old_sig) => {
// Check if changed
let new_sig = FileSignature::from_path(&node.path).ok()?;
if new_sig.changed(old_sig) {
let change_type = if old_sig.permissions != new_sig.permissions {
ChangeType::PermissionChanged
} else {
ChangeType::Modified
};
Some(InterestFactor::ChangedSinceLastScan {
change: change_type,
weight: self.weights.changed_since_scan,
})
} else {
None
}
}
}
}
/// Check if file is in a hot directory
fn check_hot_dir(&self, node: &FileNode) -> Option<InterestFactor> {
// Check if any ancestor is a hot directory
for ancestor in node.path.ancestors() {
if self.hot_dirs.contains(ancestor) {
return Some(InterestFactor::HotDirectory {
change_count: 0, // We don't track exact count here
weight: self.weights.hot_directory,
});
}
}
None
}
/// Check if inside a dependency tree (reduces interest)
fn check_dependency_context(&self, node: &FileNode) -> Option<InterestFactor> {
let path_str = node.path.to_string_lossy();
// Check for common dependency directories
let dep_indicators = [
("node_modules", DependencyManager::Npm),
("target/debug", DependencyManager::Cargo),
("target/release", DependencyManager::Cargo),
(".venv", DependencyManager::Python),
("venv", DependencyManager::Python),
("__pycache__", DependencyManager::Python),
("vendor", DependencyManager::Go), // Could also be Ruby/PHP
(".m2", DependencyManager::Java),
("build/classes", DependencyManager::Java),
];
for (indicator, _manager) in &dep_indicators {
if path_str.contains(indicator) {
// Calculate depth inside dependency tree
let depth = path_str
.split(indicator)
.nth(1)
.map(|s| s.matches('/').count())
.unwrap_or(0);
return Some(InterestFactor::InDependencyTree {
depth,
weight: self.weights.dependency_depth_penalty * (depth as f32 + 1.0),
});
}
}
None
}
/// Check filesystem type (virtual filesystems are less interesting)
fn check_filesystem_type(&self, node: &FileNode) -> Option<InterestFactor> {
match node.filesystem_type {
FilesystemType::Procfs | FilesystemType::Sysfs | FilesystemType::Devfs => {
Some(InterestFactor::InDependencyTree {
depth: 0,
weight: -0.5, // Strong negative for virtual filesystems
})
}
FilesystemType::Tmpfs => Some(InterestFactor::InDependencyTree {
depth: 0,
weight: -0.2, // Mild negative for temp filesystems
}),
_ => None,
}
}
/// Boost interest based on file category
fn check_category_boost(&self, node: &FileNode) -> Option<InterestFactor> {
if node.is_dir {
return None;
}
// Source code files are generally more interesting
let boost: f32 = match node.category {
FileCategory::Rust
| FileCategory::Python
| FileCategory::JavaScript
| FileCategory::TypeScript
| FileCategory::Go
| FileCategory::Java
| FileCategory::Cpp
| FileCategory::C => 0.1,
// Config and build files
FileCategory::Toml
| FileCategory::Yaml
| FileCategory::Json
| FileCategory::Makefile
| FileCategory::Dockerfile => 0.15,
// Documentation
FileCategory::Markdown | FileCategory::Readme => 0.1,
// Tests are interesting
FileCategory::Test => 0.1,
// Archives and binaries less interesting
FileCategory::Archive | FileCategory::Binary | FileCategory::DiskImage => -0.1,
// Temp and backup files not interesting
FileCategory::Temp | FileCategory::Backup => -0.2,
_ => 0.0,
};
if boost.abs() > 0.01 {
Some(InterestFactor::Custom {
name: format!("Category: {:?}", node.category),
weight: boost,
})
} else {
None
}
}
/// Build traversal context for a node
pub fn build_traversal_context(
&self,
node: &FileNode,
parent_interest: Option<InterestLevel>,
) -> TraversalContext {
let path_str = node.path.to_string_lossy();
// Determine traversal path type
let traversal_path = if node.is_symlink {
TraversalPath::Symlink {
target: std::fs::read_link(&node.path).unwrap_or_default(),
target_exists: node.path.exists(),
}
} else if let Some((indicator, manager)) = self.find_dependency_indicator(&path_str) {
TraversalPath::Dependency {
manager,
dep_root: node
.path
.to_string_lossy()
.split(indicator)
.next()
.map(|s| std::path::PathBuf::from(format!("{}{}", s, indicator)))
.unwrap_or_default(),
}
} else {
TraversalPath::Direct
};
// Check for git worktree
let in_git_worktree = node.path.join(".git").exists()
|| node
.path
.ancestors()
.any(|p| p.join(".git").exists());
// Check for submodule
let in_submodule = node
.path
.ancestors()
.any(|p| p.join(".git").is_file()); // Submodules have .git as file
TraversalContext {
path: traversal_path,
depth_from_root: node.depth,
in_git_worktree,
in_submodule,
parent_interest,
}
}
/// Find dependency indicator in path
fn find_dependency_indicator(&self, path: &str) -> Option<(&'static str, DependencyManager)> {
let indicators = [
("node_modules", DependencyManager::Npm),
("target/debug", DependencyManager::Cargo),
("target/release", DependencyManager::Cargo),
(".venv", DependencyManager::Python),
("venv", DependencyManager::Python),
("vendor", DependencyManager::Go),
(".m2", DependencyManager::Java),
];
for (indicator, manager) in indicators {
if path.contains(indicator) {
return Some((indicator, manager));
}
}
None
}
}
impl Default for InterestCalculator {
fn default() -> Self {
Self::new()
}
}
/// Quick helper to determine if a path is likely interesting
pub fn quick_interest_check(path: &Path) -> InterestLevel {
let path_str = path.to_string_lossy();
// Critical paths
if path_str.contains(".env") && !path_str.contains(".env.example") {
return InterestLevel::Critical;
}
// Boring paths
let boring_patterns = [
"node_modules",
"target/debug",
"target/release",
"__pycache__",
".git/objects",
".venv",
"venv/lib",
];
for pattern in boring_patterns {
if path_str.contains(pattern) {
return InterestLevel::Boring;
}
}
// Key files
if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
let name_lower = name.to_lowercase();
if matches!(
name_lower.as_str(),
"readme.md"
| "cargo.toml"
| "package.json"
| "main.rs"
| "lib.rs"
| "index.js"
| "index.ts"
) {
return InterestLevel::Important;
}
}
InterestLevel::Background
}
#[cfg(test)]
mod tests {
use super::*;
use crate::scanner::{FileCategory, FileType, FilesystemType};
use std::path::PathBuf;
use std::time::Duration;
fn make_test_node(path: &str, is_dir: bool, hours_old: f32) -> FileNode {
let modified = SystemTime::now() - Duration::from_secs_f32(hours_old * 3600.0);
FileNode {
path: PathBuf::from(path),
is_dir,
size: 1000,
permissions: 0o644,
uid: 1000,
gid: 1000,
modified,
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_recency_scoring() {
let calc = InterestCalculator::new();
// Very recent file
let recent = make_test_node("src/main.rs", false, 0.5);
let score = calc.calculate(&recent);
assert!(score.score > 0.3, "Recent file should have high score");
// Old file
let old = make_test_node("src/old.rs", false, 200.0);
let score = calc.calculate(&old);
assert!(score.score < 0.2, "Old file should have low score");
}
#[test]
fn test_key_file_detection() {
let calc = InterestCalculator::new();
let readme = make_test_node("README.md", false, 100.0);
let score = calc.calculate(&readme);
assert!(
score.score >= 0.4,
"README should be important: {}",
score.score
);
let cargo = make_test_node("Cargo.toml", false, 100.0);
let score = calc.calculate(&cargo);
assert!(
score.score >= 0.4,
"Cargo.toml should be important: {}",
score.score
);
}
#[test]
fn test_dependency_penalty() {
let calc = InterestCalculator::new();
// File in node_modules (use old file to avoid recency boost)
let node_mod = make_test_node("node_modules/lodash/index.js", false, 200.0);
let score = calc.calculate(&node_mod);
// Category boost (+0.1) minus dependency penalty (-0.1*depth) can be positive
// Key assertion: it should be lower than files outside node_modules
assert!(
score.score < 0.3,
"node_modules file should have reduced interest: {}",
score.score
);
// Same file outside node_modules (also old)
let normal = make_test_node("src/utils/index.js", false, 200.0);
let score = calc.calculate(&normal);
// The normal file should score higher than node_modules file
let node_mod_score = calc.calculate(&make_test_node("node_modules/lodash/index.js", false, 200.0)).score;
assert!(
score.score > node_mod_score,
"Normal source file ({}) should have higher interest than node_modules ({})",
score.score,
node_mod_score
);
}
#[test]
fn test_quick_interest_check() {
assert_eq!(
quick_interest_check(Path::new(".env")),
InterestLevel::Critical
);
assert_eq!(
quick_interest_check(Path::new("node_modules/foo/bar.js")),
InterestLevel::Boring
);
assert_eq!(
quick_interest_check(Path::new("README.md")),
InterestLevel::Important
);
assert_eq!(
quick_interest_check(Path::new("src/utils.rs")),
InterestLevel::Background
);
}
}
