@lamentis/naome 1.3.0 → 1.3.2

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/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;
@@ -12,9 +13,11 @@ use crate::models::NaomeError;
 
 use super::scanner::QualityContext;
 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};
 

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

@@ -5,6 +5,7 @@ use crate::paths;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum QualityMode {
     ChangedFast,
+    PathScoped,
     Report,
     DeepReport,
 }
@@ -16,13 +17,14 @@ impl QualityMode {
     pub fn as_str(self) -> &'static str {
         match self {
             Self::ChangedFast => "changed",
+            Self::PathScoped => "path",
             Self::Report => "report",
             Self::DeepReport => "deep-report",
         }
     }
 
     pub fn is_changed(self) -> bool {
-        self == Self::ChangedFast
+        matches!(self, Self::ChangedFast | Self::PathScoped)
     }
 
     pub fn is_deep(self) -> bool {
@@ -257,6 +259,23 @@ pub struct QualityInitResult {
     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 {

package/crates/naome-core/src/repository_model/detect.rs

@@ -0,0 +1,188 @@
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::path_scan::{collect_repo_paths, evidence, has_any_suffix, has_path, has_suffix};
+use super::types::{RepositoryFact, RepositoryModel, RepositoryVerificationCheck};
+use super::world::build_world_sections;
+
+pub(super) fn detect_repository_model(root: &Path) -> Result<RepositoryModel, NaomeError> {
+    let paths = collect_repo_paths(root)?;
+    let mut facts = Vec::new();
+    detect_stack_facts(&paths, &mut facts);
+    detect_root_facts(&paths, &mut facts);
+    let verification_checks = detect_verification_facts(root, &mut facts)?;
+    facts.sort_by(|left, right| left.id.cmp(&right.id));
+    facts.dedup_by(|left, right| left.id == right.id);
+    let world = build_world_sections(&paths, &facts);
+    Ok(RepositoryModel {
+        schema: "naome.repository-model.v2".to_string(),
+        version: 2,
+        facts,
+        languages: world.languages,
+        package_managers: world.package_managers,
+        build_systems: world.build_systems,
+        adapters: world.adapters,
+        roots: world.roots,
+        entities: world.entities,
+        path_facts: world.path_facts,
+        verification_checks,
+        ..RepositoryModel::default()
+    })
+}
+
+fn detect_stack_facts(paths: &[String], facts: &mut Vec<RepositoryFact>) {
+    if has_path(paths, "Cargo.toml") || has_suffix(paths, ".rs") {
+        push_fact(
+            facts,
+            "language",
+            "rust",
+            evidence(paths, &["Cargo.toml", ".rs"]),
+        );
+        push_fact(
+            facts,
+            "packageManager",
+            "cargo",
+            evidence(paths, &["Cargo.toml"]),
+        );
+        push_fact(
+            facts,
+            "buildSystem",
+            "cargo",
+            evidence(paths, &["Cargo.toml"]),
+        );
+    }
+    if has_path(paths, "package.json") || has_any_suffix(paths, &[".js", ".ts", ".tsx", ".jsx"]) {
+        push_fact(
+            facts,
+            "language",
+            "javascript-typescript",
+            evidence(paths, &["package.json", ".js", ".ts", ".tsx", ".jsx"]),
+        );
+        push_fact(
+            facts,
+            "packageManager",
+            "npm",
+            evidence(paths, &["package.json"]),
+        );
+    }
+    if has_path(paths, "Package.swift") || has_suffix(paths, ".swift") {
+        push_fact(
+            facts,
+            "language",
+            "swift",
+            evidence(paths, &["Package.swift", ".swift"]),
+        );
+        push_fact(
+            facts,
+            "packageManager",
+            "swift-package-manager",
+            evidence(paths, &["Package.swift"]),
+        );
+    }
+    if paths
+        .iter()
+        .any(|path| path.contains(".xcodeproj/") || path.contains(".xcworkspace/"))
+    {
+        push_fact(
+            facts,
+            "buildSystem",
+            "xcode",
+            evidence(paths, &[".xcodeproj/", ".xcworkspace/"]),
+        );
+        push_fact(
+            facts,
+            "appType",
+            "apple-platform",
+            evidence(paths, &[".xcodeproj/", ".xcworkspace/"]),
+        );
+    }
+}
+
+fn detect_root_facts(paths: &[String], facts: &mut Vec<RepositoryFact>) {
+    const SOURCE_ROOTS: &[&str] = &["src", "Sources", "app", "packages"];
+    const TEST_ROOTS: &[&str] = &["test", "tests", "Tests", "__tests__"];
+    const DOCS_ROOTS: &[&str] = &["docs"];
+    const GENERATED_ROOTS: &[&str] = &["generated", "Generated"];
+    const ARTIFACT_ROOTS: &[&str] = &["dist", "build", "DerivedData"];
+
+    for (category, roots) in [
+        ("sourceRoot", SOURCE_ROOTS),
+        ("testRoot", TEST_ROOTS),
+        ("docsRoot", DOCS_ROOTS),
+        ("generatedRoot", GENERATED_ROOTS),
+        ("artifactRoot", ARTIFACT_ROOTS),
+    ] {
+        for root in roots {
+            if paths
+                .iter()
+                .any(|path| path == *root || path.starts_with(&format!("{root}/")))
+            {
+                push_fact(facts, category, root, vec![root.to_string()]);
+            }
+        }
+    }
+}
+
+fn detect_verification_facts(
+    root: &Path,
+    facts: &mut Vec<RepositoryFact>,
+) -> Result<Vec<RepositoryVerificationCheck>, NaomeError> {
+    let path = root.join(".naome/verification.json");
+    if !path.is_file() {
+        return Ok(Vec::new());
+    }
+    let value: serde_json::Value = serde_json::from_str(&std::fs::read_to_string(path)?)?;
+    let Some(checks) = value.get("checks").and_then(serde_json::Value::as_array) else {
+        return Ok(Vec::new());
+    };
+    let mut verification_checks = Vec::new();
+    for check in checks {
+        if let Some(id) = check.get("id").and_then(serde_json::Value::as_str) {
+            push_fact(
+                facts,
+                "verificationCheck",
+                id,
+                vec![".naome/verification.json".to_string()],
+            );
+            verification_checks.push(RepositoryVerificationCheck {
+                id: id.to_string(),
+                command: check
+                    .get("command")
+                    .and_then(serde_json::Value::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                cwd: check
+                    .get("cwd")
+                    .and_then(serde_json::Value::as_str)
+                    .unwrap_or(".")
+                    .to_string(),
+                evidence: check
+                    .get("evidence")
+                    .and_then(serde_json::Value::as_array)
+                    .into_iter()
+                    .flatten()
+                    .filter_map(serde_json::Value::as_str)
+                    .map(str::to_string)
+                    .collect(),
+            });
+        }
+    }
+    verification_checks.sort_by(|left, right| left.id.cmp(&right.id));
+    verification_checks.dedup_by(|left, right| left.id == right.id);
+    Ok(verification_checks)
+}
+
+fn push_fact(facts: &mut Vec<RepositoryFact>, category: &str, value: &str, evidence: Vec<String>) {
+    if evidence.is_empty() {
+        return;
+    }
+    facts.push(RepositoryFact {
+        id: format!("{category}:{value}"),
+        category: category.to_string(),
+        value: value.to_string(),
+        confidence: "high".to_string(),
+        source: "deterministic-scan".to_string(),
+        evidence,
+    });
+}

package/crates/naome-core/src/repository_model/explain.rs

@@ -0,0 +1,121 @@
+use super::types::{RepositoryFact, RepositoryModel, RepositoryPathExplanation};
+
+pub(super) fn explain_path(model: &RepositoryModel, path: &str) -> RepositoryPathExplanation {
+    let normalized = path.replace('\\', "/");
+    let mut facts = facts_for_path(model, &normalized);
+    facts.sort_by(|left, right| left.id.cmp(&right.id));
+    let mut evidence = facts
+        .iter()
+        .flat_map(|fact| fact.evidence.clone())
+        .collect::<std::collections::BTreeSet<_>>()
+        .into_iter()
+        .collect::<Vec<_>>();
+    if !evidence.contains(&normalized) {
+        evidence.push(normalized.clone());
+    }
+    evidence.sort();
+
+    RepositoryPathExplanation {
+        schema: "naome.repository-model-explanation.v1".to_string(),
+        role: path_fact_for_path(model, &normalized)
+            .map(|fact| fact.role.clone())
+            .or_else(|| role_for_path(&normalized)),
+        language: path_fact_for_path(model, &normalized)
+            .and_then(|fact| fact.language.clone())
+            .or_else(|| language_for_path(&normalized)),
+        module: path_fact_for_path(model, &normalized)
+            .and_then(|fact| fact.module.clone())
+            .or_else(|| module_for_path(model, &normalized)),
+        entity: path_fact_for_path(model, &normalized)
+            .and_then(|fact| fact.entity.clone())
+            .or_else(|| entity_for_path(model, &normalized)),
+        path: normalized,
+        facts,
+        evidence,
+    }
+}
+
+fn path_fact_for_path<'a>(
+    model: &'a RepositoryModel,
+    path: &str,
+) -> Option<&'a super::types::RepositoryPathFact> {
+    model.path_facts.iter().find(|fact| fact.path == path)
+}
+
+fn facts_for_path(model: &RepositoryModel, path: &str) -> Vec<RepositoryFact> {
+    model
+        .facts
+        .iter()
+        .filter(|fact| {
+            fact.evidence
+                .iter()
+                .any(|evidence| path_matches_fact(path, evidence))
+        })
+        .cloned()
+        .collect()
+}
+
+fn path_matches_fact(path: &str, evidence: &str) -> bool {
+    path == evidence || path.starts_with(&format!("{evidence}/")) || evidence.starts_with(path)
+}
+
+fn role_for_path(path: &str) -> Option<String> {
+    let lower = path.to_ascii_lowercase();
+    if lower.contains("/tests/") || lower.starts_with("tests/") || lower.ends_with("test.ts") {
+        Some("test".to_string())
+    } else if lower.starts_with("docs/") || lower.ends_with(".md") {
+        Some("docs".to_string())
+    } else if lower.contains("/generated/") || lower.starts_with("generated/") {
+        Some("generated".to_string())
+    } else if lower.starts_with("src/") || lower.starts_with("sources/") || source_suffix(&lower) {
+        Some("source".to_string())
+    } else {
+        None
+    }
+}
+
+fn language_for_path(path: &str) -> Option<String> {
+    match path.rsplit('.').next() {
+        Some("rs") => Some("rust".to_string()),
+        Some("js" | "jsx" | "ts" | "tsx") => Some("javascript-typescript".to_string()),
+        Some("swift") => Some("swift".to_string()),
+        _ => None,
+    }
+}
+
+fn source_suffix(path: &str) -> bool {
+    path.ends_with(".rs")
+        || path.ends_with(".js")
+        || path.ends_with(".jsx")
+        || path.ends_with(".ts")
+        || path.ends_with(".tsx")
+        || path.ends_with(".swift")
+}
+
+fn module_for_path(model: &RepositoryModel, path: &str) -> Option<String> {
+    parent_before(path, "/src/")
+        .or_else(|| parent_before(path, "/Sources/"))
+        .or_else(|| {
+            model
+                .roots
+                .iter()
+                .filter(|root| path.starts_with(&format!("{}/", root.path)))
+                .max_by_key(|root| root.path.len())
+                .map(|root| root.path.clone())
+        })
+}
+
+fn entity_for_path(model: &RepositoryModel, path: &str) -> Option<String> {
+    model
+        .entities
+        .iter()
+        .filter(|entity| entity.path == "." || path.starts_with(&format!("{}/", entity.path)))
+        .max_by_key(|entity| entity.path.len())
+        .map(|entity| entity.id.clone())
+}
+
+fn parent_before(path: &str, marker: &str) -> Option<String> {
+    path.split_once(marker)
+        .map(|(parent, _)| parent.to_string())
+        .filter(|parent| !parent.is_empty())
+}

package/crates/naome-core/src/repository_model/path_scan.rs

@@ -0,0 +1,67 @@
+use std::collections::BTreeSet;
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::NaomeError;
+
+pub(super) 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 !output.status.success() {
+        return Ok(Vec::new());
+    }
+    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();
+    Ok(paths)
+}
+
+pub(super) fn evidence(paths: &[String], markers: &[&str]) -> Vec<String> {
+    let mut evidence = BTreeSet::new();
+    for marker in markers {
+        for path in paths {
+            if matches_marker(path, marker) {
+                evidence.insert(path.clone());
+                break;
+            }
+        }
+    }
+    evidence.into_iter().collect()
+}
+
+pub(super) fn has_path(paths: &[String], expected: &str) -> bool {
+    paths
+        .iter()
+        .any(|path| path == expected || path.ends_with(&format!("/{expected}")))
+}
+
+pub(super) fn has_suffix(paths: &[String], suffix: &str) -> bool {
+    paths.iter().any(|path| path.ends_with(suffix))
+}
+
+pub(super) fn has_any_suffix(paths: &[String], suffixes: &[&str]) -> bool {
+    suffixes.iter().any(|suffix| has_suffix(paths, suffix))
+}
+
+fn matches_marker(path: &str, marker: &str) -> bool {
+    if marker.starts_with('.') {
+        return path.ends_with(marker);
+    }
+    if marker.ends_with('/') {
+        return path.contains(marker);
+    }
+    path == marker || path.ends_with(&format!("/{marker}"))
+}

package/crates/naome-core/src/repository_model/path_support.rs

@@ -0,0 +1,59 @@
+use super::types::{RepositoryEntity, RepositoryRoot};
+
+pub(super) fn language_for_path(path: &str) -> Option<String> {
+    match path.rsplit('.').next() {
+        Some("rs") => Some("rust".to_string()),
+        Some("js" | "jsx" | "ts" | "tsx") => Some("javascript-typescript".to_string()),
+        Some("swift") => Some("swift".to_string()),
+        _ => None,
+    }
+}
+
+pub(super) fn parent_path(path: &str) -> String {
+    path.rsplit_once('/')
+        .map(|(parent, _)| parent.to_string())
+        .unwrap_or_default()
+}
+
+pub(super) fn module_for_path(path: &str, roots: &[RepositoryRoot]) -> Option<String> {
+    parent_path(path)
+        .split_once("/src")
+        .map(|(module, _)| module.to_string())
+        .or_else(|| {
+            parent_path(path)
+                .split_once("/Sources")
+                .map(|(module, _)| module.to_string())
+        })
+        .or_else(|| {
+            roots
+                .iter()
+                .filter(|root| path.starts_with(&format!("{}/", root.path)))
+                .max_by_key(|root| root.path.len())
+                .map(|root| root.path.clone())
+        })
+}
+
+pub(super) fn entity_for_path(path: &str, entities: &[RepositoryEntity]) -> Option<String> {
+    entities
+        .iter()
+        .filter(|entity| entity.path == "." || path.starts_with(&format!("{}/", entity.path)))
+        .max_by_key(|entity| entity.path.len())
+        .map(|entity| entity.id.clone())
+}
+
+pub(super) fn root_at_segment(path: &str, names: &[&str]) -> Option<String> {
+    let segments = path.split('/').collect::<Vec<_>>();
+    let index = segments
+        .iter()
+        .position(|segment| names.iter().any(|name| segment == name))?;
+    if index + 1 >= segments.len() {
+        return None;
+    }
+    Some(segments[..=index].join("/"))
+}
+
+pub(super) fn is_package_manifest(path: &str) -> bool {
+    path.ends_with("Cargo.toml")
+        || path.ends_with("package.json")
+        || path.ends_with("Package.swift")
+}