@lamentis/naome 1.2.0 → 1.3.0

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

@@ -1,9 +1,14 @@
+mod adapter_support;
 mod adapters;
 mod baseline;
+mod cache;
 mod checks;
 mod cleanup;
 mod config;
+mod config_support;
 mod scanner;
+mod semantic;
+mod structure;
 mod types;
 
 use std::path::Path;
@@ -11,15 +16,30 @@ use std::path::Path;
 use crate::models::NaomeError;
 
 pub use cleanup::{cleanup_plan_from_violations, cleanup_route_for_path};
+pub use cache::{clear_quality_cache, quality_cache_status, QualityCacheStatus};
+pub use semantic::{semantic_route_for_finding, SemanticFinding, SemanticReport};
+pub use structure::{
+    explain_repository_structure, RepositoryStructureConfig, StructurePathExplanation,
+};
 pub use types::{
-    QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask, QualityInitResult, QualityMode,
-    QualityReport, QualitySummary, QualityViolation, RepositoryQualityConfig,
+    QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask, QualityInitMode,
+    QualityInitResult, QualityMode, QualityReport, QualitySummary, QualityViolation,
+    RepositoryQualityConfig,
 };
 
-use self::baseline::{baseline_relative_path, read_baseline_fingerprints, write_baseline};
+use self::baseline::{
+    baseline_relative_path, read_baseline_fingerprints, write_baseline,
+    write_empty_baseline_if_missing,
+};
 use self::checks::run_quality_checks;
 use self::config::{config_relative_path, read_config, write_default_config_if_missing};
+use self::scanner::collect_repo_paths;
 use self::scanner::scan_repository;
+use self::semantic::run_semantic_checks;
+use self::structure::{
+    run_repository_structure_checks, structure_config_relative_path,
+    write_default_structure_config_if_missing,
+};
 
 pub fn check_repository_quality(
     root: &Path,
@@ -29,6 +49,7 @@ pub fn check_repository_quality(
     let context = scan_repository(root, mode, config)?;
     let baseline = read_baseline_fingerprints(root)?;
     let mut violations = run_quality_checks(&context);
+    violations.extend(run_repository_structure_checks(root, &context, &baseline)?);
     for violation in &mut violations {
         violation.baseline = baseline.contains(&violation.fingerprint);
     }
@@ -38,6 +59,10 @@ pub fn check_repository_quality(
         .filter(|violation| violation.baseline)
         .count();
     let ok = blocking_violation_count == 0;
+    let mut reason_codes = context.reason_codes.clone();
+    if mode == QualityMode::Report {
+        reason_codes.push("deep_checks_skipped".to_string());
+    }
 
     Ok(QualityReport {
         schema: "naome.repository-quality-report.v1".to_string(),
@@ -47,25 +72,60 @@ pub fn check_repository_quality(
         scanned_paths: context.scanned_paths(),
         summary: QualitySummary {
             scanned_files: context.files.len(),
+            scanned_path_count: context.scanned_paths().len(),
             violation_count: violations.len(),
             baseline_violation_count,
             blocking_violation_count,
+            truncated: context.truncated,
+            reason_codes,
+            cache_hits: context.cache_hits,
+            cache_misses: context.cache_misses,
         },
         violations,
     })
 }
 
 pub fn init_repository_quality(root: &Path) -> Result<QualityInitResult, NaomeError> {
+    init_repository_quality_with_mode(root, QualityInitMode::SeedOnly)
+}
+
+pub fn init_repository_quality_with_mode(
+    root: &Path,
+    mode: QualityInitMode,
+) -> Result<QualityInitResult, NaomeError> {
     let config_written = write_default_config_if_missing(root)?;
-    let report = check_repository_quality(root, QualityMode::Report)?;
-    let baseline_written = write_baseline(root, &report.violations)?;
+    let structure_config_written = {
+        let repo_paths = collect_repo_paths(root)?;
+        write_default_structure_config_if_missing(root, &repo_paths)?
+    };
+    let (baseline_written, baseline_violations, baseline_pending) = match mode {
+        QualityInitMode::SeedOnly => {
+            write_empty_baseline_if_missing(root)?;
+            (false, 0, true)
+        }
+        QualityInitMode::Baseline | QualityInitMode::DeepBaseline => {
+            let report = check_repository_quality(
+                root,
+                if mode == QualityInitMode::DeepBaseline {
+                    QualityMode::DeepReport
+                } else {
+                    QualityMode::Report
+                },
+            )?;
+            (write_baseline(root, &report.violations)?, report.violations.len(), false)
+        }
+    };
 
     Ok(QualityInitResult {
         schema: "naome.repository-quality-init.v1".to_string(),
+        mode: mode.as_str().to_string(),
         config_written,
+        structure_config_written,
         baseline_written,
-        baseline_violations: report.violations.len(),
+        baseline_pending,
+        baseline_violations,
         config_path: config_relative_path().to_string(),
+        structure_config_path: structure_config_relative_path().to_string(),
         baseline_path: baseline_relative_path().to_string(),
     })
 }
@@ -88,3 +148,9 @@ pub fn route_quality_cleanup(
         .collect::<Vec<_>>();
     Ok(cleanup_route_for_path(&path, violations))
 }
+
+pub fn check_semantic_legacy(root: &Path, mode: QualityMode) -> Result<SemanticReport, NaomeError> {
+    let config = read_config(root)?;
+    let context = scan_repository(root, mode, config)?;
+    Ok(run_semantic_checks(&context))
+}

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

@@ -0,0 +1,78 @@
+pub(super) 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;
+    }
+
+    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;
+            }
+            continue;
+        }
+        if character == '"' || character == '\'' || character == '`' {
+            in_string = true;
+            quote = character;
+            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;
+        }
+    }
+    let value = normalized.trim().to_string();
+    (!value.is_empty()).then_some(value)
+}
+
+pub(super) 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 is_comment_only(trimmed: &str) -> bool {
+    trimmed.starts_with("//")
+        || trimmed.starts_with('#')
+        || trimmed.starts_with("/*")
+        || trimmed.starts_with('*')
+        || trimmed.starts_with("--")
+}
+
+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 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('\''))
+}

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

@@ -0,0 +1,160 @@
+mod normalize;
+
+use std::collections::{HashMap, HashSet};
+use std::fs;
+use std::path::Path;
+
+use super::{FileAnalysis, NormalizedLine, SymbolAnalysis};
+use crate::quality::cache::{content_hash, QualityCache};
+use normalize::{normalize_line, token_set};
+
+pub(super) fn analyze_repo_file(
+    root: &Path,
+    path: &str,
+    added_lines: &HashMap<String, usize>,
+    blob_hashes: &HashMap<String, String>,
+    cache: &QualityCache,
+    allow_cache: bool,
+) -> Option<(FileAnalysis, bool)> {
+    let full_path = root.join(path);
+    if !full_path.is_file() || is_binary_extension(path) {
+        return None;
+    }
+    if allow_cache {
+        if let Some(blob_hash) = blob_hashes.get(path) {
+            if let Some(cached) = cache.read(path, blob_hash) {
+                return Some((cached, true));
+            }
+        }
+    }
+    let content = fs::read_to_string(&full_path).ok()?;
+    let file = analyze_file(
+        path,
+        &content,
+        added_lines.get(path).copied().unwrap_or(0),
+    );
+    let hash = if allow_cache {
+        blob_hashes
+            .get(path)
+            .cloned()
+            .unwrap_or_else(|| content_hash(&content))
+    } else {
+        content_hash(&content)
+    };
+    let _ = cache.write(path, &hash, &file);
+    Some((file, false))
+}
+
+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,
+        raw_lines: lines.iter().map(|line| (*line).to_string()).collect(),
+        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));
+        }
+    }
+
+    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,
+        });
+    }
+    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)));
+        }
+    }
+    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)));
+            }
+        }
+    }
+    None
+}
+
+fn symbol_name(rest: &str) -> String {
+    rest.chars()
+        .take_while(|character| character.is_ascii_alphanumeric() || *character == '_')
+        .collect::<String>()
+        .trim_matches('_')
+        .to_string()
+}
+
+fn indentation(line: &str) -> usize {
+    line.chars()
+        .take_while(|character| character.is_whitespace())
+        .map(|character| if character == '\t' { 2 } else { 1 })
+        .sum()
+}
+
+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))
+}

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

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::Path;
 use std::process::Command;
@@ -36,7 +36,10 @@ pub(crate) fn collect_repo_paths(root: &Path) -> Result<Vec<String>, NaomeError>
     Ok(paths)
 }
 
-pub(super) fn added_lines_by_path(root: &Path) -> Result<HashMap<String, usize>, NaomeError> {
+pub(super) fn added_lines_by_path(
+    root: &Path,
+    target_paths: &HashSet<String>,
+) -> Result<HashMap<String, usize>, NaomeError> {
     let mut added = HashMap::new();
     for args in [
         vec!["diff", "--numstat"],
@@ -53,13 +56,20 @@ pub(super) fn added_lines_by_path(root: &Path) -> Result<HashMap<String, usize>,
             };
             let _deletions = parts.next();
             let Some(path) = parts.next() else { continue };
+            let path = path.replace('\\', "/");
+            if !target_paths.contains(&path) {
+                continue;
+            }
             let Ok(count) = additions.parse::<usize>() else {
                 continue;
             };
-            *added.entry(path.replace('\\', "/")).or_insert(0) += count;
+            *added.entry(path).or_insert(0) += count;
         }
     }
     for path in untracked_paths(root)? {
+        if !target_paths.contains(&path) {
+            continue;
+        }
         if let Ok(content) = fs::read_to_string(root.join(&path)) {
             added.insert(path, content.lines().count());
         }
@@ -67,6 +77,32 @@ pub(super) fn added_lines_by_path(root: &Path) -> Result<HashMap<String, usize>,
     Ok(added)
 }
 
+pub(super) fn tracked_blob_hashes(root: &Path) -> Result<HashMap<String, String>, NaomeError> {
+    let output = Command::new("git")
+        .args(["ls-files", "-s", "-z"])
+        .current_dir(root)
+        .output()?;
+    if !output.status.success() {
+        return Ok(HashMap::new());
+    }
+
+    let mut hashes = HashMap::new();
+    for entry in output.stdout.split(|byte| *byte == 0) {
+        if entry.is_empty() {
+            continue;
+        }
+        let entry = String::from_utf8_lossy(entry);
+        let Some((metadata, path)) = entry.split_once('\t') else {
+            continue;
+        };
+        let mut parts = metadata.split_whitespace();
+        let _mode = parts.next();
+        let Some(hash) = parts.next() else { continue };
+        hashes.insert(path.replace('\\', "/"), hash.to_string());
+    }
+    Ok(hashes)
+}
+
 fn collect_files_recursive(
     root: &Path,
     dir: &Path,