@lamentis/naome 1.2.1 → 1.3.0

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,
@@ -85,36 +98,41 @@ pub fn scan_repository(
     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 => changed_paths.clone(),
+        QualityMode::Report | QualityMode::DeepReport => whole_repo_paths.clone(),
     };
-    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);
-            }
-        }
-    }
+    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 = analyze_comparison_paths(
+        root,
+        mode,
+        &whole_repo_paths,
+        &target_paths,
+        &comparison_added_lines,
+        &blob_hashes,
+        &cache,
+        &ignore_patterns,
+        files.len(),
+        &mut state,
+    );
 
     files.sort_by(|left, right| left.path.cmp(&right.path));
     Ok(QualityContext {
@@ -124,215 +142,145 @@ 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");
-    }
-    format!("sha256:{:x}", hasher.finalize())
-}
-
-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
+    files
 }
 
-fn symbol_name(rest: &str) -> String {
-    rest.chars()
-        .take_while(|character| character.is_ascii_alphanumeric() || *character == '_')
-        .collect::<String>()
-        .trim_matches('_')
-        .to_string()
-}
-
-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::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 => 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 +312,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)
+    }
 }

package/crates/naome-core/src/quality/semantic/checks.rs

@@ -0,0 +1,134 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use super::model::{ObjectCandidate, SemanticFinding};
+use super::route::{cleanup_route, finding_mode};
+use crate::quality::scanner::{stable_fingerprint, QualityContext};
+
+pub(super) fn copied_config_findings(
+    context: &QualityContext,
+    candidates: &[ObjectCandidate],
+) -> Vec<SemanticFinding> {
+    let mut by_shape: BTreeMap<&str, Vec<&ObjectCandidate>> = BTreeMap::new();
+    for candidate in candidates
+        .iter()
+        .filter(|candidate| candidate.keys.len() >= 4 && candidate.line_count >= 8)
+        .filter(|candidate| has_config_shape_signal(&candidate.keys))
+    {
+        by_shape
+            .entry(candidate.shape_hash.as_str())
+            .or_default()
+            .push(candidate);
+    }
+
+    by_shape
+        .into_values()
+        .filter(|group| group.len() >= 2)
+        .filter(|group| group_applies_to_mode(context, group))
+        .map(|group| {
+            let occurrences = group
+                .iter()
+                .map(|candidate| candidate.occurrence())
+                .collect::<Vec<_>>();
+            let primary = &occurrences[0];
+            let id = stable_fingerprint(&[
+                "semantic",
+                "copied-config-object",
+                &primary.shape_hash,
+                &primary.path,
+            ]);
+            SemanticFinding {
+                id,
+                kind: "copied-config-object".to_string(),
+                confidence: 0.92,
+                severity: "medium".to_string(),
+                mode: finding_mode(context).to_string(),
+                summary: format!(
+                    "Same config-like object shape appears in {} locations.",
+                    occurrences.len()
+                ),
+                cleanup_route: cleanup_route(
+                    "Extract shared fixture builder",
+                    &occurrences,
+                    "Create a shared fixture or builder for the repeated object shape.",
+                ),
+                occurrences,
+            }
+        })
+        .collect()
+}
+
+pub(super) fn inline_legacy_fixture_findings(
+    context: &QualityContext,
+    candidates: &[ObjectCandidate],
+) -> Vec<SemanticFinding> {
+    candidates
+        .iter()
+        .filter(|candidate| context.applies_to(&candidate.path))
+        .filter(|candidate| candidate.in_test_context)
+        .filter(|candidate| !is_shared_fixture_factory(candidate))
+        .filter(|candidate| candidate.line_count >= 8)
+        .filter(|candidate| has_legacy_fixture_signal(&candidate.keys))
+        .map(|candidate| {
+            let occurrence = candidate.occurrence();
+            let id = stable_fingerprint(&[
+                "semantic",
+                "inline-legacy-fixture",
+                &occurrence.shape_hash,
+                &occurrence.path,
+                &occurrence.start_line.to_string(),
+            ]);
+            SemanticFinding {
+                id,
+                kind: "inline-legacy-fixture".to_string(),
+                confidence: 0.86,
+                severity: "medium".to_string(),
+                mode: finding_mode(context).to_string(),
+                summary: "Large schema/version fixture is inline in a test or support context."
+                    .to_string(),
+                cleanup_route: cleanup_route(
+                    "Extract compatibility fixture",
+                    std::slice::from_ref(&occurrence),
+                    "Move the inline legacy fixture into a shared test fixture factory and keep version-specific differences explicit.",
+                ),
+                occurrences: vec![occurrence],
+            }
+        })
+        .collect()
+}
+
+fn has_config_shape_signal(keys: &BTreeSet<String>) -> bool {
+    keys.contains("schema")
+        || keys.contains("version")
+        || keys.contains("status")
+        || keys.contains("enabledadapters")
+        || keys.contains("disabledchecks")
+        || keys.contains("limits")
+}
+
+fn has_legacy_fixture_signal(keys: &BTreeSet<String>) -> bool {
+    (keys.contains("schema") && keys.contains("version"))
+        || (keys.contains("version") && keys.contains("status"))
+        || (keys.contains("fromversion") && keys.contains("toversion"))
+}
+
+fn is_shared_fixture_factory(candidate: &ObjectCandidate) -> bool {
+    let Some(symbol) = &candidate.symbol else {
+        return false;
+    };
+    let normalized = symbol.to_ascii_lowercase();
+    [
+        "builder", "contract", "factory", "fixture", "make", "template",
+    ]
+    .iter()
+    .any(|marker| normalized.contains(marker))
+}
+
+fn group_applies_to_mode(context: &QualityContext, group: &[&ObjectCandidate]) -> bool {
+    if context.mode.is_deep() {
+        return true;
+    }
+    context.mode.is_changed()
+        && group
+            .iter()
+            .any(|candidate| context.applies_to(&candidate.path))
+}