@lamentis/naome 1.3.0 → 1.3.1

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

@@ -1,3 +1,4 @@
+mod adapter_ios;
 mod adapter_support;
 mod adapters;
 mod baseline;
@@ -6,6 +7,8 @@ mod checks;
 mod cleanup;
 mod config;
 mod config_support;
+mod reconcile;
+mod reconcile_anchors;
 mod scanner;
 mod semantic;
 mod structure;
@@ -14,17 +17,19 @@ mod types;
 use std::path::Path;
 
 use crate::models::NaomeError;
+use crate::repository_model_drift;
 
-pub use cleanup::{cleanup_plan_from_violations, cleanup_route_for_path};
 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, QualityInitMode,
-    QualityInitResult, QualityMode, QualityReport, QualitySummary, QualityViolation,
-    RepositoryQualityConfig,
+    QualityInitResult, QualityMode, QualityReconcileReport, QualityReport, QualitySummary,
+    QualityViolation, RepositoryQualityConfig,
 };
 
 use self::baseline::{
@@ -33,8 +38,9 @@ use self::baseline::{
 };
 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::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,
@@ -47,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);
     }
@@ -77,7 +111,7 @@ pub fn check_repository_quality(
             baseline_violation_count,
             blocking_violation_count,
             truncated: context.truncated,
-            reason_codes,
+            reason_codes: with_repository_model_reason_codes(reason_codes, &violations),
             cache_hits: context.cache_hits,
             cache_misses: context.cache_misses,
         },
@@ -85,6 +119,86 @@ pub fn check_repository_quality(
     })
 }
 
+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)
 }
@@ -112,7 +226,11 @@ pub fn init_repository_quality_with_mode(
                     QualityMode::Report
                 },
             )?;
-            (write_baseline(root, &report.violations)?, report.violations.len(), false)
+            (
+                write_baseline(root, &report.violations)?,
+                report.violations.len(),
+                false,
+            )
         }
     };
 
@@ -154,3 +272,16 @@ pub fn check_semantic_legacy(root: &Path, mode: QualityMode) -> Result<SemanticR
     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.rs

@@ -28,11 +28,7 @@ pub(super) fn analyze_repo_file(
         }
     }
     let content = fs::read_to_string(&full_path).ok()?;
-    let file = analyze_file(
-        path,
-        &content,
-        added_lines.get(path).copied().unwrap_or(0),
-    );
+    let file = analyze_file(path, &content, added_lines.get(path).copied().unwrap_or(0));
     let hash = if allow_cache {
         blob_hashes
             .get(path)
@@ -110,6 +106,8 @@ fn symbol_start(trimmed: &str) -> Option<(String, String)> {
         ("function", "def "),
         ("function", "fn "),
         ("function", "pub fn "),
+        ("function", "pub(crate) fn "),
+        ("function", "pub(super) fn "),
         ("function", "func "),
         ("class", "class "),
         ("struct", "struct "),
@@ -123,6 +121,17 @@ fn symbol_start(trimmed: &str) -> Option<(String, String)> {
             return Some((kind.to_string(), symbol_name(rest)));
         }
     }
+    for visibility in ["", "pub ", "pub(crate) ", "pub(super) "] {
+        for (kind, keyword) in [("const", "const "), ("static", "static ")] {
+            let prefix = format!("{visibility}{keyword}");
+            if let Some(rest) = trimmed.strip_prefix(&prefix) {
+                if !looks_like_typed_rust_item(rest) {
+                    continue;
+                }
+                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.")
@@ -134,6 +143,12 @@ fn symbol_start(trimmed: &str) -> Option<(String, String)> {
     None
 }
 
+fn looks_like_typed_rust_item(rest: &str) -> bool {
+    rest.split('=').next().is_some_and(|before_assignment| {
+        before_assignment.contains(':') && !before_assignment.trim().is_empty()
+    })
+}
+
 fn symbol_name(rest: &str) -> String {
     rest.chars()
         .take_while(|character| character.is_ascii_alphanumeric() || *character == '_')

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

@@ -93,12 +93,36 @@ pub fn scan_repository(
     config: RepositoryQualityConfig,
 ) -> Result<QualityContext, NaomeError> {
     let changed_paths = git::changed_paths(root)?;
+    scan_repository_with_targets(root, mode, config, changed_paths, true)
+}
+
+pub fn scan_repository_paths(
+    root: &Path,
+    config: RepositoryQualityConfig,
+    paths: &[String],
+) -> Result<QualityContext, NaomeError> {
+    let mut target_paths = paths
+        .iter()
+        .map(|path| normalize_target_path(path))
+        .collect::<Result<Vec<_>, _>>()?;
+    target_paths.sort();
+    target_paths.dedup();
+    scan_repository_with_targets(root, QualityMode::PathScoped, config, target_paths, false)
+}
+
+fn scan_repository_with_targets(
+    root: &Path,
+    mode: QualityMode,
+    config: RepositoryQualityConfig,
+    changed_paths: Vec<String>,
+    include_comparison_files: bool,
+) -> Result<QualityContext, NaomeError> {
     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::ChangedFast => changed_paths.clone(),
+        QualityMode::ChangedFast | QualityMode::PathScoped => changed_paths.clone(),
         QualityMode::Report | QualityMode::DeepReport => whole_repo_paths.clone(),
     };
     let added_lines = if mode.is_changed() {
@@ -121,18 +145,22 @@ pub fn scan_repository(
         &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,
-    );
+    let comparison_files = if include_comparison_files {
+        analyze_comparison_paths(
+            root,
+            mode,
+            &whole_repo_paths,
+            &target_paths,
+            &comparison_added_lines,
+            &blob_hashes,
+            &cache,
+            &ignore_patterns,
+            files.len(),
+            &mut state,
+        )
+    } else {
+        Vec::new()
+    };
 
     files.sort_by(|left, right| left.path.cmp(&right.path));
     Ok(QualityContext {
@@ -150,6 +178,17 @@ pub fn scan_repository(
     })
 }
 
+fn normalize_target_path(path: &str) -> Result<String, NaomeError> {
+    let normalized = path.trim_start_matches("./").replace('\\', "/");
+    let has_parent_segment = normalized.split('/').any(|segment| segment == "..");
+    if normalized.is_empty() || normalized.starts_with('/') || has_parent_segment {
+        return Err(NaomeError::new(format!(
+            "quality path must be a repository-relative path: {path}"
+        )));
+    }
+    Ok(normalized)
+}
+
 #[derive(Default)]
 struct ScanState {
     cache_hits: usize,
@@ -196,9 +235,14 @@ fn analyze_primary_paths(
             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())
-        {
+        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);
         }
@@ -258,6 +302,7 @@ pub fn stable_fingerprint(parts: &[&str]) -> String {
 fn max_scanned_files(mode: QualityMode) -> usize {
     match mode {
         QualityMode::ChangedFast => 2_000,
+        QualityMode::PathScoped => 128,
         QualityMode::Report => 5_000,
         QualityMode::DeepReport => usize::MAX,
     }
@@ -265,7 +310,7 @@ fn max_scanned_files(mode: QualityMode) -> usize {
 
 fn max_file_bytes(mode: QualityMode) -> u64 {
     match mode {
-        QualityMode::ChangedFast => 512 * 1024,
+        QualityMode::ChangedFast | QualityMode::PathScoped => 512 * 1024,
         QualityMode::Report => 1024 * 1024,
         QualityMode::DeepReport => 8 * 1024 * 1024,
     }

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

@@ -112,6 +112,9 @@ fn has_legacy_fixture_signal(keys: &BTreeSet<String>) -> bool {
 }
 
 fn is_shared_fixture_factory(candidate: &ObjectCandidate) -> bool {
+    if is_shared_fixture_path(&candidate.path) {
+        return true;
+    }
     let Some(symbol) = &candidate.symbol else {
         return false;
     };
@@ -123,6 +126,20 @@ fn is_shared_fixture_factory(candidate: &ObjectCandidate) -> bool {
     .any(|marker| normalized.contains(marker))
 }
 
+fn is_shared_fixture_path(path: &str) -> bool {
+    let normalized = path.replace('\\', "/").to_ascii_lowercase();
+    [
+        "/fixtures/",
+        "/fixture/",
+        "/support/",
+        "_support/",
+        "-support/",
+        "/test-support.",
+    ]
+    .iter()
+    .any(|marker| normalized.contains(marker))
+}
+
 fn group_applies_to_mode(context: &QualityContext, group: &[&ObjectCandidate]) -> bool {
     if context.mode.is_deep() {
         return true;

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

@@ -4,7 +4,7 @@ use crate::quality::types::QualityMode;
 
 pub(super) fn finding_mode(context: &QualityContext) -> &'static str {
     match context.mode {
-        QualityMode::ChangedFast => "changed-blocking",
+        QualityMode::ChangedFast | QualityMode::PathScoped => "changed-blocking",
         QualityMode::Report => "report",
         QualityMode::DeepReport => "deep-report",
     }