@lamentis/naome 1.3.0 → 1.3.2

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

@@ -23,6 +23,25 @@ impl<'a> RepoSignals<'a> {
             .iter()
             .any(|path| extensions.iter().any(|extension| path.ends_with(extension)))
     }
+
+    pub(crate) fn has_path_containing(&self, fragments: &[&str]) -> bool {
+        self.paths.iter().any(|path| {
+            let lower = path.to_ascii_lowercase();
+            fragments.iter().any(|fragment| lower.contains(fragment))
+        })
+    }
+
+    pub(crate) fn has_file_name(&self, names: &[&str]) -> bool {
+        self.paths.iter().any(|path| {
+            let lower = path.to_ascii_lowercase();
+            path.rsplit('/').next().is_some_and(|file_name| {
+                names
+                    .iter()
+                    .any(|name| file_name.eq_ignore_ascii_case(name))
+                    || names.iter().any(|name| lower.ends_with(name))
+            })
+        })
+    }
 }
 
 pub(crate) trait AdapterDescriptor {
@@ -87,3 +106,51 @@ pub(crate) fn detects_javascript_typescript_project(signals: &RepoSignals<'_>) -
     signals.has_manifest("package.json")
         || signals.has_extension(&[".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"])
 }
+
+pub(crate) fn detects_swift_project(signals: &RepoSignals<'_>) -> bool {
+    signals.has_manifest("Package.swift") || signals.has_extension(&[".swift"])
+}
+
+pub(crate) fn detects_xcode_project(signals: &RepoSignals<'_>) -> bool {
+    signals.has_path_containing(&[".xcodeproj/", ".xcworkspace/"])
+}
+
+pub(crate) fn detects_xctest_project(signals: &RepoSignals<'_>) -> bool {
+    signals.has_path_containing(&["tests/"])
+        && signals.has_file_name(&["tests.swift", "uitests.swift"])
+}
+
+pub(crate) fn detects_swiftui_project(signals: &RepoSignals<'_>) -> bool {
+    signals.has_file_name(&["view.swift", "app.swift"])
+        || signals.has_path_containing(&["preview content/"])
+}
+
+pub(crate) fn detects_ios_app_structure_project(signals: &RepoSignals<'_>) -> bool {
+    detects_xcode_project(signals)
+        || signals.has_file_name(&["appdelegate.swift", "scenedelegate.swift", "info.plist"])
+        || signals.has_path_containing(&[".xcassets/"])
+}
+
+pub(crate) fn detects_swift_package_project(signals: &RepoSignals<'_>) -> bool {
+    signals.has_manifest("Package.swift")
+        || signals.has_path_containing(&["sources/", "tests/"])
+            && signals.has_extension(&[".swift"])
+}
+
+pub(crate) fn detects_ios_resources_project(signals: &RepoSignals<'_>) -> bool {
+    signals.has_path_containing(&[".xcassets/"])
+        || signals.has_extension(&[
+            ".strings",
+            ".stringsdict",
+            ".plist",
+            ".entitlements",
+            ".storyboard",
+            ".xib",
+        ])
+}
+
+pub(crate) fn detects_generated_ios_project(signals: &RepoSignals<'_>) -> bool {
+    signals.has_path_containing(&["generated/", "swiftgen/", "sourcery/"])
+        || signals.has_file_name(&["r.generated.swift"])
+        || signals.has_extension(&[".generated.swift", ".pb.swift", ".grpc.swift"])
+}

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

@@ -1,8 +1,12 @@
 use crate::models::NaomeError;
 
+use super::adapter_ios;
 use super::adapter_support::{
-    detected_ids, detects_javascript_typescript_project, detects_rust_project, extend_unique,
-    find_adapter_by_id, validate_ids, AdapterDescriptor, RepoSignals,
+    detected_ids, detects_generated_ios_project, detects_ios_app_structure_project,
+    detects_ios_resources_project, detects_javascript_typescript_project, detects_rust_project,
+    detects_swift_package_project, detects_swift_project, detects_swiftui_project,
+    detects_xcode_project, detects_xctest_project, extend_unique, find_adapter_by_id, validate_ids,
+    AdapterDescriptor, RepoSignals,
 };
 use super::types::{QualityLimitOverrides, QualityPathRule, RepositoryQualityConfig};
 
@@ -49,21 +53,76 @@ pub(crate) fn validate_adapter_ids(ids: &[String]) -> Result<(), NaomeError> {
     validate_ids(ids, registry(), CONFIG_PATH)
 }
 
+const QUALITY_ADAPTERS: &[QualityAdapter] = &[
+    QualityAdapter {
+        id: "rust",
+        generated_paths: &[],
+        detect: detects_rust_project,
+        path_rules: rust_path_rules,
+    },
+    QualityAdapter {
+        id: "javascript-typescript",
+        generated_paths: &["coverage/**", "**/coverage/**", ".next/**", "**/.next/**"],
+        detect: detects_javascript_typescript_project,
+        path_rules: javascript_typescript_path_rules,
+    },
+    QualityAdapter {
+        id: "swift",
+        generated_paths: &[],
+        detect: detects_swift_project,
+        path_rules: adapter_ios::swift_path_rules,
+    },
+    QualityAdapter {
+        id: "xcode",
+        generated_paths: &[
+            "DerivedData/**",
+            "**/DerivedData/**",
+            "**/xcuserdata/**",
+            "**/*.xcuserstate",
+        ],
+        detect: detects_xcode_project,
+        path_rules: empty_path_rules,
+    },
+    QualityAdapter {
+        id: "xctest",
+        generated_paths: &[],
+        detect: detects_xctest_project,
+        path_rules: adapter_ios::xctest_path_rules,
+    },
+    QualityAdapter {
+        id: "swiftui",
+        generated_paths: &["**/Preview Content/**"],
+        detect: detects_swiftui_project,
+        path_rules: adapter_ios::swiftui_path_rules,
+    },
+    QualityAdapter {
+        id: "ios-app-structure",
+        generated_paths: &[],
+        detect: detects_ios_app_structure_project,
+        path_rules: adapter_ios::ios_app_structure_path_rules,
+    },
+    QualityAdapter {
+        id: "swift-package",
+        generated_paths: &[],
+        detect: detects_swift_package_project,
+        path_rules: adapter_ios::swift_package_path_rules,
+    },
+    QualityAdapter {
+        id: "ios-resources",
+        generated_paths: &[],
+        detect: detects_ios_resources_project,
+        path_rules: adapter_ios::ios_resource_path_rules,
+    },
+    QualityAdapter {
+        id: "generated-ios",
+        generated_paths: adapter_ios::GENERATED_IOS_PATHS,
+        detect: detects_generated_ios_project,
+        path_rules: adapter_ios::generated_ios_path_rules,
+    },
+];
+
 fn registry() -> &'static [QualityAdapter] {
-    &[
-        QualityAdapter {
-            id: "rust",
-            generated_paths: &[],
-            detect: detects_rust_project,
-            path_rules: rust_path_rules,
-        },
-        QualityAdapter {
-            id: "javascript-typescript",
-            generated_paths: &["coverage/**", "**/coverage/**", ".next/**", "**/.next/**"],
-            detect: detects_javascript_typescript_project,
-            path_rules: javascript_typescript_path_rules,
-        },
-    ]
+    QUALITY_ADAPTERS
 }
 
 fn rust_path_rules() -> Vec<QualityPathRule> {
@@ -84,6 +143,10 @@ fn javascript_typescript_path_rules() -> Vec<QualityPathRule> {
     }]
 }
 
+fn empty_path_rules() -> Vec<QualityPathRule> {
+    Vec::new()
+}
+
 fn javascript_typescript_test_paths() -> Vec<String> {
     let mut paths = Vec::new();
     for marker in ["test", "spec"] {
@@ -100,7 +163,7 @@ fn javascript_typescript_test_paths() -> Vec<String> {
     paths
 }
 
-fn test_file_limits(max_top_level_symbols: usize) -> QualityLimitOverrides {
+pub(super) fn test_file_limits(max_top_level_symbols: usize) -> QualityLimitOverrides {
     QualityLimitOverrides {
         max_file_lines: Some(650),
         max_diff_added_lines: Some(220),
@@ -112,7 +175,7 @@ fn test_file_limits(max_top_level_symbols: usize) -> QualityLimitOverrides {
     }
 }
 
-fn path_rule(
+pub(super) fn path_rule(
     id: &str,
     paths: &[&str],
     limits: QualityLimitOverrides,

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

@@ -91,15 +91,13 @@ impl QualityCache {
     }
 
     fn entry_path(&self, path: &str, content_hash: &str) -> PathBuf {
-        self.root
-            .join(CACHE_RELATIVE_PATH)
-            .join(stable_key(&[
-                env!("CARGO_PKG_VERSION"),
-                &self.config_hash,
-                ADAPTER_VERSION,
-                path,
-                content_hash,
-            ]))
+        self.root.join(CACHE_RELATIVE_PATH).join(stable_key(&[
+            env!("CARGO_PKG_VERSION"),
+            &self.config_hash,
+            ADAPTER_VERSION,
+            path,
+            content_hash,
+        ]))
     }
 }
 

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

@@ -18,13 +18,10 @@ impl QualityCheck for DuplicateBlockCheck {
             return;
         }
         let mut occurrences: HashMap<String, Vec<DuplicateOccurrence>> = HashMap::new();
-        for file in context
-            .comparison_candidate_files()
-            .filter(|file| {
-                is_code_like_path(&file.path)
-                    && context.config.check_enabled_for_path(self.id(), &file.path)
-            })
-        {
+        for file in context.comparison_candidate_files().filter(|file| {
+            is_code_like_path(&file.path)
+                && context.config.check_enabled_for_path(self.id(), &file.path)
+        }) {
             let window = context.limits_for(&file.path).duplicate_block_lines;
             if file.normalized_lines.len() < window {
                 continue;

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