@lamentis/naome 1.2.1 → 1.3.1

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

@@ -15,6 +15,12 @@ pub fn config_relative_path() -> &'static str {
 }
 
 pub fn read_config(root: &Path) -> Result<RepositoryQualityConfig, NaomeError> {
+    let config = read_policy_config(root)?;
+    validate_config(&config)?;
+    apply_enabled_adapters(config)
+}
+
+pub(super) fn read_policy_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)?)?
@@ -22,7 +28,20 @@ pub fn read_config(root: &Path) -> Result<RepositoryQualityConfig, NaomeError> {
         generated_config(root)?
     };
     validate_config(&config)?;
-    apply_enabled_adapters(config)
+    Ok(config)
+}
+
+pub(super) fn write_policy_config(
+    root: &Path,
+    config: &RepositoryQualityConfig,
+) -> Result<(), NaomeError> {
+    let path = root.join(CONFIG_RELATIVE_PATH);
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let content = serde_json::to_string_pretty(config)?;
+    fs::write(path, format!("{content}\n"))?;
+    Ok(())
 }
 
 pub fn write_default_config_if_missing(root: &Path) -> Result<bool, NaomeError> {
@@ -34,8 +53,7 @@ pub fn write_default_config_if_missing(root: &Path) -> Result<bool, NaomeError>
     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"))?;
+    write_policy_config(root, &generated_config(root)?)?;
     Ok(true)
 }
 

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

@@ -1,31 +1,47 @@
+mod adapter_ios;
 mod adapter_support;
 mod adapters;
 mod baseline;
+mod cache;
 mod checks;
 mod cleanup;
 mod config;
 mod config_support;
+mod reconcile;
+mod reconcile_anchors;
 mod scanner;
+mod semantic;
 mod structure;
 mod types;
 
 use std::path::Path;
 
 use crate::models::NaomeError;
+use crate::repository_model_drift;
 
+pub use cache::{clear_quality_cache, quality_cache_status, QualityCacheStatus};
 pub use cleanup::{cleanup_plan_from_violations, cleanup_route_for_path};
+pub use reconcile::reconcile_repository_quality;
+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, QualityReconcileReport, 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::scan_repository;
+use self::reconcile::stale_adapter_policy_violations;
+use self::scanner::{collect_repo_paths, stable_fingerprint};
+use self::scanner::{scan_repository, scan_repository_paths};
+use self::semantic::run_semantic_checks;
 use self::structure::{
     run_repository_structure_checks, structure_config_relative_path,
     write_default_structure_config_if_missing,
@@ -37,9 +53,37 @@ pub fn check_repository_quality(
 ) -> Result<QualityReport, NaomeError> {
     let config = read_config(root)?;
     let context = scan_repository(root, mode, config)?;
+    quality_report_from_context(root, context)
+}
+
+pub fn check_repository_quality_paths(
+    root: &Path,
+    paths: &[impl AsRef<str>],
+) -> Result<QualityReport, NaomeError> {
+    let config = read_config(root)?;
+    let paths = paths
+        .iter()
+        .map(|path| path.as_ref().to_string())
+        .collect::<Vec<_>>();
+    let context = scan_repository_paths(root, config, &paths)?;
+    quality_report_from_context(root, context)
+}
+
+fn quality_report_from_context(
+    root: &Path,
+    context: self::scanner::QualityContext,
+) -> Result<QualityReport, NaomeError> {
+    let mode = context.mode;
     let baseline = read_baseline_fingerprints(root)?;
     let mut violations = run_quality_checks(&context);
     violations.extend(run_repository_structure_checks(root, &context, &baseline)?);
+    violations.extend(stale_adapter_policy_violations(
+        root,
+        mode,
+        &context.changed_paths,
+    )?);
+    violations.extend(stale_repository_model_violations(root)?);
+    violations.extend(semantic_changed_violations(&context));
     for violation in &mut violations {
         violation.baseline = baseline.contains(&violation.fingerprint);
     }
@@ -49,6 +93,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(),
@@ -58,30 +106,142 @@ 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: with_repository_model_reason_codes(reason_codes, &violations),
+            cache_hits: context.cache_hits,
+            cache_misses: context.cache_misses,
         },
         violations,
     })
 }
 
+fn semantic_changed_violations(context: &self::scanner::QualityContext) -> Vec<QualityViolation> {
+    if !context.mode.is_changed() {
+        return Vec::new();
+    }
+    run_semantic_checks(context)
+        .findings
+        .iter()
+        .filter_map(|finding| semantic_finding_violation(context, finding))
+        .collect()
+}
+
+fn semantic_finding_violation(
+    context: &self::scanner::QualityContext,
+    finding: &SemanticFinding,
+) -> Option<QualityViolation> {
+    let primary = finding
+        .occurrences
+        .iter()
+        .find(|occurrence| context.applies_to(&occurrence.path))
+        .or_else(|| finding.occurrences.first())?;
+    let related_paths = finding
+        .occurrences
+        .iter()
+        .map(|occurrence| occurrence.path.clone())
+        .filter(|path| path != &primary.path)
+        .collect::<Vec<_>>();
+    Some(QualityViolation {
+        check_id: format!("semantic-{}", finding.kind),
+        severity: "blocking".to_string(),
+        path: primary.path.clone(),
+        line: Some(primary.start_line),
+        message: finding.summary.clone(),
+        value: Some(finding.confidence),
+        limit: None,
+        fingerprint: finding.id.clone(),
+        related_paths,
+        baseline: false,
+    })
+}
+
+fn stale_repository_model_violations(root: &Path) -> Result<Vec<QualityViolation>, NaomeError> {
+    let drift = repository_model_drift(root)?;
+    if !drift.model_present || !drift.stale {
+        return Ok(Vec::new());
+    }
+    let message = drift
+        .messages
+        .first()
+        .cloned()
+        .unwrap_or_else(|| "NAOME repository model is stale.".to_string());
+    Ok(vec![QualityViolation {
+        check_id: "repository-model-stale".to_string(),
+        severity: "blocking".to_string(),
+        path: drift.model_path,
+        line: None,
+        message: message.clone(),
+        value: None,
+        limit: None,
+        fingerprint: stable_fingerprint(&["repository-model-stale", &message]),
+        related_paths: drift.related_paths,
+        baseline: false,
+    }])
+}
+
+fn with_repository_model_reason_codes(
+    mut reason_codes: Vec<String>,
+    violations: &[QualityViolation],
+) -> Vec<String> {
+    if violations
+        .iter()
+        .any(|violation| violation.check_id == "repository-model-stale")
+        && !reason_codes
+            .iter()
+            .any(|code| code == "repository_model_stale")
+    {
+        reason_codes.push("repository_model_stale".to_string());
+    }
+    reason_codes
+}
+
 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 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 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,
+            )
+        }
     };
-    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(),
+        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(),
@@ -106,3 +266,22 @@ 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))
+}
+
+pub fn check_semantic_legacy_paths(
+    root: &Path,
+    paths: &[impl AsRef<str>],
+) -> Result<SemanticReport, NaomeError> {
+    let config = read_config(root)?;
+    let paths = paths
+        .iter()
+        .map(|path| path.as_ref().to_string())
+        .collect::<Vec<_>>();
+    let context = scan_repository_paths(root, config, &paths)?;
+    Ok(run_semantic_checks(&context))
+}

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

@@ -0,0 +1,138 @@
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::adapters::detected_adapter_ids;
+use super::config::{config_relative_path, read_policy_config, write_policy_config};
+use super::reconcile_anchors::changed_paths_introduce_adapter;
+use super::scanner::{collect_repo_paths, stable_fingerprint};
+use super::structure::{
+    detected_structure_adapter_ids, read_policy_structure_config, structure_config_relative_path,
+    write_policy_structure_config,
+};
+use super::types::{QualityMode, QualityReconcileReport, QualityViolation};
+
+pub fn reconcile_repository_quality(
+    root: &Path,
+    write: bool,
+) -> Result<QualityReconcileReport, NaomeError> {
+    let paths = collect_repo_paths(root)?;
+    let mut quality_config = read_policy_config(root)?;
+    let mut structure_config = read_policy_structure_config(root, &paths)?;
+    let detected_quality_adapters = detected_adapter_ids(&paths);
+    let detected_structure_adapters = detected_structure_adapter_ids(&paths);
+    let missing_quality_adapters =
+        missing_adapters(&detected_quality_adapters, &quality_config.enabled_adapters);
+    let missing_structure_adapters = missing_adapters(
+        &detected_structure_adapters,
+        &structure_config.enabled_adapters,
+    );
+    let stale = !missing_quality_adapters.is_empty() || !missing_structure_adapters.is_empty();
+    let mut updated_paths = Vec::new();
+
+    if write && stale {
+        for adapter in &missing_quality_adapters {
+            quality_config.enabled_adapters.push(adapter.clone());
+        }
+        for adapter in &missing_structure_adapters {
+            structure_config.enabled_adapters.push(adapter.clone());
+        }
+        quality_config.enabled_adapters.sort();
+        quality_config.enabled_adapters.dedup();
+        structure_config.enabled_adapters.sort();
+        structure_config.enabled_adapters.dedup();
+
+        if !missing_quality_adapters.is_empty() {
+            write_policy_config(root, &quality_config)?;
+            updated_paths.push(config_relative_path().to_string());
+        }
+        if !missing_structure_adapters.is_empty() {
+            write_policy_structure_config(root, &structure_config)?;
+            updated_paths.push(structure_config_relative_path().to_string());
+        }
+    }
+
+    let stale_after_write = stale && !write;
+    let mut reason_codes = Vec::new();
+    if stale {
+        reason_codes.push("adapter_policy_stale".to_string());
+    }
+    if write && !updated_paths.is_empty() {
+        reason_codes.push("adapter_policy_updated".to_string());
+    }
+
+    Ok(QualityReconcileReport {
+        schema: "naome.repository-quality-reconcile.v1".to_string(),
+        ok: !stale_after_write,
+        stale: stale_after_write,
+        write,
+        detected_quality_adapters,
+        enabled_quality_adapters: quality_config.enabled_adapters,
+        missing_quality_adapters: if write {
+            Vec::new()
+        } else {
+            missing_quality_adapters
+        },
+        detected_structure_adapters,
+        enabled_structure_adapters: structure_config.enabled_adapters,
+        missing_structure_adapters: if write {
+            Vec::new()
+        } else {
+            missing_structure_adapters
+        },
+        updated_paths,
+        reason_codes,
+    })
+}
+
+pub(crate) fn stale_adapter_policy_violations(
+    root: &Path,
+    mode: QualityMode,
+    changed_paths: &[String],
+) -> Result<Vec<QualityViolation>, NaomeError> {
+    let report = reconcile_repository_quality(root, false)?;
+    if report.ok {
+        return Ok(Vec::new());
+    }
+
+    let mut missing = report.missing_quality_adapters.clone();
+    for adapter in &report.missing_structure_adapters {
+        if !missing.contains(adapter) {
+            missing.push(adapter.clone());
+        }
+    }
+    if mode.is_changed() {
+        missing.retain(|adapter| changed_paths_introduce_adapter(adapter, changed_paths));
+    }
+    if missing.is_empty() {
+        return Ok(Vec::new());
+    }
+    missing.sort();
+
+    let message = format!(
+        "Repository tech-stack signals require adapter policy reconciliation. Missing adapter(s): {}. Run `naome quality reconcile --write`.",
+        missing.join(", ")
+    );
+    let check_id = "adapter-policy-stale";
+    let path = config_relative_path();
+    Ok(vec![QualityViolation {
+        check_id: check_id.to_string(),
+        severity: "error".to_string(),
+        path: path.to_string(),
+        line: None,
+        message: message.clone(),
+        value: Some(missing.len() as f64),
+        limit: Some(0.0),
+        fingerprint: stable_fingerprint(&[check_id, path, &missing.join(","), &message]),
+        related_paths: vec![structure_config_relative_path().to_string()],
+        baseline: false,
+    }])
+}
+
+fn missing_adapters(detected: &[String], enabled: &[String]) -> Vec<String> {
+    detected
+        .iter()
+        .filter(|adapter| !enabled.contains(adapter))
+        .cloned()
+        .collect()
+}

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

@@ -0,0 +1,64 @@
+pub(super) fn changed_paths_introduce_adapter(adapter: &str, changed_paths: &[String]) -> bool {
+    match adapter {
+        "rust" => changed_paths
+            .iter()
+            .any(|path| path.ends_with("Cargo.toml")),
+        "javascript-typescript" => changed_paths.iter().any(|path| {
+            path.ends_with("package.json")
+                || path.ends_with("tsconfig.json")
+                || path.ends_with("jsconfig.json")
+        }),
+        "swift" => changed_paths
+            .iter()
+            .any(|path| path.ends_with("Package.swift") || path.ends_with(".swift")),
+        "xcode" => changed_paths
+            .iter()
+            .any(|path| path.contains(".xcodeproj/") || path.contains(".xcworkspace/")),
+        "xctest" => changed_paths.iter().any(|path| {
+            let lower = path.to_ascii_lowercase();
+            lower.contains("/tests/")
+                && (lower.ends_with("tests.swift") || lower.ends_with("uitests.swift"))
+        }),
+        "swiftui" => changed_paths.iter().any(|path| {
+            path.ends_with("App.swift")
+                || path.ends_with("View.swift")
+                || path.contains("Preview Content/")
+        }),
+        "ios-app-structure" => changed_paths.iter().any(|path| {
+            path.ends_with("AppDelegate.swift")
+                || path.ends_with("SceneDelegate.swift")
+                || path.ends_with("Info.plist")
+                || path.contains(".xcassets/")
+                || path.ends_with(".entitlements")
+        }),
+        "swift-package" => changed_paths.iter().any(|path| {
+            path.ends_with("Package.swift")
+                || path.starts_with("Sources/")
+                || path.contains("/Sources/")
+                || path.starts_with("Tests/")
+                || path.contains("/Tests/")
+        }),
+        "ios-resources" => changed_paths.iter().any(|path| {
+            path.contains(".xcassets/")
+                || path.ends_with(".strings")
+                || path.ends_with(".stringsdict")
+                || path.ends_with(".plist")
+                || path.ends_with(".entitlements")
+                || path.ends_with(".storyboard")
+                || path.ends_with(".xib")
+        }),
+        "generated-ios" => changed_paths.iter().any(generated_ios_path),
+        _ => false,
+    }
+}
+
+fn generated_ios_path(path: &String) -> bool {
+    let lower = path.to_ascii_lowercase();
+    lower.contains("/generated/")
+        || lower.contains("/swiftgen/")
+        || lower.contains("/sourcery/")
+        || lower.ends_with("r.generated.swift")
+        || lower.ends_with(".generated.swift")
+        || lower.ends_with(".pb.swift")
+        || lower.ends_with(".grpc.swift")
+}

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('\''))
+}