@lamentis/naome 1.2.1 → 1.3.1

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

@@ -5,17 +5,21 @@ use crate::quality::adapter_support::{
     find_adapter_by_id, validate_ids, AdapterDescriptor, RepoSignals,
 };
 
+use super::adapter_ios;
 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],
+#[derive(Clone, Copy)]
+pub(super) struct StructureAdapter {
+    pub(super) id: &'static str,
+    pub(super) detect: fn(&RepoSignals<'_>) -> bool,
+    pub(super) source_roots: &'static [&'static str],
+    pub(super) test_roots: &'static [&'static str],
+    pub(super) generated_roots: &'static [&'static str],
+    pub(super) artifact_roots: &'static [&'static str],
+    pub(super) module_roots: &'static [&'static str],
+    pub(super) allowed_root_files: &'static [&'static str],
 }
 
 impl AdapterDescriptor for StructureAdapter {
@@ -29,17 +33,21 @@ impl AdapterDescriptor for StructureAdapter {
 }
 
 pub fn detected_structure_adapter_ids(paths: &[String]) -> Vec<String> {
-    detected_ids(paths, registry())
+    let registry = registry();
+    detected_ids(paths, &registry)
 }
 
 pub fn apply_structure_adapters(
     mut config: RepositoryStructureConfig,
 ) -> Result<RepositoryStructureConfig, NaomeError> {
-    validate_structure_adapter_ids(&config.enabled_adapters)?;
+    let registry = registry();
+    validate_ids(&config.enabled_adapters, &registry, CONFIG_PATH)?;
     for adapter_id in config.enabled_adapters.clone() {
-        let adapter = find_adapter_by_id(registry(), &adapter_id, CONFIG_PATH)?;
+        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.generated_roots, adapter.generated_roots);
+        extend_unique(&mut config.artifact_roots, adapter.artifact_roots);
         extend_unique(&mut config.module_roots, adapter.module_roots);
         extend_unique(&mut config.allowed_root_files, adapter.allowed_root_files);
     }
@@ -47,38 +55,48 @@ pub fn apply_structure_adapters(
 }
 
 pub fn validate_structure_adapter_ids(ids: &[String]) -> Result<(), NaomeError> {
-    validate_ids(ids, registry(), CONFIG_PATH)
+    let registry = registry();
+    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",
-            ],
-        },
-    ]
+const BASE_STRUCTURE_ADAPTERS: &[StructureAdapter] = &[
+    StructureAdapter {
+        id: "rust",
+        detect: detects_rust_project,
+        source_roots: &["src/**", "crates/*/src/**", "**/crates/*/src/**"],
+        test_roots: &["tests/**", "crates/*/tests/**", "**/crates/*/tests/**"],
+        generated_roots: &[],
+        artifact_roots: &[],
+        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/**"],
+        generated_roots: &[],
+        artifact_roots: &["coverage/**", "**/coverage/**", ".next/**", "**/.next/**"],
+        module_roots: &["src/**", "app/**", "packages/*/src/**"],
+        allowed_root_files: &[
+            "package.json",
+            "tsconfig.json",
+            "vite.config.ts",
+            "next.config.js",
+        ],
+    },
+];
+
+fn registry() -> Vec<StructureAdapter> {
+    let mut adapters = Vec::new();
+    adapters.extend_from_slice(BASE_STRUCTURE_ADAPTERS);
+    adapters.extend(adapter_ios::adapters());
+    adapters
 }

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

@@ -1,5 +1,3 @@
-use std::collections::BTreeMap;
-
 use crate::quality::structure::model::{RepositoryStructureModel, StructurePath};
 use crate::quality::types::{QualityMode, QualityViolation};
 
@@ -38,7 +36,7 @@ pub(super) fn directory_size(
         if directory.file_count <= model.config.limits.max_directory_files {
             continue;
         }
-        if mode == QualityMode::Changed && directory.direct_changed_paths.is_empty() {
+        if mode.is_changed() && directory.direct_changed_paths.is_empty() {
             continue;
         }
         push_with_limit(
@@ -85,20 +83,13 @@ pub(super) fn case_collisions(
     mode: QualityMode,
     violations: &mut Vec<QualityViolation>,
 ) {
-    let mut groups: BTreeMap<String, Vec<String>> = BTreeMap::new();
-    for path in &model.paths {
-        groups
-            .entry(path.explanation.path.to_ascii_lowercase())
-            .or_default()
-            .push(path.explanation.path.clone());
-    }
-    for group in groups.values().filter(|group| group.len() > 1) {
-        let changed_group = group.iter().any(|path| {
-            model.paths.iter().any(|candidate| {
-                candidate.explanation.path == *path && candidate.explanation.changed
-            })
-        });
-        if mode == QualityMode::Changed && !changed_group {
+    for group in model
+        .lowercase_paths
+        .values()
+        .filter(|group| group.len() > 1)
+    {
+        let changed_group = group.iter().any(|path| model.changed_paths.contains(path));
+        if mode.is_changed() && !changed_group {
             continue;
         }
         for path in group {
@@ -134,10 +125,11 @@ fn related_module_paths(model: &RepositoryStructureModel, path: &StructurePath)
         return Vec::new();
     };
     model
-        .paths
-        .iter()
-        .filter(|candidate| candidate.explanation.module.as_ref() == Some(module))
-        .map(|candidate| candidate.explanation.path.clone())
+        .module_paths
+        .get(module)
+        .into_iter()
+        .flatten()
+        .cloned()
         .filter(|candidate| candidate != &path.explanation.path)
         .take(10)
         .collect()

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

@@ -53,7 +53,7 @@ fn check_enabled(model: &RepositoryStructureModel, check_id: &str) -> bool {
 }
 
 fn applies(path: &StructurePath, mode: QualityMode) -> bool {
-    mode == QualityMode::Report || path.explanation.changed
+    !mode.is_changed() || path.explanation.changed
 }
 
 fn push(

package/crates/naome-core/src/quality/structure/classify/roles.rs

@@ -2,13 +2,37 @@ use crate::paths;
 
 use crate::quality::structure::model::RepositoryStructureConfig;
 
+const ROLE_SEGMENTS: &[&str] = &[
+    "src",
+    "source",
+    "sources",
+    "test",
+    "tests",
+    "docs",
+    "doc",
+    "scripts",
+    "generated",
+    "resources",
+    "views",
+];
+
 pub fn role_for(path: &str, segments: &[String], config: &RepositoryStructureConfig) -> String {
     let lower = path.to_ascii_lowercase();
     if has_segment(segments, &["node_modules", "vendor", "third_party"]) {
         return "dependency/vendor".to_string();
     }
     if paths::matches_any(path, &config.generated_roots)
-        || has_segment(segments, &["generated", "__generated__", "codegen"])
+        || has_segment(
+            segments,
+            &[
+                "generated",
+                "__generated__",
+                "codegen",
+                "swiftgen",
+                "sourcery",
+            ],
+        )
+        || is_generated_ios_path(&lower)
     {
         return "generated".to_string();
     }
@@ -131,7 +155,13 @@ fn is_test_path(lower: &str, segments: &[String]) -> bool {
     lower.contains(".test.")
         || lower.contains(".spec.")
         || lower.ends_with("_test.rs")
+        || lower.ends_with("tests.swift")
+        || lower.ends_with("uitests.swift")
         || has_segment(segments, &["test", "tests", "__tests__"])
+        || segments.iter().any(|segment| {
+            let lower = segment.to_ascii_lowercase();
+            lower.ends_with("tests") || lower.ends_with("uitests")
+        })
 }
 
 fn is_docs_path(lower: &str, segments: &[String]) -> bool {
@@ -150,8 +180,16 @@ fn is_config_path(
     paths::matches_any(path, &config.allowed_root_files)
         || segments.len() == 1 && (lower.starts_with('.') || lower.ends_with(".toml"))
         || lower.ends_with(".json")
+        || lower.ends_with(".plist")
+        || lower.ends_with(".entitlements")
+        || lower.ends_with(".xcconfig")
+        || lower.ends_with(".strings")
+        || lower.ends_with(".stringsdict")
         || lower.ends_with(".yaml")
         || lower.ends_with(".yml")
+        || lower.ends_with("package.swift")
+        || lower.ends_with("podfile")
+        || lower.ends_with("cartfile")
 }
 
 fn is_script_path(lower: &str, segments: &[String]) -> bool {
@@ -163,6 +201,16 @@ fn is_artifact_path(lower: &str) -> bool {
         || lower.ends_with(".log")
         || lower.ends_with(".map")
         || lower.ends_with(".min.js")
+        || lower.contains("/deriveddata/")
+        || lower.ends_with(".xcarchive")
+        || lower.ends_with(".dsym")
+}
+
+fn is_generated_ios_path(lower: &str) -> bool {
+    lower.ends_with(".generated.swift")
+        || lower.ends_with(".pb.swift")
+        || lower.ends_with(".grpc.swift")
+        || lower.ends_with("/r.generated.swift")
 }
 
 fn has_segment(segments: &[String], expected: &[&str]) -> bool {
@@ -173,10 +221,8 @@ fn has_segment(segments: &[String], expected: &[&str]) -> bool {
 }
 
 fn is_role_segment(segment: &str) -> bool {
-    matches!(
-        segment,
-        "src" | "test" | "tests" | "docs" | "doc" | "scripts" | "generated"
-    )
+    let lower = segment.to_ascii_lowercase();
+    ROLE_SEGMENTS.contains(&lower.as_str())
 }
 
 fn stem(file_name: &str) -> Option<String> {

package/crates/naome-core/src/quality/structure/classify.rs

@@ -24,10 +24,16 @@ pub fn build_structure_model(
         .collect::<Vec<_>>();
     paths.sort_by(|left, right| left.explanation.path.cmp(&right.explanation.path));
     let directories = directories_for(&paths);
+    let indexes = indexes_for(&paths);
     RepositoryStructureModel {
         config,
         paths,
         directories,
+        module_paths: indexes.module_paths,
+        directory_paths: indexes.directory_paths,
+        role_paths: indexes.role_paths,
+        lowercase_paths: indexes.lowercase_paths,
+        changed_paths: indexes.changed_paths,
     }
 }
 
@@ -92,3 +98,49 @@ fn directory_of(path: &str) -> String {
         .map(|(directory, _)| directory.to_string())
         .unwrap_or_else(|| ".".to_string())
 }
+
+struct StructureIndexes {
+    module_paths: BTreeMap<String, Vec<String>>,
+    directory_paths: BTreeMap<String, Vec<String>>,
+    role_paths: BTreeMap<String, Vec<String>>,
+    lowercase_paths: BTreeMap<String, Vec<String>>,
+    changed_paths: BTreeSet<String>,
+}
+
+fn indexes_for(paths: &[StructurePath]) -> StructureIndexes {
+    let mut module_paths = BTreeMap::new();
+    let mut directory_paths = BTreeMap::new();
+    let mut role_paths = BTreeMap::new();
+    let mut lowercase_paths = BTreeMap::new();
+    let mut changed_paths = BTreeSet::new();
+    for path in paths {
+        let value = path.explanation.path.clone();
+        if let Some(module) = &path.explanation.module {
+            push_index(&mut module_paths, module, &value);
+        }
+        push_index(&mut directory_paths, &path.explanation.directory, &value);
+        push_index(&mut role_paths, &path.explanation.role, &value);
+        push_index(
+            &mut lowercase_paths,
+            &path.explanation.path.to_ascii_lowercase(),
+            &value,
+        );
+        if path.explanation.changed {
+            changed_paths.insert(value);
+        }
+    }
+    StructureIndexes {
+        module_paths,
+        directory_paths,
+        role_paths,
+        lowercase_paths,
+        changed_paths,
+    }
+}
+
+fn push_index(index: &mut BTreeMap<String, Vec<String>>, key: &str, value: &str) {
+    index
+        .entry(key.to_string())
+        .or_default()
+        .push(value.to_string());
+}

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

@@ -19,6 +19,15 @@ pub fn structure_config_relative_path() -> &'static str {
 pub fn read_structure_config(
     root: &Path,
     paths: &[String],
+) -> Result<RepositoryStructureConfig, NaomeError> {
+    let config = read_policy_structure_config(root, paths)?;
+    validate_structure_config(&config)?;
+    apply_structure_adapters(config)
+}
+
+pub(crate) fn read_policy_structure_config(
+    root: &Path,
+    paths: &[String],
 ) -> Result<RepositoryStructureConfig, NaomeError> {
     let path = root.join(CONFIG_RELATIVE_PATH);
     let config = if path.is_file() {
@@ -27,7 +36,20 @@ pub fn read_structure_config(
         generated_structure_config(paths)
     };
     validate_structure_config(&config)?;
-    apply_structure_adapters(config)
+    Ok(config)
+}
+
+pub(crate) fn write_policy_structure_config(
+    root: &Path,
+    config: &RepositoryStructureConfig,
+) -> 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_structure_config_if_missing(
@@ -41,8 +63,7 @@ pub fn write_default_structure_config_if_missing(
     if let Some(parent) = path.parent() {
         fs::create_dir_all(parent)?;
     }
-    let content = serde_json::to_string_pretty(&generated_structure_config(paths))?;
-    fs::write(path, format!("{content}\n"))?;
+    write_policy_structure_config(root, &generated_structure_config(paths))?;
     Ok(true)
 }
 

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

@@ -1,3 +1,4 @@
+mod adapter_ios;
 mod adapters;
 mod checks;
 mod classify;
@@ -11,10 +12,12 @@ use std::path::Path;
 use crate::models::NaomeError;
 
 use super::scanner::QualityContext;
-use super::types::{QualityMode, QualityViolation};
+use super::types::QualityViolation;
+pub(crate) use adapters::detected_structure_adapter_ids;
 use checks::run_structure_checks;
 use classify::build_structure_model;
 use config::read_structure_config;
+pub(crate) use config::{read_policy_structure_config, write_policy_structure_config};
 pub use config::{structure_config_relative_path, write_default_structure_config_if_missing};
 pub use model::{RepositoryStructureConfig, StructurePathExplanation};
 
@@ -33,7 +36,7 @@ pub fn run_repository_structure_checks(
                 .find(|file| file.path == violation.path)
                 .is_some_and(|file| !file.symbols.is_empty())
     });
-    if context.mode == QualityMode::Report {
+    if !context.mode.is_changed() {
         for violation in &mut violations {
             violation.baseline = baseline_fingerprints.contains(&violation.fingerprint);
         }

package/crates/naome-core/src/quality/structure/model.rs

@@ -1,4 +1,4 @@
-use std::collections::BTreeSet;
+use std::collections::{BTreeMap, BTreeSet};
 
 use serde::{Deserialize, Serialize};
 
@@ -121,4 +121,11 @@ pub struct RepositoryStructureModel {
     pub config: RepositoryStructureConfig,
     pub paths: Vec<StructurePath>,
     pub directories: Vec<StructureDirectory>,
+    pub module_paths: BTreeMap<String, Vec<String>>,
+    #[allow(dead_code)]
+    pub directory_paths: BTreeMap<String, Vec<String>>,
+    #[allow(dead_code)]
+    pub role_paths: BTreeMap<String, Vec<String>>,
+    pub lowercase_paths: BTreeMap<String, Vec<String>>,
+    pub changed_paths: BTreeSet<String>,
 }

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

@@ -4,15 +4,47 @@ use crate::paths;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum QualityMode {
-    Changed,
+    ChangedFast,
+    PathScoped,
     Report,
+    DeepReport,
 }
 
 impl QualityMode {
+    #[allow(non_upper_case_globals)]
+    pub const Changed: Self = Self::ChangedFast;
+
     pub fn as_str(self) -> &'static str {
         match self {
-            Self::Changed => "changed",
+            Self::ChangedFast => "changed",
+            Self::PathScoped => "path",
             Self::Report => "report",
+            Self::DeepReport => "deep-report",
+        }
+    }
+
+    pub fn is_changed(self) -> bool {
+        matches!(self, Self::ChangedFast | Self::PathScoped)
+    }
+
+    pub fn is_deep(self) -> bool {
+        self == Self::DeepReport
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum QualityInitMode {
+    SeedOnly,
+    Baseline,
+    DeepBaseline,
+}
+
+impl QualityInitMode {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::SeedOnly => "init",
+            Self::Baseline => "baseline",
+            Self::DeepBaseline => "deep-baseline",
         }
     }
 }
@@ -187,9 +219,14 @@ pub struct QualityReport {
 #[serde(rename_all = "camelCase")]
 pub struct QualitySummary {
     pub scanned_files: usize,
+    pub scanned_path_count: usize,
     pub violation_count: usize,
     pub baseline_violation_count: usize,
     pub blocking_violation_count: usize,
+    pub truncated: bool,
+    pub reason_codes: Vec<String>,
+    pub cache_hits: usize,
+    pub cache_misses: usize,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -211,15 +248,34 @@ pub struct QualityViolation {
 #[serde(rename_all = "camelCase")]
 pub struct QualityInitResult {
     pub schema: String,
+    pub mode: String,
     pub config_written: bool,
     pub structure_config_written: bool,
     pub baseline_written: bool,
+    pub baseline_pending: bool,
     pub baseline_violations: usize,
     pub config_path: String,
     pub structure_config_path: String,
     pub baseline_path: String,
 }
 
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityReconcileReport {
+    pub schema: String,
+    pub ok: bool,
+    pub stale: bool,
+    pub write: bool,
+    pub detected_quality_adapters: Vec<String>,
+    pub enabled_quality_adapters: Vec<String>,
+    pub missing_quality_adapters: Vec<String>,
+    pub detected_structure_adapters: Vec<String>,
+    pub enabled_structure_adapters: Vec<String>,
+    pub missing_structure_adapters: Vec<String>,
+    pub updated_paths: Vec<String>,
+    pub reason_codes: Vec<String>,
+}
+
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct QualityCleanupPlan {
@@ -258,6 +314,7 @@ pub fn default_generated_paths() -> Vec<String> {
 const DEFAULT_IGNORED_PATHS: &str = r#"
 .git/**
 .naome/archive/**
+.naome/cache/**
 .naome/task-state.json
 .naome/task-journal.jsonl
 .naome/repository-quality.json