@lamentis/naome 1.1.2 → 1.2.1

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

@@ -0,0 +1,228 @@
+mod duplicate_blocks;
+mod near_duplicates;
+
+use std::collections::HashSet;
+
+use super::scanner::{stable_fingerprint, QualityContext};
+use super::types::{QualityMode, QualityViolation};
+use duplicate_blocks::DuplicateBlockCheck;
+use near_duplicates::NearDuplicateFunctionCheck;
+
+pub fn run_quality_checks(context: &QualityContext) -> Vec<QualityViolation> {
+    let checks = registry();
+    let disabled = context
+        .config
+        .disabled_checks
+        .iter()
+        .map(String::as_str)
+        .collect::<HashSet<_>>();
+    let mut violations = Vec::new();
+
+    for check in checks {
+        if !disabled.contains(check.id()) {
+            check.evaluate(context, &mut violations);
+        }
+    }
+
+    violations.sort_by(|left, right| {
+        left.path
+            .cmp(&right.path)
+            .then(left.check_id.cmp(&right.check_id))
+            .then(left.line.cmp(&right.line))
+            .then(left.fingerprint.cmp(&right.fingerprint))
+    });
+    violations
+}
+
+pub(super) trait QualityCheck {
+    fn id(&self) -> &'static str;
+    fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>);
+}
+
+fn registry() -> Vec<Box<dyn QualityCheck>> {
+    vec![
+        Box::new(FileLengthCheck),
+        Box::new(DiffGrowthCheck),
+        Box::new(FunctionLengthCheck),
+        Box::new(TopLevelSymbolCountCheck),
+        Box::new(DuplicateBlockCheck),
+        Box::new(NearDuplicateFunctionCheck),
+    ]
+}
+
+struct FileLengthCheck;
+
+impl QualityCheck for FileLengthCheck {
+    fn id(&self) -> &'static str {
+        "file-length"
+    }
+
+    fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>) {
+        for file in context
+            .files
+            .iter()
+            .filter(|file| context.check_applies_to(self.id(), &file.path))
+        {
+            let limits = context.limits_for(&file.path);
+            let limit =
+                if context.mode == QualityMode::Changed && file.added_lines == file.line_count {
+                    limits.max_new_file_lines
+                } else {
+                    limits.max_file_lines
+                };
+            if file.line_count > limit {
+                violations.push(violation(
+                    self.id(),
+                    &file.path,
+                    None,
+                    format!(
+                        "{} has {} lines, exceeding the configured limit of {}.",
+                        file.path, file.line_count, limit
+                    ),
+                    Some(file.line_count as f64),
+                    Some(limit as f64),
+                    Vec::new(),
+                ));
+            }
+        }
+    }
+}
+
+struct DiffGrowthCheck;
+
+impl QualityCheck for DiffGrowthCheck {
+    fn id(&self) -> &'static str {
+        "diff-growth"
+    }
+
+    fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>) {
+        if context.mode != QualityMode::Changed {
+            return;
+        }
+        for file in context
+            .files
+            .iter()
+            .filter(|file| context.check_applies_to(self.id(), &file.path))
+        {
+            let limit = context.limits_for(&file.path).max_diff_added_lines;
+            if file.added_lines > limit {
+                violations.push(violation(
+                    self.id(),
+                    &file.path,
+                    None,
+                    format!(
+                        "{} adds {} lines in this task, exceeding the configured limit of {}.",
+                        file.path, file.added_lines, limit
+                    ),
+                    Some(file.added_lines as f64),
+                    Some(limit as f64),
+                    Vec::new(),
+                ));
+            }
+        }
+    }
+}
+
+struct FunctionLengthCheck;
+
+impl QualityCheck for FunctionLengthCheck {
+    fn id(&self) -> &'static str {
+        "function-length"
+    }
+
+    fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>) {
+        for file in context.files.iter().filter(|file| {
+            context.check_applies_to(self.id(), &file.path) && is_code_like_path(&file.path)
+        }) {
+            let limit = context.limits_for(&file.path).max_function_lines;
+            for symbol in &file.symbols {
+                if symbol.line_count() > limit {
+                    violations.push(violation(
+                        self.id(),
+                        &file.path,
+                        Some(symbol.start_line),
+                        format!(
+                            "{} {} has {} lines, exceeding the configured limit of {}.",
+                            symbol.kind,
+                            symbol.name,
+                            symbol.line_count(),
+                            limit
+                        ),
+                        Some(symbol.line_count() as f64),
+                        Some(limit as f64),
+                        Vec::new(),
+                    ));
+                }
+            }
+        }
+    }
+}
+
+struct TopLevelSymbolCountCheck;
+
+impl QualityCheck for TopLevelSymbolCountCheck {
+    fn id(&self) -> &'static str {
+        "top-level-symbol-count"
+    }
+
+    fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>) {
+        for file in context.files.iter().filter(|file| {
+            context.check_applies_to(self.id(), &file.path) && is_code_like_path(&file.path)
+        }) {
+            let limit = context.limits_for(&file.path).max_top_level_symbols;
+            let count = file
+                .symbols
+                .iter()
+                .filter(|symbol| symbol.indent <= 2)
+                .count();
+            if count > limit {
+                violations.push(violation(
+                    self.id(),
+                    &file.path,
+                    None,
+                    format!(
+                        "{} defines {} top-level symbols, exceeding the configured limit of {}.",
+                        file.path, count, limit
+                    ),
+                    Some(count as f64),
+                    Some(limit as f64),
+                    Vec::new(),
+                ));
+            }
+        }
+    }
+}
+
+pub(super) fn is_code_like_path(path: &str) -> bool {
+    let lower = path.to_ascii_lowercase();
+    [
+        ".rs", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".py", ".go", ".swift", ".kt",
+        ".java", ".c", ".cc", ".cpp", ".h", ".hpp", ".rb", ".php", ".cs", ".sh", ".bash", ".zsh",
+    ]
+    .iter()
+    .any(|extension| lower.ends_with(extension))
+}
+
+pub(super) fn violation(
+    check_id: &str,
+    path: &str,
+    line: Option<usize>,
+    message: String,
+    value: Option<f64>,
+    limit: Option<f64>,
+    related_paths: Vec<String>,
+) -> QualityViolation {
+    let line_part = line.map(|value| value.to_string()).unwrap_or_default();
+    QualityViolation {
+        check_id: check_id.to_string(),
+        severity: "blocking".to_string(),
+        path: path.to_string(),
+        line,
+        message: message.clone(),
+        value,
+        limit,
+        fingerprint: stable_fingerprint(&[check_id, path, &line_part, &message]),
+        related_paths,
+        baseline: false,
+    }
+}

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

@@ -0,0 +1,84 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use super::types::{QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask, QualityViolation};
+
+pub fn cleanup_plan_from_violations(violations: &[QualityViolation]) -> QualityCleanupPlan {
+    let mut grouped: BTreeMap<String, Vec<&QualityViolation>> = BTreeMap::new();
+    for violation in violations {
+        grouped
+            .entry(violation.path.clone())
+            .or_default()
+            .push(violation);
+    }
+
+    let mut tasks = grouped
+        .into_iter()
+        .map(|(path, violations)| {
+            let check_ids = violations
+                .iter()
+                .map(|violation| violation.check_id.clone())
+                .collect::<BTreeSet<_>>()
+                .into_iter()
+                .collect::<Vec<_>>();
+            QualityCleanupTask {
+                path,
+                violation_count: violations.len(),
+                summary: format!(
+                    "Resolve {} repository-quality violation(s): {}.",
+                    violations.len(),
+                    check_ids.join(", ")
+                ),
+                check_ids,
+            }
+        })
+        .collect::<Vec<_>>();
+    tasks.sort_by(|left, right| {
+        right
+            .violation_count
+            .cmp(&left.violation_count)
+            .then(left.path.cmp(&right.path))
+    });
+
+    QualityCleanupPlan {
+        schema: "naome.quality-cleanup-plan.v1".to_string(),
+        tasks,
+    }
+}
+
+pub fn cleanup_route_for_path(
+    path: &str,
+    violations: Vec<QualityViolation>,
+) -> QualityCleanupRoute {
+    let mut related_paths = violations
+        .iter()
+        .flat_map(|violation| violation.related_paths.clone())
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .collect::<Vec<_>>();
+    related_paths.retain(|related| related != path);
+    let topic = if violations.iter().any(|violation| {
+        violation.check_id.starts_with("directory-")
+            || violation.check_id == "root-file-sprawl"
+            || violation.check_id == "dumping-ground-directory"
+            || violation.check_id == "path-depth"
+            || violation.check_id == "case-collision"
+            || violation.check_id == "test-source-pairing"
+    }) {
+        "repository structure"
+    } else {
+        "repository quality"
+    };
+    QualityCleanupRoute {
+        schema: "naome.quality-cleanup-route.v1".to_string(),
+        path: path.to_string(),
+        violations,
+        related_paths,
+        agent_instructions: format!(
+            "Reduce or split {path} until every {topic} violation is gone. Prefer named modules and reusable helpers/components over dumping logic into generic directories. Keep behavior unchanged, add or preserve focused tests, then run naome quality check --changed before task completion."
+        ),
+        required_checks: vec![
+            "naome quality check --changed".to_string(),
+            "git diff --check".to_string(),
+        ],
+    }
+}

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

@@ -0,0 +1,102 @@
+use std::fs;
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::adapters::{apply_enabled_adapters, detected_adapter_ids, validate_adapter_ids};
+use super::config_support::validate_ready_schema;
+use super::scanner::collect_repo_paths;
+use super::types::RepositoryQualityConfig;
+
+const CONFIG_RELATIVE_PATH: &str = ".naome/repository-quality.json";
+
+pub fn config_relative_path() -> &'static str {
+    CONFIG_RELATIVE_PATH
+}
+
+pub fn read_config(root: &Path) -> Result<RepositoryQualityConfig, NaomeError> {
+    let path = root.join(CONFIG_RELATIVE_PATH);
+    let config = if path.is_file() {
+        serde_json::from_str(&fs::read_to_string(path)?)?
+    } else {
+        generated_config(root)?
+    };
+    validate_config(&config)?;
+    apply_enabled_adapters(config)
+}
+
+pub fn write_default_config_if_missing(root: &Path) -> Result<bool, NaomeError> {
+    let path = root.join(CONFIG_RELATIVE_PATH);
+    if path.exists() {
+        return Ok(false);
+    }
+
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let content = serde_json::to_string_pretty(&generated_config(root)?)?;
+    fs::write(path, format!("{content}\n"))?;
+    Ok(true)
+}
+
+fn generated_config(root: &Path) -> Result<RepositoryQualityConfig, NaomeError> {
+    let paths = collect_repo_paths(root)?;
+    let mut config = RepositoryQualityConfig::default();
+    config.enabled_adapters = detected_adapter_ids(&paths);
+    Ok(config)
+}
+
+fn validate_config(config: &RepositoryQualityConfig) -> Result<(), NaomeError> {
+    validate_ready_schema(
+        CONFIG_RELATIVE_PATH,
+        &config.schema,
+        "naome.repository-quality.v1",
+        config.version,
+        &config.status,
+    )?;
+    if config.limits.duplicate_block_lines < 3 {
+        return Err(NaomeError::new(
+            ".naome/repository-quality.json duplicateBlockLines must be at least 3.",
+        ));
+    }
+    if !(0.5..=1.0).contains(&config.limits.near_duplicate_similarity) {
+        return Err(NaomeError::new(
+            ".naome/repository-quality.json nearDuplicateSimilarity must be between 0.5 and 1.0.",
+        ));
+    }
+    validate_adapter_ids(&config.enabled_adapters)?;
+    for rule in &config.path_rules {
+        if rule.id.trim().is_empty() {
+            return Err(NaomeError::new(
+                ".naome/repository-quality.json pathRules entries must have a non-empty id.",
+            ));
+        }
+        if rule.paths.is_empty() {
+            return Err(NaomeError::new(format!(
+                ".naome/repository-quality.json pathRules.{} must list at least one path.",
+                rule.id
+            )));
+        }
+        if rule
+            .limits
+            .duplicate_block_lines
+            .is_some_and(|value| value < 3)
+        {
+            return Err(NaomeError::new(format!(
+                ".naome/repository-quality.json pathRules.{} duplicateBlockLines must be at least 3.",
+                rule.id
+            )));
+        }
+        if rule
+            .limits
+            .near_duplicate_similarity
+            .is_some_and(|value| !(0.5..=1.0).contains(&value))
+        {
+            return Err(NaomeError::new(format!(
+                ".naome/repository-quality.json pathRules.{} nearDuplicateSimilarity must be between 0.5 and 1.0.",
+                rule.id
+            )));
+        }
+    }
+    Ok(())
+}

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

@@ -0,0 +1,24 @@
+use crate::models::NaomeError;
+
+pub(crate) fn validate_ready_schema(
+    config_path: &str,
+    actual_schema: &str,
+    expected_schema: &str,
+    version: u32,
+    status: &str,
+) -> Result<(), NaomeError> {
+    if actual_schema != expected_schema {
+        return Err(NaomeError::new(format!(
+            "{config_path} schema must be {expected_schema}."
+        )));
+    }
+    if version != 1 {
+        return Err(NaomeError::new(format!("{config_path} version must be 1.")));
+    }
+    if status != "ready" {
+        return Err(NaomeError::new(format!(
+            "{config_path} status must be ready."
+        )));
+    }
+    Ok(())
+}

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

@@ -0,0 +1,108 @@
+mod adapter_support;
+mod adapters;
+mod baseline;
+mod checks;
+mod cleanup;
+mod config;
+mod config_support;
+mod scanner;
+mod structure;
+mod types;
+
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+pub use cleanup::{cleanup_plan_from_violations, cleanup_route_for_path};
+pub use structure::{
+    explain_repository_structure, RepositoryStructureConfig, StructurePathExplanation,
+};
+pub use types::{
+    QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask, QualityInitResult, QualityMode,
+    QualityReport, QualitySummary, QualityViolation, RepositoryQualityConfig,
+};
+
+use self::baseline::{baseline_relative_path, read_baseline_fingerprints, write_baseline};
+use self::checks::run_quality_checks;
+use self::config::{config_relative_path, read_config, write_default_config_if_missing};
+use self::scanner::scan_repository;
+use self::structure::{
+    run_repository_structure_checks, structure_config_relative_path,
+    write_default_structure_config_if_missing,
+};
+
+pub fn check_repository_quality(
+    root: &Path,
+    mode: QualityMode,
+) -> Result<QualityReport, NaomeError> {
+    let config = read_config(root)?;
+    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);
+    }
+    let blocking_violation_count = violations.len();
+    let baseline_violation_count = violations
+        .iter()
+        .filter(|violation| violation.baseline)
+        .count();
+    let ok = blocking_violation_count == 0;
+
+    Ok(QualityReport {
+        schema: "naome.repository-quality-report.v1".to_string(),
+        mode: mode.as_str().to_string(),
+        ok,
+        changed_paths: context.changed_paths.clone(),
+        scanned_paths: context.scanned_paths(),
+        summary: QualitySummary {
+            scanned_files: context.files.len(),
+            violation_count: violations.len(),
+            baseline_violation_count,
+            blocking_violation_count,
+        },
+        violations,
+    })
+}
+
+pub fn init_repository_quality(root: &Path) -> Result<QualityInitResult, NaomeError> {
+    let config_written = write_default_config_if_missing(root)?;
+    let structure_config_written = {
+        let config = read_config(root)?;
+        let context = scan_repository(root, QualityMode::Report, config)?;
+        write_default_structure_config_if_missing(root, &context.repo_paths)?
+    };
+    let report = check_repository_quality(root, QualityMode::Report)?;
+    let baseline_written = write_baseline(root, &report.violations)?;
+
+    Ok(QualityInitResult {
+        schema: "naome.repository-quality-init.v1".to_string(),
+        config_written,
+        structure_config_written,
+        baseline_written,
+        baseline_violations: report.violations.len(),
+        config_path: config_relative_path().to_string(),
+        structure_config_path: structure_config_relative_path().to_string(),
+        baseline_path: baseline_relative_path().to_string(),
+    })
+}
+
+pub fn plan_quality_cleanup(root: &Path) -> Result<QualityCleanupPlan, NaomeError> {
+    let report = check_repository_quality(root, QualityMode::Report)?;
+    Ok(cleanup_plan_from_violations(&report.violations))
+}
+
+pub fn route_quality_cleanup(
+    root: &Path,
+    path: impl AsRef<str>,
+) -> Result<QualityCleanupRoute, NaomeError> {
+    let path = path.as_ref().replace('\\', "/");
+    let report = check_repository_quality(root, QualityMode::Report)?;
+    let violations = report
+        .violations
+        .into_iter()
+        .filter(|violation| violation.path == path)
+        .collect::<Vec<_>>();
+    Ok(cleanup_route_for_path(&path, violations))
+}

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

@@ -0,0 +1,103 @@
+use std::collections::HashMap;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::NaomeError;
+
+pub(crate) fn collect_repo_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    let output = Command::new("git")
+        .args([
+            "ls-files",
+            "-z",
+            "--cached",
+            "--others",
+            "--exclude-standard",
+        ])
+        .current_dir(root)
+        .output();
+    if let Ok(output) = output {
+        if output.status.success() {
+            let mut paths = output
+                .stdout
+                .split(|byte| *byte == 0)
+                .filter(|entry| !entry.is_empty())
+                .map(|entry| String::from_utf8_lossy(entry).replace('\\', "/"))
+                .collect::<Vec<_>>();
+            paths.sort();
+            paths.dedup();
+            return Ok(paths);
+        }
+    }
+
+    let mut paths = Vec::new();
+    collect_files_recursive(root, root, &mut paths)?;
+    paths.sort();
+    Ok(paths)
+}
+
+pub(super) fn added_lines_by_path(root: &Path) -> Result<HashMap<String, usize>, NaomeError> {
+    let mut added = HashMap::new();
+    for args in [
+        vec!["diff", "--numstat"],
+        vec!["diff", "--cached", "--numstat"],
+    ] {
+        let output = Command::new("git").args(args).current_dir(root).output()?;
+        if !output.status.success() {
+            continue;
+        }
+        for line in String::from_utf8_lossy(&output.stdout).lines() {
+            let mut parts = line.split('\t');
+            let Some(additions) = parts.next() else {
+                continue;
+            };
+            let _deletions = parts.next();
+            let Some(path) = parts.next() else { continue };
+            let Ok(count) = additions.parse::<usize>() else {
+                continue;
+            };
+            *added.entry(path.replace('\\', "/")).or_insert(0) += count;
+        }
+    }
+    for path in untracked_paths(root)? {
+        if let Ok(content) = fs::read_to_string(root.join(&path)) {
+            added.insert(path, content.lines().count());
+        }
+    }
+    Ok(added)
+}
+
+fn collect_files_recursive(
+    root: &Path,
+    dir: &Path,
+    paths: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_dir() {
+            collect_files_recursive(root, &path, paths)?;
+        } else if path.is_file() {
+            if let Ok(relative) = path.strip_prefix(root) {
+                paths.push(relative.to_string_lossy().replace('\\', "/"));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn untracked_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    let output = Command::new("git")
+        .args(["ls-files", "--others", "--exclude-standard", "-z"])
+        .current_dir(root)
+        .output()?;
+    if !output.status.success() {
+        return Ok(Vec::new());
+    }
+    Ok(output
+        .stdout
+        .split(|byte| *byte == 0)
+        .filter(|entry| !entry.is_empty())
+        .map(|entry| String::from_utf8_lossy(entry).replace('\\', "/"))
+        .collect())
+}