@lamentis/naome 1.2.1 → 1.3.1

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

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