@lamentis/naome 1.2.1 → 1.3.1

package/crates/naome-core/src/quality/scanner.rs

@@ -1,3 +1,4 @@
+mod analysis;
 mod repo_paths;
 
 use std::collections::{HashMap, HashSet};
@@ -7,13 +8,15 @@ use std::path::Path;
 use sha2::{Digest, Sha256};
 
 use crate::{git, models::NaomeError, paths};
-use repo_paths::added_lines_by_path;
 pub(crate) use repo_paths::collect_repo_paths;
+use repo_paths::{added_lines_by_path, tracked_blob_hashes};
 
+use super::cache::QualityCache;
 use super::types::{
     default_generated_paths, default_ignored_paths, QualityLimits, QualityMode,
     RepositoryQualityConfig,
 };
+use analysis::analyze_repo_file;
 
 #[derive(Debug, Clone)]
 pub struct QualityContext {
@@ -23,6 +26,11 @@ pub struct QualityContext {
     pub repo_paths: Vec<String>,
     pub target_paths: HashSet<String>,
     pub files: Vec<FileAnalysis>,
+    pub comparison_files: Vec<FileAnalysis>,
+    pub truncated: bool,
+    pub reason_codes: Vec<String>,
+    pub cache_hits: usize,
+    pub cache_misses: usize,
 }
 
 impl QualityContext {
@@ -30,8 +38,12 @@ impl QualityContext {
         self.files.iter().map(|file| file.path.clone()).collect()
     }
 
+    pub fn comparison_candidate_files(&self) -> impl Iterator<Item = &FileAnalysis> {
+        self.files.iter().chain(self.comparison_files.iter())
+    }
+
     pub fn applies_to(&self, path: &str) -> bool {
-        self.mode == QualityMode::Report || self.target_paths.contains(path)
+        !self.mode.is_changed() || self.target_paths.contains(path)
     }
 
     pub fn check_applies_to(&self, check_id: &str, path: &str) -> bool {
@@ -43,22 +55,23 @@ impl QualityContext {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct FileAnalysis {
     pub path: String,
     pub line_count: usize,
     pub added_lines: usize,
+    pub raw_lines: Vec<String>,
     pub normalized_lines: Vec<NormalizedLine>,
     pub symbols: Vec<SymbolAnalysis>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NormalizedLine {
     pub line_number: usize,
     pub value: String,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SymbolAnalysis {
     pub kind: String,
     pub name: String,
@@ -80,41 +93,74 @@ pub fn scan_repository(
     config: RepositoryQualityConfig,
 ) -> Result<QualityContext, NaomeError> {
     let changed_paths = git::changed_paths(root)?;
+    scan_repository_with_targets(root, mode, config, changed_paths, true)
+}
+
+pub fn scan_repository_paths(
+    root: &Path,
+    config: RepositoryQualityConfig,
+    paths: &[String],
+) -> Result<QualityContext, NaomeError> {
+    let mut target_paths = paths
+        .iter()
+        .map(|path| normalize_target_path(path))
+        .collect::<Result<Vec<_>, _>>()?;
+    target_paths.sort();
+    target_paths.dedup();
+    scan_repository_with_targets(root, QualityMode::PathScoped, config, target_paths, false)
+}
+
+fn scan_repository_with_targets(
+    root: &Path,
+    mode: QualityMode,
+    config: RepositoryQualityConfig,
+    changed_paths: Vec<String>,
+    include_comparison_files: bool,
+) -> Result<QualityContext, NaomeError> {
     let target_paths = changed_paths.iter().cloned().collect::<HashSet<_>>();
     let mut whole_repo_paths = collect_repo_paths(root)?;
     whole_repo_paths.sort();
     whole_repo_paths.dedup();
     let scan_paths = match mode {
-        QualityMode::Changed => changed_paths.clone(),
-        QualityMode::Report => whole_repo_paths.clone(),
+        QualityMode::ChangedFast | QualityMode::PathScoped => changed_paths.clone(),
+        QualityMode::Report | QualityMode::DeepReport => whole_repo_paths.clone(),
+    };
+    let added_lines = if mode.is_changed() {
+        added_lines_by_path(root, &target_paths)?
+    } else {
+        HashMap::new()
+    };
+    let comparison_added_lines = HashMap::new();
+    let blob_hashes = tracked_blob_hashes(root).unwrap_or_default();
+    let cache = QualityCache::new(root, &config);
+    let ignore_patterns = CompiledPatternSet::new(ignore_patterns(root, &config));
+    let mut state = ScanState::default();
+    let mut files = analyze_primary_paths(
+        root,
+        mode,
+        &scan_paths,
+        &added_lines,
+        &blob_hashes,
+        &cache,
+        &ignore_patterns,
+        &mut state,
+    );
+    let comparison_files = if include_comparison_files {
+        analyze_comparison_paths(
+            root,
+            mode,
+            &whole_repo_paths,
+            &target_paths,
+            &comparison_added_lines,
+            &blob_hashes,
+            &cache,
+            &ignore_patterns,
+            files.len(),
+            &mut state,
+        )
+    } else {
+        Vec::new()
     };
-    let added_lines = added_lines_by_path(root)?;
-    let ignore_patterns = ignore_patterns(root, &config);
-    let mut files = Vec::new();
-
-    for path in scan_paths {
-        if should_skip_path(&path, &ignore_patterns) {
-            continue;
-        }
-        if let Some(file) = analyze_repo_file(root, &path, &added_lines) {
-            files.push(file);
-        }
-    }
-
-    if mode == QualityMode::Changed {
-        let scanned = files
-            .iter()
-            .map(|file| file.path.clone())
-            .collect::<HashSet<_>>();
-        for path in &whole_repo_paths {
-            if scanned.contains(path) || should_skip_path(path, &ignore_patterns) {
-                continue;
-            }
-            if let Some(file) = analyze_repo_file(root, path, &added_lines) {
-                files.push(file);
-            }
-        }
-    }
 
     files.sort_by(|left, right| left.path.cmp(&right.path));
     Ok(QualityContext {
@@ -124,215 +170,162 @@ pub fn scan_repository(
         repo_paths: whole_repo_paths,
         target_paths,
         files,
+        comparison_files,
+        truncated: state.truncated,
+        reason_codes: state.reason_codes,
+        cache_hits: state.cache_hits,
+        cache_misses: state.cache_misses,
     })
 }
 
-pub fn stable_fingerprint(parts: &[&str]) -> String {
-    let mut hasher = Sha256::new();
-    for part in parts {
-        hasher.update(part.as_bytes());
-        hasher.update(b"\0");
+fn normalize_target_path(path: &str) -> Result<String, NaomeError> {
+    let normalized = path.trim_start_matches("./").replace('\\', "/");
+    let has_parent_segment = normalized.split('/').any(|segment| segment == "..");
+    if normalized.is_empty() || normalized.starts_with('/') || has_parent_segment {
+        return Err(NaomeError::new(format!(
+            "quality path must be a repository-relative path: {path}"
+        )));
     }
-    format!("sha256:{:x}", hasher.finalize())
+    Ok(normalized)
 }
 
-fn analyze_repo_file(
-    root: &Path,
-    path: &str,
-    added_lines: &HashMap<String, usize>,
-) -> Option<FileAnalysis> {
-    let full_path = root.join(path);
-    if !full_path.is_file() || is_binary_extension(path) {
-        return None;
-    }
-    let content = fs::read_to_string(&full_path).ok()?;
-    Some(analyze_file(
-        path,
-        &content,
-        added_lines.get(path).copied().unwrap_or(0),
-    ))
+#[derive(Default)]
+struct ScanState {
+    cache_hits: usize,
+    cache_misses: usize,
+    truncated: bool,
+    reason_codes: Vec<String>,
 }
 
-fn analyze_file(path: &str, content: &str, added_lines: usize) -> FileAnalysis {
-    let lines = content.lines().collect::<Vec<_>>();
-    let normalized_lines = lines
-        .iter()
-        .enumerate()
-        .filter_map(|(index, line)| normalize_line(line).map(|value| (index + 1, value)))
-        .map(|(line_number, value)| NormalizedLine { line_number, value })
-        .collect::<Vec<_>>();
-    let symbols = detect_symbols(&lines);
-    FileAnalysis {
-        path: path.to_string(),
-        line_count: lines.len(),
-        added_lines,
-        normalized_lines,
-        symbols,
-    }
-}
-
-fn detect_symbols(lines: &[&str]) -> Vec<SymbolAnalysis> {
-    let mut starts = Vec::new();
-    for (index, line) in lines.iter().enumerate() {
-        let indent = indentation(line);
-        if let Some((kind, name)) = symbol_start(line.trim()) {
-            starts.push((index, indent, kind, name));
+impl ScanState {
+    fn record_cache_result(&mut self, cache_hit: bool) {
+        if cache_hit {
+            self.cache_hits += 1;
+        } else {
+            self.cache_misses += 1;
         }
     }
 
-    let mut symbols = Vec::new();
-    for (position, (start_index, indent, kind, name)) in starts.iter().enumerate() {
-        let end_index = starts
-            .iter()
-            .skip(position + 1)
-            .find(|(_, next_indent, _, _)| next_indent <= indent)
-            .map(|(next_index, _, _, _)| next_index.saturating_sub(1))
-            .unwrap_or_else(|| lines.len().saturating_sub(1));
-        let normalized_body = lines[*start_index..=end_index]
-            .iter()
-            .filter_map(|line| normalize_line(line))
-            .collect::<Vec<_>>();
-        let tokens = normalized_body
-            .iter()
-            .flat_map(|line| token_set(line))
-            .collect::<HashSet<_>>();
-        symbols.push(SymbolAnalysis {
-            kind: kind.clone(),
-            name: name.clone(),
-            start_line: start_index + 1,
-            end_line: end_index + 1,
-            indent: *indent,
-            tokens,
-        });
+    fn truncate(&mut self, reason: &str) {
+        self.truncated = true;
+        add_reason(&mut self.reason_codes, reason);
     }
-    symbols
 }
 
-fn symbol_start(trimmed: &str) -> Option<(String, String)> {
-    let candidates = [
-        ("function", "function "),
-        ("function", "export function "),
-        ("function", "async function "),
-        ("function", "export async function "),
-        ("function", "def "),
-        ("function", "fn "),
-        ("function", "pub fn "),
-        ("function", "func "),
-        ("class", "class "),
-        ("struct", "struct "),
-        ("struct", "pub struct "),
-        ("enum", "enum "),
-        ("enum", "pub enum "),
-        ("impl", "impl "),
-    ];
-    for (kind, prefix) in candidates {
-        if let Some(rest) = trimmed.strip_prefix(prefix) {
-            return Some((kind.to_string(), symbol_name(rest)));
+fn analyze_primary_paths(
+    root: &Path,
+    mode: QualityMode,
+    paths: &[String],
+    added_lines: &HashMap<String, usize>,
+    blob_hashes: &HashMap<String, String>,
+    cache: &QualityCache,
+    ignore_patterns: &CompiledPatternSet,
+    state: &mut ScanState,
+) -> Vec<FileAnalysis> {
+    let mut files = Vec::new();
+    for path in paths {
+        if ignore_patterns.matches(path) {
+            continue;
         }
-    }
-    for prefix in ["const ", "let ", "export const ", "export let "] {
-        if let Some(rest) = trimmed.strip_prefix(prefix) {
-            if trimmed.contains("=>") || trimmed.contains("function") || trimmed.contains("React.")
-            {
-                return Some(("function".to_string(), symbol_name(rest)));
-            }
+        if files.len() >= max_scanned_files(mode) {
+            state.truncate("max_scanned_files");
+            break;
+        }
+        if file_exceeds_budget(root, path, mode) {
+            state.truncate("max_file_bytes");
+            continue;
+        }
+        if let Some((file, cache_hit)) = analyze_repo_file(
+            root,
+            path,
+            added_lines,
+            blob_hashes,
+            cache,
+            !mode.is_changed(),
+        ) {
+            state.record_cache_result(cache_hit);
+            files.push(file);
         }
     }
-    None
-}
-
-fn symbol_name(rest: &str) -> String {
-    rest.chars()
-        .take_while(|character| character.is_ascii_alphanumeric() || *character == '_')
-        .collect::<String>()
-        .trim_matches('_')
-        .to_string()
+    files
 }
 
-fn normalize_line(line: &str) -> Option<String> {
-    let trimmed = line.trim();
-    if trimmed.is_empty()
-        || is_comment_only(trimmed)
-        || is_string_list_item(trimmed)
-        || is_generated_hash_mapping(trimmed)
-    {
-        return None;
+fn analyze_comparison_paths(
+    root: &Path,
+    mode: QualityMode,
+    paths: &[String],
+    target_paths: &HashSet<String>,
+    added_lines: &HashMap<String, usize>,
+    blob_hashes: &HashMap<String, String>,
+    cache: &QualityCache,
+    ignore_patterns: &CompiledPatternSet,
+    primary_count: usize,
+    state: &mut ScanState,
+) -> Vec<FileAnalysis> {
+    if !mode.is_changed() {
+        return Vec::new();
     }
-
-    let mut normalized = String::new();
-    let mut in_string = false;
-    let mut quote = '\0';
-    let mut previous_space = false;
-    for character in trimmed.chars() {
-        if in_string {
-            if character == quote {
-                in_string = false;
-                normalized.push('S');
-                previous_space = false;
-            }
+    let mut files = Vec::new();
+    for path in paths {
+        if target_paths.contains(path) || ignore_patterns.matches(path) {
             continue;
         }
-        if character == '"' || character == '\'' || character == '`' {
-            in_string = true;
-            quote = character;
+        if file_exceeds_budget(root, path, mode) {
+            state.truncate("max_file_bytes");
             continue;
         }
-        let next = if character.is_ascii_digit() {
-            '0'
-        } else if character.is_whitespace() {
-            ' '
-        } else {
-            character.to_ascii_lowercase()
-        };
-        if next == ' ' {
-            if !previous_space {
-                normalized.push(next);
-            }
-            previous_space = true;
-        } else {
-            normalized.push(next);
-            previous_space = false;
+        if let Some((file, cache_hit)) =
+            analyze_repo_file(root, path, added_lines, blob_hashes, cache, true)
+        {
+            state.record_cache_result(cache_hit);
+            files.push(file);
+        }
+        if primary_count.saturating_add(files.len()) >= max_scanned_files(mode) {
+            state.truncate("max_scanned_files");
+            break;
         }
     }
-    let value = normalized.trim().to_string();
-    (!value.is_empty()).then_some(value)
+    files.sort_by(|left, right| left.path.cmp(&right.path));
+    files.dedup_by(|left, right| left.path == right.path);
+    files
 }
 
-fn is_comment_only(trimmed: &str) -> bool {
-    trimmed.starts_with("//")
-        || trimmed.starts_with('#')
-        || trimmed.starts_with("/*")
-        || trimmed.starts_with('*')
-        || trimmed.starts_with("--")
+pub fn stable_fingerprint(parts: &[&str]) -> String {
+    let mut hasher = Sha256::new();
+    for part in parts {
+        hasher.update(part.as_bytes());
+        hasher.update(b"\0");
+    }
+    format!("sha256:{:x}", hasher.finalize())
 }
 
-fn is_generated_hash_mapping(trimmed: &str) -> bool {
-    let Some((key, value)) = trimmed.split_once(':') else {
-        return false;
-    };
-    key.trim_start().starts_with('"')
-        && value.trim_start().starts_with("\"sha256:")
-        && value.chars().filter(|character| *character == '"').count() >= 2
+fn max_scanned_files(mode: QualityMode) -> usize {
+    match mode {
+        QualityMode::ChangedFast => 2_000,
+        QualityMode::PathScoped => 128,
+        QualityMode::Report => 5_000,
+        QualityMode::DeepReport => usize::MAX,
+    }
 }
 
-fn is_string_list_item(trimmed: &str) -> bool {
-    let value = trimmed.trim_end_matches(',');
-    (value.starts_with('"') && value.ends_with('"'))
-        || (value.starts_with('\'') && value.ends_with('\''))
+fn max_file_bytes(mode: QualityMode) -> u64 {
+    match mode {
+        QualityMode::ChangedFast | QualityMode::PathScoped => 512 * 1024,
+        QualityMode::Report => 1024 * 1024,
+        QualityMode::DeepReport => 8 * 1024 * 1024,
+    }
 }
 
-fn token_set(line: &str) -> Vec<String> {
-    line.split(|character: char| !character.is_ascii_alphanumeric() && character != '_')
-        .filter(|token| token.len() > 1)
-        .map(ToString::to_string)
-        .collect()
+fn file_exceeds_budget(root: &Path, path: &str, mode: QualityMode) -> bool {
+    fs::metadata(root.join(path)).map_or(false, |metadata| {
+        metadata.is_file() && metadata.len() > max_file_bytes(mode)
+    })
 }
 
-fn indentation(line: &str) -> usize {
-    line.chars()
-        .take_while(|character| character.is_whitespace())
-        .map(|character| if character == '\t' { 2 } else { 1 })
-        .sum()
+fn add_reason(reason_codes: &mut Vec<String>, reason: &str) {
+    if !reason_codes.iter().any(|existing| existing == reason) {
+        reason_codes.push(reason.to_string());
+    }
 }
 
 fn ignore_patterns(root: &Path, config: &RepositoryQualityConfig) -> Vec<String> {
@@ -364,16 +357,41 @@ fn read_naomeignore_patterns(root: &Path) -> Vec<String> {
         .collect()
 }
 
-fn should_skip_path(path: &str, patterns: &[String]) -> bool {
-    paths::matches_any(path, patterns)
+struct CompiledPatternSet {
+    exact: HashSet<String>,
+    prefixes: Vec<String>,
+    wildcards: Vec<String>,
 }
 
-fn is_binary_extension(path: &str) -> bool {
-    let lower = path.to_ascii_lowercase();
-    [
-        ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz", ".tgz", ".wasm",
-        ".dylib", ".so", ".dll", ".exe", ".bin",
-    ]
-    .iter()
-    .any(|extension| lower.ends_with(extension))
+impl CompiledPatternSet {
+    fn new(patterns: Vec<String>) -> Self {
+        let mut exact = HashSet::new();
+        let mut prefixes = Vec::new();
+        let mut wildcards = Vec::new();
+        for pattern in patterns {
+            let normalized = pattern.trim_start_matches("./").replace('\\', "/");
+            if normalized.ends_with("/**") && !normalized[..normalized.len() - 3].contains('*') {
+                prefixes.push(normalized.trim_end_matches("**").to_string());
+            } else if normalized.contains('*') || normalized.contains('?') {
+                wildcards.push(normalized);
+            } else {
+                exact.insert(normalized);
+            }
+        }
+        prefixes.sort();
+        prefixes.dedup();
+        wildcards.sort();
+        wildcards.dedup();
+        Self {
+            exact,
+            prefixes,
+            wildcards,
+        }
+    }
+
+    fn matches(&self, path: &str) -> bool {
+        self.exact.contains(path)
+            || self.prefixes.iter().any(|prefix| path.starts_with(prefix))
+            || paths::matches_any(path, &self.wildcards)
+    }
 }