@lamentis/naome 1.1.2 → 1.2.1

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

@@ -0,0 +1,379 @@
+mod repo_paths;
+
+use std::collections::{HashMap, HashSet};
+use std::fs;
+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 super::types::{
+    default_generated_paths, default_ignored_paths, QualityLimits, QualityMode,
+    RepositoryQualityConfig,
+};
+
+#[derive(Debug, Clone)]
+pub struct QualityContext {
+    pub mode: QualityMode,
+    pub config: RepositoryQualityConfig,
+    pub changed_paths: Vec<String>,
+    pub repo_paths: Vec<String>,
+    pub target_paths: HashSet<String>,
+    pub files: Vec<FileAnalysis>,
+}
+
+impl QualityContext {
+    pub fn scanned_paths(&self) -> Vec<String> {
+        self.files.iter().map(|file| file.path.clone()).collect()
+    }
+
+    pub fn applies_to(&self, path: &str) -> bool {
+        self.mode == QualityMode::Report || self.target_paths.contains(path)
+    }
+
+    pub fn check_applies_to(&self, check_id: &str, path: &str) -> bool {
+        self.applies_to(path) && self.config.check_enabled_for_path(check_id, path)
+    }
+
+    pub fn limits_for(&self, path: &str) -> QualityLimits {
+        self.config.limits_for_path(path)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FileAnalysis {
+    pub path: String,
+    pub line_count: usize,
+    pub added_lines: usize,
+    pub normalized_lines: Vec<NormalizedLine>,
+    pub symbols: Vec<SymbolAnalysis>,
+}
+
+#[derive(Debug, Clone)]
+pub struct NormalizedLine {
+    pub line_number: usize,
+    pub value: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct SymbolAnalysis {
+    pub kind: String,
+    pub name: String,
+    pub start_line: usize,
+    pub end_line: usize,
+    pub indent: usize,
+    pub tokens: HashSet<String>,
+}
+
+impl SymbolAnalysis {
+    pub fn line_count(&self) -> usize {
+        self.end_line.saturating_sub(self.start_line) + 1
+    }
+}
+
+pub fn scan_repository(
+    root: &Path,
+    mode: QualityMode,
+    config: RepositoryQualityConfig,
+) -> Result<QualityContext, NaomeError> {
+    let changed_paths = git::changed_paths(root)?;
+    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(),
+    };
+    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 {
+        mode,
+        config,
+        changed_paths,
+        repo_paths: whole_repo_paths,
+        target_paths,
+        files,
+    })
+}
+
+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),
+    ))
+}
+
+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));
+        }
+    }
+
+    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 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)
+}
+
+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('\''))
+}
+
+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 indentation(line: &str) -> usize {
+    line.chars()
+        .take_while(|character| character.is_whitespace())
+        .map(|character| if character == '\t' { 2 } else { 1 })
+        .sum()
+}
+
+fn ignore_patterns(root: &Path, config: &RepositoryQualityConfig) -> Vec<String> {
+    let mut patterns = Vec::new();
+    patterns.extend(read_naomeignore_patterns(root));
+    patterns.extend(default_ignored_paths());
+    patterns.extend(default_generated_paths());
+    patterns.extend(config.ignored_paths.clone());
+    patterns.extend(config.generated_paths.clone());
+    patterns
+}
+
+fn read_naomeignore_patterns(root: &Path) -> Vec<String> {
+    let Ok(content) = fs::read_to_string(root.join(".naomeignore")) else {
+        return Vec::new();
+    };
+    content
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty() && !line.starts_with('#') && !line.starts_with('!'))
+        .map(|pattern| {
+            let normalized = pattern.trim_start_matches("./").replace('\\', "/");
+            if normalized.ends_with('/') {
+                format!("{normalized}**")
+            } else {
+                normalized
+            }
+        })
+        .collect()
+}
+
+fn should_skip_path(path: &str, patterns: &[String]) -> bool {
+    paths::matches_any(path, patterns)
+}
+
+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/structure/adapters.rs

@@ -0,0 +1,84 @@
+use crate::models::NaomeError;
+
+use crate::quality::adapter_support::{
+    detected_ids, detects_javascript_typescript_project, detects_rust_project, extend_unique,
+    find_adapter_by_id, validate_ids, AdapterDescriptor, RepoSignals,
+};
+
+use super::model::RepositoryStructureConfig;
+
+const CONFIG_PATH: &str = ".naome/repository-structure.json";
+
+struct StructureAdapter {
+    id: &'static str,
+    detect: fn(&RepoSignals<'_>) -> bool,
+    source_roots: &'static [&'static str],
+    test_roots: &'static [&'static str],
+    module_roots: &'static [&'static str],
+    allowed_root_files: &'static [&'static str],
+}
+
+impl AdapterDescriptor for StructureAdapter {
+    fn id(&self) -> &'static str {
+        self.id
+    }
+
+    fn detects(&self, signals: &RepoSignals<'_>) -> bool {
+        (self.detect)(signals)
+    }
+}
+
+pub fn detected_structure_adapter_ids(paths: &[String]) -> Vec<String> {
+    detected_ids(paths, registry())
+}
+
+pub fn apply_structure_adapters(
+    mut config: RepositoryStructureConfig,
+) -> Result<RepositoryStructureConfig, NaomeError> {
+    validate_structure_adapter_ids(&config.enabled_adapters)?;
+    for adapter_id in config.enabled_adapters.clone() {
+        let adapter = find_adapter_by_id(registry(), &adapter_id, CONFIG_PATH)?;
+        extend_unique(&mut config.source_roots, adapter.source_roots);
+        extend_unique(&mut config.test_roots, adapter.test_roots);
+        extend_unique(&mut config.module_roots, adapter.module_roots);
+        extend_unique(&mut config.allowed_root_files, adapter.allowed_root_files);
+    }
+    Ok(config)
+}
+
+pub fn validate_structure_adapter_ids(ids: &[String]) -> Result<(), NaomeError> {
+    validate_ids(ids, registry(), CONFIG_PATH)
+}
+
+fn registry() -> &'static [StructureAdapter] {
+    &[
+        StructureAdapter {
+            id: "rust",
+            detect: detects_rust_project,
+            source_roots: &["src/**", "crates/*/src/**", "**/crates/*/src/**"],
+            test_roots: &["tests/**", "crates/*/tests/**", "**/crates/*/tests/**"],
+            module_roots: &["src/**", "crates/*/src/**", "**/crates/*/src/**"],
+            allowed_root_files: &["Cargo.toml", "Cargo.lock"],
+        },
+        StructureAdapter {
+            id: "javascript-typescript",
+            detect: detects_javascript_typescript_project,
+            source_roots: &[
+                "src/**",
+                "app/**",
+                "pages/**",
+                "components/**",
+                "packages/*/src/**",
+                "**/packages/*/src/**",
+            ],
+            test_roots: &["test/**", "tests/**", "__tests__/**", "packages/*/tests/**"],
+            module_roots: &["src/**", "app/**", "packages/*/src/**"],
+            allowed_root_files: &[
+                "package.json",
+                "tsconfig.json",
+                "vite.config.ts",
+                "next.config.js",
+            ],
+        },
+    ]
+}

package/crates/naome-core/src/quality/structure/checks/basic.rs

@@ -0,0 +1,153 @@
+use crate::paths;
+use crate::quality::types::{QualityMode, QualityViolation};
+
+use super::{applies, push};
+use crate::quality::structure::model::{DirectoryRoleRule, RepositoryStructureModel};
+
+pub(super) fn root_file_sprawl(
+    model: &RepositoryStructureModel,
+    mode: QualityMode,
+    violations: &mut Vec<QualityViolation>,
+) {
+    for path in model
+        .paths
+        .iter()
+        .filter(|path| applies(path, mode) && path.segments.len() == 1)
+    {
+        if paths::matches_any(&path.explanation.path, &model.config.allowed_root_files) {
+            continue;
+        }
+        push_single_path(
+            "root-file-sprawl",
+            &path.explanation.path,
+            format!(
+                "{} is a root-level file without a recognized root role; place new work inside a module, docs, config, or script directory.",
+                path.explanation.path
+            ),
+            violations,
+        );
+    }
+}
+
+pub(super) fn misplaced_files(
+    model: &RepositoryStructureModel,
+    mode: QualityMode,
+    violations: &mut Vec<QualityViolation>,
+) {
+    for path in model.paths.iter().filter(|path| applies(path, mode)) {
+        let role = path.explanation.role.as_str();
+        let misplaced_test =
+            role == "test" && !paths::matches_any(&path.explanation.path, &model.config.test_roots);
+        if misplaced_test {
+            push_single_path(
+                "misplaced-file-role",
+                &path.explanation.path,
+                format!(
+                    "{} is test code outside a configured test root.",
+                    path.explanation.path
+                ),
+                violations,
+            );
+        }
+    }
+}
+
+pub(super) fn directory_role_mixing(
+    model: &RepositoryStructureModel,
+    mode: QualityMode,
+    violations: &mut Vec<QualityViolation>,
+) {
+    for path in model.paths.iter().filter(|path| {
+        applies(path, mode)
+            && matches!(path.explanation.role.as_str(), "generated" | "artifact")
+            && paths::matches_any(&path.explanation.path, &model.config.source_roots)
+    }) {
+        if role_rule_allows_path(model, &path.explanation.path, &path.explanation.role) {
+            continue;
+        }
+        push_single_path(
+            "directory-role-mixing",
+            &path.explanation.path,
+            format!(
+                "{} is {} content under a source root.",
+                path.explanation.path, path.explanation.role
+            ),
+            violations,
+        );
+    }
+
+    for directory in &model.directories {
+        let rule = directory_role_rule_for(model, &directory.path);
+        let allowed_by_rule = rule
+            .filter(|rule| !rule.allowed_roles.is_empty())
+            .is_some_and(|rule| {
+                directory
+                    .roles
+                    .iter()
+                    .all(|role| rule.allowed_roles.iter().any(|allowed| allowed == role))
+            });
+        let max_roles = rule
+            .and_then(|rule| rule.max_roles)
+            .unwrap_or(model.config.limits.max_directory_roles);
+        let incompatible = directory.roles.contains("source")
+            && (directory.roles.contains("generated")
+                || directory.roles.contains("artifact")
+                || directory.roles.contains("dependency/vendor"));
+        let too_many_roles = directory.roles.len() > max_roles
+            && (directory.roles.contains("source")
+                || directory.roles.contains("generated")
+                || directory.roles.contains("artifact"));
+        if (!incompatible || allowed_by_rule) && !too_many_roles {
+            continue;
+        }
+        for path in model.paths.iter().filter(|path| {
+            path.explanation.directory == directory.path
+                && applies(path, mode)
+                && path.explanation.role != "source"
+        }) {
+            push(
+                "directory-role-mixing",
+                &path.explanation.path,
+                format!(
+                    "{} mixes incompatible directory roles: {}.",
+                    directory.path,
+                    directory
+                        .roles
+                        .iter()
+                        .cloned()
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                ),
+                vec![],
+                violations,
+            );
+        }
+    }
+}
+
+fn role_rule_allows_path(model: &RepositoryStructureModel, path: &str, role: &str) -> bool {
+    model.config.directory_role_rules.iter().any(|rule| {
+        !rule.allowed_roles.is_empty()
+            && paths::matches_any(path, &rule.paths)
+            && rule.allowed_roles.iter().any(|allowed| allowed == role)
+    })
+}
+
+fn directory_role_rule_for<'a>(
+    model: &'a RepositoryStructureModel,
+    directory: &str,
+) -> Option<&'a DirectoryRoleRule> {
+    model.config.directory_role_rules.iter().find(|rule| {
+        paths::matches_any(directory, &rule.paths)
+            || paths::matches_any(&format!("{directory}/_"), &rule.paths)
+    })
+}
+
+fn push_single_path(
+    check_id: &str,
+    path: &str,
+    message: String,
+    violations: &mut Vec<QualityViolation>,
+) {
+    push(check_id, path, message, vec![], violations);
+}