@lamentis/naome 1.3.12 → 1.3.14

package/crates/naome-core/src/architecture/scan/manifest.rs

@@ -0,0 +1,33 @@
+use std::fs;
+use std::path::Path;
+
+use super::ManifestFact;
+
+mod common;
+mod parsers;
+
+use common::{manifest_kind, ManifestKind};
+
+pub(super) fn extract_manifests(root: &Path, files: &[String]) -> Vec<ManifestFact> {
+    let mut manifests = files
+        .iter()
+        .filter_map(|path| extract_manifest(root, path))
+        .collect::<Vec<_>>();
+    manifests.sort_by(|left, right| left.path.cmp(&right.path));
+    manifests
+}
+
+fn extract_manifest(root: &Path, path: &str) -> Option<ManifestFact> {
+    let kind = manifest_kind(path)?;
+    let content = fs::read_to_string(root.join(path)).ok()?;
+    match kind {
+        ManifestKind::PackageJson => parsers::json::package_json(path, &content),
+        ManifestKind::CargoToml => parsers::toml::cargo_toml(path, &content),
+        ManifestKind::PyprojectToml => parsers::toml::pyproject_toml(path, &content),
+        ManifestKind::GoMod => parsers::other::go_mod(path, &content),
+        ManifestKind::PomXml => parsers::other::pom_xml(path, &content),
+        ManifestKind::BuildGradle => parsers::other::build_gradle(path, &content),
+        ManifestKind::PackageSwift => parsers::other::package_swift(path, &content),
+        ManifestKind::XcodeProject => parsers::other::xcode_project(path, &content),
+    }
+}

package/crates/naome-core/src/architecture/scan.rs

@@ -1,16 +1,22 @@
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 use crate::git;
 use crate::models::NaomeError;
 
-use super::config::{read_architecture_config, ArchitectureConfig};
+use cache::CacheStatus;
+
+use super::config::{
+    default_architecture_config_text, read_architecture_config, ArchitectureConfig,
+};
 use super::model::ArchitectureGraph;
 
+mod cache;
 mod graph_builder;
 mod imports;
+mod manifest;
 mod path_scan;
 
 #[derive(Debug, Clone, Default)]
@@ -27,14 +33,18 @@ pub struct ArchitectureScanReport {
     pub files_scanned: usize,
     pub changed_only_requested: bool,
     pub changed_only_degraded_to_full_scan: bool,
+    pub changed_only_mode: String,
+    pub changed_only_degradation_reason: Option<String>,
     pub changed_paths: Vec<String>,
     #[serde(skip_serializing)]
     pub config: ArchitectureConfig,
     #[serde(skip_serializing)]
     pub file_facts: BTreeMap<String, FileFact>,
+    #[serde(skip_serializing)]
+    pub manifest_facts: Vec<ManifestFact>,
 }
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FileFact {
     pub path: String,
@@ -46,7 +56,7 @@ pub struct FileFact {
     pub imports: Vec<ImportFact>,
 }
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ImportFact {
     pub specifier: String,
@@ -56,7 +66,7 @@ pub struct ImportFact {
     pub extractor: String,
 }
 
-#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub enum ImportTarget {
     File(String),
@@ -64,6 +74,26 @@ pub enum ImportTarget {
     Unknown(String),
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ManifestFact {
+    pub path: String,
+    pub ecosystem: String,
+    pub package_name: String,
+    pub dependencies: Vec<ManifestDependency>,
+    pub confidence: f32,
+    pub extractor: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ManifestDependency {
+    pub name: String,
+    pub dependency_kind: String,
+    pub version: Option<String>,
+    pub confidence: f32,
+}
+
 pub fn scan_architecture(
     root: &Path,
     options: ArchitectureScanOptions,
@@ -71,21 +101,235 @@ pub fn scan_architecture(
     let config = read_architecture_config(root, options.config_path.as_deref())?;
     let changed_paths = changed_paths(root, options.changed_only)?;
     let files = path_scan::repository_files(root, &config)?;
-    let (mut graph, file_facts) = graph_builder::build_path_graph(root, files, &config);
+    let config_hash = cache::config_hash(
+        root,
+        options.config_path.as_deref(),
+        default_architecture_config_text(),
+    )?;
+    let file_list_hash = cache::file_list_hash(&files);
+    let manifest_facts = manifest::extract_manifests(root, &files);
+
+    let scan = if options.changed_only {
+        changed_only_scan(
+            root,
+            files,
+            &config,
+            &manifest_facts,
+            &changed_paths,
+            config_hash,
+            file_list_hash,
+        )?
+    } else {
+        full_scan(
+            root,
+            files,
+            &config,
+            &manifest_facts,
+            config_hash,
+            file_list_hash,
+            false,
+            None,
+            "full_scan",
+        )?
+    };
+
+    Ok(scan.with_changed_paths(changed_paths))
+}
+
+fn changed_only_scan(
+    root: &Path,
+    files: Vec<String>,
+    config: &ArchitectureConfig,
+    manifest_facts: &[ManifestFact],
+    changed_paths: &[String],
+    config_hash: String,
+    file_list_hash: String,
+) -> Result<ArchitectureScanReport, NaomeError> {
+    let Some(cache) = cache::read(root) else {
+        return degraded_full_scan(
+            root,
+            files,
+            config,
+            manifest_facts,
+            config_hash,
+            file_list_hash,
+            "cache_miss",
+        );
+    };
+    match cache.is_compatible(&config_hash, &file_list_hash) {
+        CacheStatus::Miss(reason) => degraded_full_scan(
+            root,
+            files,
+            config,
+            manifest_facts,
+            config_hash,
+            file_list_hash,
+            reason,
+        ),
+        CacheStatus::Hit => incremental_scan(
+            root,
+            files,
+            config,
+            manifest_facts,
+            changed_paths,
+            config_hash,
+            file_list_hash,
+            cache,
+        ),
+    }
+}
+
+fn incremental_scan(
+    root: &Path,
+    files: Vec<String>,
+    config: &ArchitectureConfig,
+    manifest_facts: &[ManifestFact],
+    changed_paths: &[String],
+    config_hash: String,
+    file_list_hash: String,
+    cache: cache::ArchitectureCache,
+) -> Result<ArchitectureScanReport, NaomeError> {
+    let file_set = files.iter().cloned().collect();
+    let changed = cache::changed_set(changed_paths);
+    if import_resolver_context_changed(changed_paths) {
+        return degraded_full_scan(
+            root,
+            files,
+            config,
+            manifest_facts,
+            config_hash,
+            file_list_hash,
+            "resolver_context_changed",
+        );
+    }
+    if cached_clean_content_changed(root, &files, &changed, &cache) {
+        return degraded_full_scan(
+            root,
+            files,
+            config,
+            manifest_facts,
+            config_hash,
+            file_list_hash,
+            "content_changed",
+        );
+    }
+    let mut file_facts = BTreeMap::new();
+    let mut scanned = 0;
+
+    for path in &files {
+        if changed.contains(path) || !cache.files.contains_key(path) {
+            let fact = graph_builder::scan_file_fact(root, path, config, &file_set);
+            scanned += 1;
+            file_facts.insert(path.clone(), fact);
+        } else if let Some(cached) = cache.files.get(path) {
+            file_facts.insert(path.clone(), cached.fact.clone());
+        }
+    }
 
+    let mut graph =
+        graph_builder::build_graph_from_facts(&files, &file_facts, config, manifest_facts);
     graph.sort_stable();
+    let _ = cache::write(root, config_hash, file_list_hash, &file_facts);
     Ok(ArchitectureScanReport {
         schema: "naome.arch.scan.v1".to_string(),
-        files_scanned: file_facts.len(),
+        files_scanned: scanned,
         graph,
-        changed_only_requested: options.changed_only,
-        changed_only_degraded_to_full_scan: options.changed_only,
-        changed_paths,
+        changed_only_requested: true,
+        changed_only_degraded_to_full_scan: false,
+        changed_only_mode: "incremental_cache".to_string(),
+        changed_only_degradation_reason: None,
+        changed_paths: Vec::new(),
+        config: config.clone(),
+        file_facts,
+        manifest_facts: manifest_facts.to_vec(),
+    })
+}
+
+fn cached_clean_content_changed(
+    root: &Path,
+    files: &[String],
+    changed: &std::collections::BTreeSet<String>,
+    cache: &cache::ArchitectureCache,
+) -> bool {
+    files.iter().any(|path| {
+        !changed.contains(path)
+            && cache.files.get(path).is_some_and(|cached| {
+                cache::content_hash(root, path)
+                    .map(|current| current != cached.content_hash)
+                    .unwrap_or(true)
+            })
+    })
+}
+
+fn import_resolver_context_changed(changed_paths: &[String]) -> bool {
+    changed_paths.iter().any(|path| {
+        Path::new(path)
+            .file_name()
+            .and_then(|value| value.to_str())
+            .is_some_and(|name| matches!(name, "go.mod" | "tsconfig.json" | "jsconfig.json"))
+    })
+}
+
+fn degraded_full_scan(
+    root: &Path,
+    files: Vec<String>,
+    config: &ArchitectureConfig,
+    manifest_facts: &[ManifestFact],
+    config_hash: String,
+    file_list_hash: String,
+    reason: &'static str,
+) -> Result<ArchitectureScanReport, NaomeError> {
+    full_scan(
+        root,
+        files,
         config,
+        manifest_facts,
+        config_hash,
+        file_list_hash,
+        true,
+        Some(reason),
+        "degraded_full_scan",
+    )
+}
+
+fn full_scan(
+    root: &Path,
+    files: Vec<String>,
+    config: &ArchitectureConfig,
+    manifest_facts: &[ManifestFact],
+    config_hash: String,
+    file_list_hash: String,
+    changed_only_degraded_to_full_scan: bool,
+    changed_only_degradation_reason: Option<&str>,
+    changed_only_mode: &str,
+) -> Result<ArchitectureScanReport, NaomeError> {
+    let (mut graph, file_facts) =
+        graph_builder::build_path_graph(root, files, config, manifest_facts);
+    graph.sort_stable();
+    let files_scanned = file_facts.len();
+    let _ = cache::write(root, config_hash, file_list_hash, &file_facts);
+    Ok(ArchitectureScanReport {
+        schema: "naome.arch.scan.v1".to_string(),
+        files_scanned,
+        graph,
+        changed_only_requested: changed_only_degraded_to_full_scan,
+        changed_only_degraded_to_full_scan,
+        changed_only_mode: changed_only_mode.to_string(),
+        changed_only_degradation_reason: changed_only_degradation_reason.map(str::to_string),
+        changed_paths: Vec::new(),
+        config: config.clone(),
         file_facts,
+        manifest_facts: manifest_facts.to_vec(),
     })
 }
 
+impl ArchitectureScanReport {
+    fn with_changed_paths(mut self, changed_paths: Vec<String>) -> Self {
+        self.changed_paths = changed_paths;
+        self
+    }
+}
+
 fn changed_paths(root: &Path, changed_only: bool) -> Result<Vec<String>, NaomeError> {
     if changed_only {
         git::changed_paths(root)

package/crates/naome-core/tests/architecture_cache.rs

@@ -0,0 +1,212 @@
+use naome_core::{validate_architecture, ArchitectureScanOptions};
+use std::path::Path;
+use std::process::Command;
+
+mod architecture_support;
+
+use architecture_support::FixtureRepo;
+
+#[test]
+fn changed_only_uses_incremental_cache_after_initial_safe_full_scan() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        forbidden_domain_to_infrastructure_config(),
+    );
+    repo.write("src/domain/event.ts", "export const event = 1;\n");
+    repo.write("src/infrastructure/db.ts", "export const db = 1;\n");
+    repo.init_git();
+
+    let initial = validate_architecture(repo.path(), changed_only()).unwrap();
+
+    assert!(initial.changed_only_requested);
+    assert!(initial.changed_only_degraded_to_full_scan);
+    assert_eq!(initial.changed_only_mode, "degraded_full_scan");
+    assert_eq!(
+        initial.changed_only_degradation_reason.as_deref(),
+        Some("cache_miss")
+    );
+
+    repo.write(
+        "src/domain/event.ts",
+        "import { db } from '../infrastructure/db';\nexport const event = db;\n",
+    );
+
+    let incremental = validate_architecture(repo.path(), changed_only()).unwrap();
+
+    assert!(incremental.changed_only_requested);
+    assert!(!incremental.changed_only_degraded_to_full_scan);
+    assert_eq!(incremental.changed_only_mode, "incremental_cache");
+    assert_eq!(incremental.changed_only_degradation_reason, None);
+    assert_eq!(incremental.files_scanned, 1);
+    assert_eq!(incremental.summary.errors, 1);
+    assert_eq!(
+        incremental.violations[0].path.as_deref(),
+        Some("src/domain/event.ts")
+    );
+}
+
+#[test]
+fn changed_only_degrades_when_architecture_config_changes() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        forbidden_domain_to_infrastructure_config(),
+    );
+    repo.write("src/domain/event.ts", "export const event = 1;\n");
+    repo.write("src/infrastructure/db.ts", "export const db = 1;\n");
+    repo.init_git();
+    validate_architecture(repo.path(), changed_only()).unwrap();
+
+    repo.write(
+        "naome.arch.yaml",
+        "layers:\n  application:\n    paths:\n      - \"src/**\"\n",
+    );
+
+    let report = validate_architecture(repo.path(), changed_only()).unwrap();
+
+    assert!(report.changed_only_degraded_to_full_scan);
+    assert_eq!(report.changed_only_mode, "degraded_full_scan");
+    assert_eq!(
+        report.changed_only_degradation_reason.as_deref(),
+        Some("config_changed")
+    );
+}
+
+#[test]
+fn changed_only_degrades_when_repository_file_set_changes() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        forbidden_domain_to_infrastructure_config(),
+    );
+    repo.write("src/domain/event.ts", "export const event = 1;\n");
+    repo.write("src/infrastructure/db.ts", "export const db = 1;\n");
+    repo.init_git();
+    validate_architecture(repo.path(), changed_only()).unwrap();
+
+    repo.write("src/domain/new.ts", "export const fresh = 1;\n");
+
+    let report = validate_architecture(repo.path(), changed_only()).unwrap();
+
+    assert!(report.changed_only_degraded_to_full_scan);
+    assert_eq!(report.changed_only_mode, "degraded_full_scan");
+    assert_eq!(
+        report.changed_only_degradation_reason.as_deref(),
+        Some("file_set_changed")
+    );
+}
+
+#[test]
+fn changed_only_degrades_when_cached_clean_file_content_changed() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        forbidden_domain_to_infrastructure_config(),
+    );
+    repo.write("src/domain/event.ts", "export const event = 1;\n");
+    repo.write("src/infrastructure/db.ts", "export const db = 1;\n");
+    repo.init_git();
+    validate_architecture(repo.path(), changed_only()).unwrap();
+
+    repo.write(
+        "src/domain/event.ts",
+        "import { db } from '../infrastructure/db';\nexport const event = db;\n",
+    );
+    commit_all(repo.path(), "content change after cache");
+
+    let report = validate_architecture(repo.path(), changed_only()).unwrap();
+
+    assert!(report.changed_only_requested);
+    assert!(report.changed_only_degraded_to_full_scan);
+    assert_eq!(report.changed_only_mode, "degraded_full_scan");
+    assert_eq!(
+        report.changed_only_degradation_reason.as_deref(),
+        Some("content_changed")
+    );
+    assert_eq!(report.summary.errors, 1);
+}
+
+#[test]
+fn changed_only_degrades_when_go_module_context_changes() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "naome.arch.yaml",
+        forbidden_domain_to_infrastructure_config(),
+    );
+    repo.write("go.mod", "module example.com/old\n\ngo 1.22\n");
+    repo.write(
+        "src/domain/event.go",
+        "package domain\n\nimport \"example.com/new/src/infrastructure/db\"\n\nvar Event = db.Value\n",
+    );
+    repo.write(
+        "src/infrastructure/db/db.go",
+        "package db\n\nvar Value = 1\n",
+    );
+    repo.init_git();
+    let initial = validate_architecture(repo.path(), changed_only()).unwrap();
+    assert_eq!(initial.summary.errors, 0);
+
+    repo.write("go.mod", "module example.com/new\n\ngo 1.22\n");
+
+    let report = validate_architecture(repo.path(), changed_only()).unwrap();
+
+    assert!(report.changed_only_requested);
+    assert!(report.changed_only_degraded_to_full_scan);
+    assert_eq!(report.changed_only_mode, "degraded_full_scan");
+    assert_eq!(
+        report.changed_only_degradation_reason.as_deref(),
+        Some("resolver_context_changed")
+    );
+    assert_eq!(report.summary.errors, 1);
+    assert_eq!(
+        report.violations[0].path.as_deref(),
+        Some("src/domain/event.go")
+    );
+}
+
+fn changed_only() -> ArchitectureScanOptions {
+    ArchitectureScanOptions {
+        changed_only: true,
+        ..ArchitectureScanOptions::default()
+    }
+}
+
+fn forbidden_domain_to_infrastructure_config() -> &'static str {
+    r#"layers:
+  domain:
+    paths:
+      - "src/domain/**"
+  infrastructure:
+    paths:
+      - "src/infrastructure/**"
+allowed_dependencies:
+  domain:
+  infrastructure:
+    - domain
+rules:
+  no_forbidden_layer_dependencies:
+    enabled: true
+    severity: error
+"#
+}
+
+fn commit_all(root: &Path, message: &str) {
+    run_git(root, &["add", "."]);
+    run_git(root, &["commit", "-m", message]);
+}
+
+fn run_git(root: &Path, args: &[&str]) {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(root)
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "git {:?} failed: {}{}",
+        args,
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+}