@lamentis/naome 1.2.1 → 1.3.1

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

@@ -0,0 +1,145 @@
+use super::path_scan::{evidence, has_any_suffix, has_path, has_suffix};
+use super::types::RepositoryWorldSignal;
+
+pub(super) fn detect_adapter_signals(paths: &[String]) -> Vec<RepositoryWorldSignal> {
+    let mut signals = adapter_specs(paths)
+        .into_iter()
+        .filter(|(_, detected, evidence)| *detected && !evidence.is_empty())
+        .map(|(id, _, evidence)| RepositoryWorldSignal {
+            id: id.to_string(),
+            value: id.to_string(),
+            confidence: "high".to_string(),
+            source: "deterministic-scan".to_string(),
+            evidence,
+        })
+        .collect::<Vec<_>>();
+    signals.sort_by(|left, right| left.id.cmp(&right.id));
+    signals
+}
+
+fn adapter_specs(paths: &[String]) -> Vec<(&'static str, bool, Vec<String>)> {
+    vec![
+        (
+            "rust",
+            detects_rust(paths),
+            evidence(paths, &["Cargo.toml", ".rs"]),
+        ),
+        (
+            "javascript-typescript",
+            detects_javascript_typescript(paths),
+            evidence(paths, &["package.json", ".js", ".ts", ".tsx", ".jsx"]),
+        ),
+        (
+            "swift",
+            detects_swift(paths),
+            evidence(paths, &["Package.swift", ".swift"]),
+        ),
+        (
+            "xcode",
+            paths
+                .iter()
+                .any(|path| path.contains(".xcodeproj/") || path.contains(".xcworkspace/")),
+            evidence(paths, &[".xcodeproj/", ".xcworkspace/"]),
+        ),
+        (
+            "xctest",
+            detects_xctest(paths),
+            evidence(paths, &["Tests", ".swift"]),
+        ),
+        (
+            "swiftui",
+            detects_swiftui(paths),
+            evidence(paths, &["View.swift", "App.swift"]),
+        ),
+        (
+            "ios-app-structure",
+            detects_ios_app(paths),
+            evidence(paths, &["Info.plist", ".xcassets/"]),
+        ),
+        (
+            "swift-package",
+            detects_swift_package(paths),
+            evidence(paths, &["Package.swift", "Sources/"]),
+        ),
+        (
+            "ios-resources",
+            detects_ios_resources(paths),
+            evidence(paths, &[".strings", ".plist", ".xib"]),
+        ),
+        (
+            "generated-ios",
+            detects_generated_ios(paths),
+            evidence(paths, &["Generated/", ".generated.swift"]),
+        ),
+    ]
+}
+
+fn detects_rust(paths: &[String]) -> bool {
+    has_path(paths, "Cargo.toml") || has_suffix(paths, ".rs")
+}
+
+fn detects_javascript_typescript(paths: &[String]) -> bool {
+    has_path(paths, "package.json") || has_any_suffix(paths, &[".js", ".jsx", ".ts", ".tsx"])
+}
+
+fn detects_swift(paths: &[String]) -> bool {
+    has_path(paths, "Package.swift") || has_suffix(paths, ".swift")
+}
+
+fn detects_xctest(paths: &[String]) -> bool {
+    paths.iter().any(|path| {
+        let lower = path.to_ascii_lowercase();
+        lower.contains("/tests/") && lower.ends_with("tests.swift")
+    })
+}
+
+fn detects_swiftui(paths: &[String]) -> bool {
+    paths.iter().any(|path| {
+        let lower = path.to_ascii_lowercase();
+        lower.ends_with("view.swift")
+            || lower.ends_with("app.swift")
+            || lower.contains("preview content/")
+    })
+}
+
+fn detects_ios_app(paths: &[String]) -> bool {
+    paths.iter().any(|path| {
+        let lower = path.to_ascii_lowercase();
+        lower.ends_with("info.plist")
+            || lower.ends_with(".entitlements")
+            || lower.contains(".xcassets/")
+    })
+}
+
+fn detects_swift_package(paths: &[String]) -> bool {
+    has_path(paths, "Package.swift")
+        || paths
+            .iter()
+            .any(|path| path.starts_with("Sources/") || path.contains("/Sources/"))
+}
+
+fn detects_ios_resources(paths: &[String]) -> bool {
+    paths.iter().any(|path| {
+        has_any_suffix(
+            &[path.clone()],
+            &[
+                ".strings",
+                ".stringsdict",
+                ".plist",
+                ".entitlements",
+                ".storyboard",
+                ".xib",
+            ],
+        ) || path.to_ascii_lowercase().contains(".xcassets/")
+    })
+}
+
+fn detects_generated_ios(paths: &[String]) -> bool {
+    paths.iter().any(|path| {
+        let lower = path.to_ascii_lowercase();
+        lower.contains("/generated/")
+            || lower.contains("/swiftgen/")
+            || lower.contains("/sourcery/")
+            || lower.ends_with(".generated.swift")
+    })
+}

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

@@ -0,0 +1,55 @@
+use super::path_support::{
+    entity_for_path, is_package_manifest, language_for_path, module_for_path,
+};
+use super::types::{RepositoryEntity, RepositoryPathFact, RepositoryRoot};
+
+pub(super) fn detect_path_facts(
+    paths: &[String],
+    roots: &[RepositoryRoot],
+    entities: &[RepositoryEntity],
+) -> Vec<RepositoryPathFact> {
+    let mut facts = paths
+        .iter()
+        .filter(|path| is_model_evidence_path(path))
+        .map(|path| RepositoryPathFact {
+            path: path.clone(),
+            role: role_for_path(path, roots).unwrap_or_else(|| "unknown".to_string()),
+            module: module_for_path(path, roots),
+            entity: entity_for_path(path, entities),
+            language: language_for_path(path),
+            flags: flags_for_path(path),
+        })
+        .collect::<Vec<_>>();
+    facts.sort_by(|left, right| left.path.cmp(&right.path));
+    facts.dedup_by(|left, right| left.path == right.path);
+    facts
+}
+
+fn is_model_evidence_path(path: &str) -> bool {
+    is_package_manifest(path)
+        || path.ends_with(".xcodeproj/project.pbxproj")
+        || path.ends_with("App.swift")
+        || path.ends_with("Info.plist")
+        || path.ends_with(".entitlements")
+        || path.ends_with(".xcassets/Contents.json")
+}
+
+fn role_for_path(path: &str, roots: &[RepositoryRoot]) -> Option<String> {
+    roots
+        .iter()
+        .filter(|root| path == root.path || path.starts_with(&format!("{}/", root.path)))
+        .max_by_key(|root| root.path.len())
+        .map(|root| root.role.clone())
+}
+
+fn flags_for_path(path: &str) -> Vec<String> {
+    let lower = path.to_ascii_lowercase();
+    let mut flags = Vec::new();
+    if lower.contains("/generated/") || lower.ends_with(".generated.swift") {
+        flags.push("generated".to_string());
+    }
+    if lower.contains("/build/") || lower.contains("/dist/") || lower.contains("/deriveddata/") {
+        flags.push("artifact".to_string());
+    }
+    flags
+}

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

@@ -0,0 +1,168 @@
+use super::path_support::{is_package_manifest, language_for_path, parent_path, root_at_segment};
+use super::types::{RepositoryEntity, RepositoryRoot};
+
+pub(super) fn detect_roots(paths: &[String]) -> Vec<RepositoryRoot> {
+    let mut roots = Vec::new();
+    for path in paths {
+        for (role, root) in root_candidates(path) {
+            push_root(&mut roots, role, &root);
+        }
+    }
+    for (role, defaults) in default_roots() {
+        for root in defaults {
+            if paths
+                .iter()
+                .any(|path| path == *root || path.starts_with(&format!("{root}/")))
+            {
+                push_root(&mut roots, role, root);
+            }
+        }
+    }
+    roots.sort_by(|left, right| left.id.cmp(&right.id));
+    roots.dedup_by(|left, right| left.id == right.id);
+    roots
+}
+
+pub(super) fn detect_entities(paths: &[String]) -> Vec<RepositoryEntity> {
+    let mut entities = Vec::new();
+    for path in paths {
+        if is_package_manifest(path) {
+            push_entity(&mut entities, "package", &parent_path(path), path, paths);
+        }
+        if path.ends_with(".xcodeproj/project.pbxproj") {
+            push_entity(
+                &mut entities,
+                "app",
+                path.trim_end_matches("/project.pbxproj"),
+                path,
+                paths,
+            );
+        }
+        if path.ends_with("App.swift") {
+            push_entity(&mut entities, "app", &parent_path(path), path, paths);
+        }
+    }
+    entities.sort_by(|left, right| left.id.cmp(&right.id));
+    entities.dedup_by(|left, right| left.id == right.id);
+    entities
+}
+
+fn root_candidates(path: &str) -> Vec<(&'static str, String)> {
+    [
+        (
+            "source",
+            root_at_segment(path, &["src", "Sources", "Source", "app"]),
+        ),
+        (
+            "test",
+            root_at_segment(path, &["test", "tests", "Tests", "__tests__"]),
+        ),
+        ("docs", root_at_segment(path, &["docs"])),
+        (
+            "generated",
+            root_at_segment(path, &["generated", "Generated"]),
+        ),
+        (
+            "artifact",
+            root_at_segment(path, &["dist", "build", "DerivedData"]),
+        ),
+    ]
+    .into_iter()
+    .filter_map(|(role, root)| root.map(|root| (role, root)))
+    .collect()
+}
+
+fn default_roots() -> [(&'static str, &'static [&'static str]); 5] {
+    [
+        ("source", &["src", "Sources", "app", "packages"]),
+        ("test", &["test", "tests", "Tests", "__tests__"]),
+        ("docs", &["docs"]),
+        ("generated", &["generated", "Generated"]),
+        ("artifact", &["dist", "build", "DerivedData"]),
+    ]
+}
+
+fn push_root(roots: &mut Vec<RepositoryRoot>, role: &str, path: &str) {
+    let normalized = path.trim_end_matches('/').to_string();
+    roots.push(RepositoryRoot {
+        id: format!("{role}:{normalized}"),
+        role: role.to_string(),
+        path: normalized.clone(),
+        source: "deterministic-scan".to_string(),
+        evidence: vec![normalized],
+    });
+}
+
+fn push_entity(
+    entities: &mut Vec<RepositoryEntity>,
+    kind: &str,
+    path: &str,
+    evidence_path: &str,
+    all_paths: &[String],
+) {
+    let normalized = if path.is_empty() { "." } else { path };
+    let entity_paths = all_paths
+        .iter()
+        .filter(|candidate| normalized == "." || candidate.starts_with(&format!("{normalized}/")))
+        .cloned()
+        .collect::<Vec<_>>();
+    entities.push(RepositoryEntity {
+        id: format!("{kind}:{normalized}"),
+        kind: kind.to_string(),
+        name: entity_name(normalized),
+        path: normalized.to_string(),
+        languages: entity_languages(&entity_paths),
+        roots: entity_roots(normalized, &entity_paths),
+        source: "deterministic-scan".to_string(),
+        evidence: vec![evidence_path.to_string()],
+    });
+}
+
+fn entity_name(path: &str) -> String {
+    path.rsplit('/')
+        .next()
+        .filter(|name| !name.is_empty())
+        .unwrap_or("root")
+        .to_string()
+}
+
+fn entity_languages(paths: &[String]) -> Vec<String> {
+    let mut languages = paths
+        .iter()
+        .filter_map(|path| language_for_path(path))
+        .collect::<Vec<_>>();
+    languages.sort();
+    languages.dedup();
+    languages
+}
+
+fn entity_roots(entity_path: &str, paths: &[String]) -> Vec<String> {
+    let mut roots = paths
+        .iter()
+        .filter_map(|path| entity_root_path(entity_path, path))
+        .collect::<Vec<_>>();
+    roots.sort();
+    roots.dedup();
+    roots
+}
+
+fn entity_root_path(entity_path: &str, path: &str) -> Option<String> {
+    let relative = if entity_path == "." {
+        path
+    } else {
+        path.strip_prefix(&format!("{entity_path}/"))?
+    };
+    let first = relative.split('/').next()?;
+    if matches!(
+        first,
+        "src" | "Sources" | "test" | "tests" | "Tests" | "Resources"
+    ) {
+        Some(if entity_path == "." {
+            first.to_string()
+        } else {
+            format!("{entity_path}/{first}")
+        })
+    } else {
+        None
+    }
+}

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

@@ -0,0 +1,164 @@
+mod detect;
+mod explain;
+mod path_scan;
+mod path_support;
+mod types;
+mod world;
+mod world_adapters;
+mod world_path_facts;
+mod world_paths;
+
+use std::fs;
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use detect::detect_repository_model;
+use explain::explain_path;
+pub use types::{
+    RepositoryEntity, RepositoryFact, RepositoryModel, RepositoryModelDrift,
+    RepositoryModelRefresh, RepositoryPathExplanation, RepositoryPathFact, RepositoryRoot,
+    RepositoryVerificationCheck, RepositoryWorldSignal,
+};
+
+const MODEL_PATH: &str = ".naome/repository-model.json";
+
+pub fn refresh_repository_model(
+    root: &Path,
+    write: bool,
+) -> Result<RepositoryModelRefresh, NaomeError> {
+    let model = detect_repository_model(root)?;
+    let existing = read_existing_model(root)?;
+    let stale = existing.as_ref() != Some(&model);
+    let canonical_drift = write && !model_file_matches(root, &model)?;
+    let mut updated_paths = Vec::new();
+
+    if write && (stale || canonical_drift) {
+        write_model(root, &model)?;
+        updated_paths.push(MODEL_PATH.to_string());
+    }
+
+    let stale_after_write = stale && !write;
+    Ok(RepositoryModelRefresh {
+        schema: "naome.repository-model-refresh.v1".to_string(),
+        ok: !stale_after_write,
+        stale: stale_after_write,
+        write,
+        model_path: MODEL_PATH.to_string(),
+        updated_paths,
+        reason_codes: if stale {
+            vec!["repository_model_stale".to_string()]
+        } else {
+            Vec::new()
+        },
+        model,
+    })
+}
+
+pub fn explain_repository_model_path(
+    root: &Path,
+    path: impl AsRef<str>,
+) -> Result<RepositoryPathExplanation, NaomeError> {
+    let model = read_existing_model(root)?.unwrap_or(detect_repository_model(root)?);
+    Ok(explain_path(&model, path.as_ref()))
+}
+
+pub fn repository_model_drift(root: &Path) -> Result<RepositoryModelDrift, NaomeError> {
+    let path = root.join(MODEL_PATH);
+    let model_present = path.is_file();
+    if !model_present {
+        return Ok(RepositoryModelDrift {
+            schema: "naome.repository-model-drift.v1".to_string(),
+            ok: true,
+            model_present,
+            stale: false,
+            model_path: MODEL_PATH.to_string(),
+            reason_codes: Vec::new(),
+            related_paths: Vec::new(),
+            messages: Vec::new(),
+        });
+    }
+
+    let existing = read_existing_model(root)?.unwrap_or_default();
+    let current = detect_repository_model(root)?;
+    let stale = existing != current;
+    let related_paths = if stale {
+        model_evidence_paths(&current)
+    } else {
+        Vec::new()
+    };
+    let messages = if stale {
+        vec![format!(
+            "NAOME repository model is stale; run naome repo model --write to refresh deterministic repository facts in {MODEL_PATH}."
+        )]
+    } else {
+        Vec::new()
+    };
+
+    Ok(RepositoryModelDrift {
+        schema: "naome.repository-model-drift.v1".to_string(),
+        ok: !stale,
+        model_present,
+        stale,
+        model_path: MODEL_PATH.to_string(),
+        reason_codes: if stale {
+            vec!["repository_model_stale".to_string()]
+        } else {
+            Vec::new()
+        },
+        related_paths,
+        messages,
+    })
+}
+
+fn read_existing_model(root: &Path) -> Result<Option<RepositoryModel>, NaomeError> {
+    let path = root.join(MODEL_PATH);
+    if !path.is_file() {
+        return Ok(None);
+    }
+    Ok(Some(serde_json::from_str(&fs::read_to_string(path)?)?))
+}
+
+fn model_evidence_paths(model: &RepositoryModel) -> Vec<String> {
+    let mut paths = model
+        .facts
+        .iter()
+        .flat_map(|fact| fact.evidence.iter())
+        .chain(model.roots.iter().flat_map(|root| root.evidence.iter()))
+        .chain(model.entities.iter().flat_map(|entity| entity.evidence.iter()))
+        .chain(model.path_facts.iter().map(|fact| &fact.path))
+        .chain(
+            model
+                .verification_checks
+                .iter()
+                .flat_map(|check| check.evidence.iter()),
+        )
+        .filter(|path| path.as_str() != ".naome/verification.json")
+        .cloned()
+        .collect::<std::collections::BTreeSet<_>>()
+        .into_iter()
+        .collect::<Vec<_>>();
+    paths.sort();
+    paths
+}
+
+fn write_model(root: &Path, model: &RepositoryModel) -> Result<(), NaomeError> {
+    let path = root.join(MODEL_PATH);
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    fs::write(path, model_content(model)?)?;
+    Ok(())
+}
+
+fn model_file_matches(root: &Path, model: &RepositoryModel) -> Result<bool, NaomeError> {
+    let path = root.join(MODEL_PATH);
+    if !path.is_file() {
+        return Ok(false);
+    }
+    Ok(fs::read_to_string(path)? == model_content(model)?)
+}
+
+fn model_content(model: &RepositoryModel) -> Result<String, NaomeError> {
+    Ok(format!("{}\n", serde_json::to_string(model)?))
+}

package/crates/naome-core/src/route/builtin_checks.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use crate::harness_health::{validate_harness_health, HarnessHealthOptions};
 use crate::models::NaomeError;
-use crate::quality::{check_repository_quality, QualityMode};
+use crate::quality::{check_repository_quality, check_semantic_legacy, QualityMode};
 use crate::route::git_ops::{command_output, git_output};
 use crate::route::quality_gate::QualityCheck;
 use crate::task_state::{validate_task_state, TaskStateMode, TaskStateOptions};
@@ -18,16 +18,6 @@ pub(super) fn run_quality_check(
     check: &QualityCheck,
 ) -> Result<(), NaomeError> {
     match check_id {
-        "installer-tests" => require_builtin_quality_check(
-            check_id,
-            check,
-            "npm run test:naome-installer",
-        ),
-        "rust-build" => require_builtin_quality_check(check_id, check, "npm run build:rust"),
-        "decision-engine-tests" => {
-            require_builtin_quality_check(check_id, check, "npm run test:decision-engine")
-        }
-        "package-dry-run" => require_builtin_quality_check(check_id, check, "npm run pack:dry-run"),
         "diff-check" => {
             require_builtin_quality_check(check_id, check, "git diff --check")?;
             let output = git_output(root, &["diff", "--check"])?;
@@ -46,10 +36,6 @@ pub(super) fn run_quality_check(
             )?;
             run_harness_health_check(root)
         }
-        "dogfood-health" => {
-            require_builtin_quality_check(check_id, check, "npm run dogfood:health")?;
-            run_harness_health_check(root)
-        }
         "task-state-check" => {
             require_builtin_quality_check(check_id, check, "npm run check:task-state")?;
             run_template_task_state_check(root)
@@ -78,14 +64,53 @@ pub(super) fn run_quality_check(
             )?;
             run_repository_quality_check(root)
         }
+        "repository-semantic-check" => {
+            require_builtin_quality_check_any(
+                check_id,
+                check,
+                &[
+                    "naome semantic check --changed",
+                    "node .naome/bin/naome.js semantic check --changed",
+                    "npm run check:repository-semantic",
+                ],
+            )?;
+            run_repository_semantic_check(root)
+        }
         _ => Err(NaomeError::new(format!(
             "Quality check {check_id} is not a built-in safe check; NAOME will not execute repository-controlled verification commands."
         ))),
     }
 }
 
+fn run_repository_semantic_check(root: &Path) -> Result<(), NaomeError> {
+    let report = check_semantic_legacy(root, QualityMode::ChangedFast)?;
+    if report.ok {
+        return Ok(());
+    }
+
+    let details = report
+        .findings
+        .iter()
+        .take(20)
+        .flat_map(|finding| {
+            finding.occurrences.iter().take(1).map(move |occurrence| {
+                format!(
+                    "{}:{} semantic-{}: {}",
+                    occurrence.path, occurrence.start_line, finding.kind, finding.summary
+                )
+            })
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    Err(NaomeError::new(format!(
+        "repository-semantic-check failed with {} finding(s).\n{}",
+        report.findings.len(),
+        details
+    )))
+}
+
 fn run_repository_quality_check(root: &Path) -> Result<(), NaomeError> {
-    let report = check_repository_quality(root, QualityMode::Changed)?;
+    let report = check_repository_quality(root, QualityMode::ChangedFast)?;
     if report.ok {
         return Ok(());
     }