@lamentis/naome 1.3.0 → 1.3.2

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

@@ -0,0 +1,152 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryModel {
+    pub schema: String,
+    pub version: u32,
+    pub status: String,
+    pub facts: Vec<RepositoryFact>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub languages: Vec<RepositoryWorldSignal>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub package_managers: Vec<RepositoryWorldSignal>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub build_systems: Vec<RepositoryWorldSignal>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub adapters: Vec<RepositoryWorldSignal>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub roots: Vec<RepositoryRoot>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub entities: Vec<RepositoryEntity>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub path_facts: Vec<RepositoryPathFact>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub verification_checks: Vec<RepositoryVerificationCheck>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryFact {
+    pub id: String,
+    pub category: String,
+    pub value: String,
+    pub confidence: String,
+    pub source: String,
+    pub evidence: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryWorldSignal {
+    pub id: String,
+    pub value: String,
+    pub confidence: String,
+    pub source: String,
+    pub evidence: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryRoot {
+    pub id: String,
+    pub role: String,
+    pub path: String,
+    pub source: String,
+    pub evidence: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryEntity {
+    pub id: String,
+    pub kind: String,
+    pub name: String,
+    pub path: String,
+    pub languages: Vec<String>,
+    pub roots: Vec<String>,
+    pub source: String,
+    pub evidence: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryPathFact {
+    pub path: String,
+    pub role: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub module: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub entity: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub flags: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryVerificationCheck {
+    pub id: String,
+    pub command: String,
+    pub cwd: String,
+    pub evidence: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryModelRefresh {
+    pub schema: String,
+    pub ok: bool,
+    pub stale: bool,
+    pub write: bool,
+    pub model_path: String,
+    pub updated_paths: Vec<String>,
+    pub reason_codes: Vec<String>,
+    pub model: RepositoryModel,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryModelDrift {
+    pub schema: String,
+    pub ok: bool,
+    pub model_present: bool,
+    pub stale: bool,
+    pub model_path: String,
+    pub reason_codes: Vec<String>,
+    pub related_paths: Vec<String>,
+    pub messages: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryPathExplanation {
+    pub schema: String,
+    pub path: String,
+    pub role: Option<String>,
+    pub language: Option<String>,
+    pub module: Option<String>,
+    pub entity: Option<String>,
+    pub facts: Vec<RepositoryFact>,
+    pub evidence: Vec<String>,
+}
+
+impl Default for RepositoryModel {
+    fn default() -> Self {
+        Self {
+            schema: "naome.repository-model.v1".to_string(),
+            version: 1,
+            status: "ready".to_string(),
+            facts: Vec::new(),
+            languages: Vec::new(),
+            package_managers: Vec::new(),
+            build_systems: Vec::new(),
+            adapters: Vec::new(),
+            roots: Vec::new(),
+            entities: Vec::new(),
+            path_facts: Vec::new(),
+            verification_checks: Vec::new(),
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+use super::types::{
+    RepositoryEntity, RepositoryFact, RepositoryPathFact, RepositoryRoot, RepositoryWorldSignal,
+};
+use super::world_adapters::detect_adapter_signals;
+use super::world_path_facts::detect_path_facts;
+use super::world_paths::{detect_entities, detect_roots};
+
+pub(super) struct RepositoryWorldSections {
+    pub languages: Vec<RepositoryWorldSignal>,
+    pub package_managers: Vec<RepositoryWorldSignal>,
+    pub build_systems: Vec<RepositoryWorldSignal>,
+    pub adapters: Vec<RepositoryWorldSignal>,
+    pub roots: Vec<RepositoryRoot>,
+    pub entities: Vec<RepositoryEntity>,
+    pub path_facts: Vec<RepositoryPathFact>,
+}
+
+pub(super) fn build_world_sections(
+    paths: &[String],
+    facts: &[RepositoryFact],
+) -> RepositoryWorldSections {
+    let roots = detect_roots(paths);
+    let entities = detect_entities(paths);
+    let path_facts = detect_path_facts(paths, &roots, &entities);
+    RepositoryWorldSections {
+        languages: signals_from_facts(facts, "language"),
+        package_managers: signals_from_facts(facts, "packageManager"),
+        build_systems: signals_from_facts(facts, "buildSystem"),
+        adapters: detect_adapter_signals(paths),
+        roots,
+        entities,
+        path_facts,
+    }
+}
+
+fn signals_from_facts(facts: &[RepositoryFact], category: &str) -> Vec<RepositoryWorldSignal> {
+    facts
+        .iter()
+        .filter(|fact| fact.category == category)
+        .map(|fact| RepositoryWorldSignal {
+            id: fact.value.clone(),
+            value: fact.value.clone(),
+            confidence: fact.confidence.clone(),
+            source: fact.source.clone(),
+            evidence: fact.evidence.clone(),
+        })
+        .collect()
+}

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
+    }
+}