@lamentis/naome 1.3.13 → 1.3.15

package/Cargo.lock

@@ -76,7 +76,7 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "naome-cli"
-version = "1.3.13"
+version = "1.3.15"
 dependencies = [
  "naome-core",
  "serde_json",
@@ -84,7 +84,7 @@ dependencies = [
 
 [[package]]
 name = "naome-core"
-version = "1.3.13"
+version = "1.3.15"
 dependencies = [
  "serde",
  "serde_json",

package/crates/naome-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-cli"
-version = "1.3.13"
+version = "1.3.15"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

package/crates/naome-cli/src/architecture_commands.rs

@@ -53,7 +53,7 @@ fn run_arch_explain(root: &Path, args: &[String]) -> Result<(), Box<dyn std::err
                 "layers": scan.config.layers.keys().collect::<Vec<_>>(),
                 "contexts": scan.config.contexts.keys().collect::<Vec<_>>(),
                 "rules": ARCHITECTURE_RULE_IDS,
-                "extractors": ["path", "typescript", "javascript", "rust", "python", "go"]
+                "extractors": ["path", "typescript", "javascript", "rust", "python", "go", "swift"]
             }))?
         );
     } else {

package/crates/naome-cli/src/quality_commands.rs

@@ -1,10 +1,10 @@
 use std::path::Path;
 
 use naome_core::{
-    check_repository_quality, check_repository_quality_paths, check_semantic_legacy, check_semantic_legacy_paths,
-    clear_quality_cache, explain_repository_structure, init_repository_quality_with_mode,
-    plan_quality_cleanup, quality_cache_status, route_quality_cleanup, semantic_route_for_finding,
-    QualityInitMode, QualityMode,
+    check_repository_quality, check_repository_quality_paths, check_semantic_legacy,
+    check_semantic_legacy_paths, clear_quality_cache, explain_repository_structure,
+    init_repository_quality_with_mode, plan_quality_cleanup, quality_cache_status,
+    route_quality_cleanup, semantic_route_for_finding, QualityInitMode, QualityMode,
 };
 
 use crate::cli_args::option_value;

package/crates/naome-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-core"
-version = "1.3.13"
+version = "1.3.15"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

package/crates/naome-core/src/architecture/config/parser/sections.rs

@@ -5,7 +5,7 @@ use super::ConfigParser;
 use crate::architecture::config::{
     ContextConfig, ExternalDependencyPolicy, IgnoreRule, LayerConfig, RuleConfig,
 };
-use crate::architecture::output::Severity;
+use crate::architecture::model::Severity;
 
 pub(super) fn parse_layers(parser: &mut ConfigParser<'_>) -> Result<(), NaomeError> {
     while let Some((_, line)) = parser.peek_line() {

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

@@ -4,7 +4,7 @@ use std::path::Path;
 
 use crate::models::NaomeError;
 
-use super::output::Severity;
+use super::model::Severity;
 
 mod parser;
 

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

@@ -38,6 +38,25 @@ pub struct SourceRange {
     pub end_column: usize,
 }
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum Severity {
+    Error,
+    Warning,
+    Info,
+}
+
+impl Severity {
+    pub fn parse(value: &str) -> Option<Self> {
+        match value {
+            "error" => Some(Self::Error),
+            "warning" | "warn" => Some(Self::Warning),
+            "info" => Some(Self::Info),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ArchitectureMetadata {
     pub path: Option<String>,

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

@@ -1,16 +1,8 @@
 use serde::{Deserialize, Serialize};
 
-use super::model::SourceRange;
+use super::model::{Severity, SourceRange};
 use super::scan::ArchitectureScanReport;
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum Severity {
-    Error,
-    Warning,
-    Info,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct ViolationSummary {
@@ -54,6 +46,8 @@ pub struct ArchitectureValidation {
     pub rules_executed: Vec<String>,
     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 violations: Vec<ArchitectureViolation>,
     #[serde(rename = "agent_feedback")]
     pub agent_feedback: Vec<ArchitectureAgentFeedback>,
@@ -72,17 +66,6 @@ pub const ARCHITECTURE_RULE_IDS: &[&str] = &[
     "arch.external_dependency_policy",
 ];
 
-impl Severity {
-    pub fn parse(value: &str) -> Option<Self> {
-        match value {
-            "error" => Some(Self::Error),
-            "warning" | "warn" => Some(Self::Warning),
-            "info" => Some(Self::Info),
-            _ => None,
-        }
-    }
-}
-
 pub fn architecture_agent_feedback(
     violations: &[ArchitectureViolation],
 ) -> Vec<ArchitectureAgentFeedback> {
@@ -134,7 +117,15 @@ pub fn format_architecture_validation(report: &ArchitectureValidation) -> String
     ];
 
     if report.changed_only_degraded_to_full_scan {
-        lines.push("changed-only requested: degraded to full scan for soundness".to_string());
+        let reason = report
+            .changed_only_degradation_reason
+            .as_deref()
+            .unwrap_or("soundness");
+        lines.push(format!(
+            "changed-only requested: degraded to full scan for soundness ({reason})"
+        ));
+    } else if report.changed_only_requested {
+        lines.push("changed-only requested: using incremental architecture cache".to_string());
     }
 
     for violation in report.violations.iter().take(10) {
@@ -152,12 +143,24 @@ pub fn format_architecture_validation(report: &ArchitectureValidation) -> String
 }
 
 pub fn format_architecture_scan(report: &ArchitectureScanReport) -> String {
-    format!(
+    let mut output = format!(
         "NAOME architecture scan\nfiles scanned: {}\ngraph nodes: {}\ngraph edges: {}\n",
         report.files_scanned,
         report.graph.nodes.len(),
         report.graph.edges.len()
-    )
+    );
+    if report.changed_only_degraded_to_full_scan {
+        let reason = report
+            .changed_only_degradation_reason
+            .as_deref()
+            .unwrap_or("soundness");
+        output.push_str(&format!(
+            "changed-only requested: degraded to full scan for soundness ({reason})\n"
+        ));
+    } else if report.changed_only_requested {
+        output.push_str("changed-only requested: using incremental architecture cache\n");
+    }
+    output
 }
 
 pub fn format_architecture_explain(scan: &ArchitectureScanReport) -> String {
@@ -176,7 +179,7 @@ pub fn format_architecture_explain(scan: &ArchitectureScanReport) -> String {
         .collect::<Vec<_>>()
         .join(", ");
     format!(
-        "NAOME Architecture Fitness\nrules: {}\nlayers: {}\ncontexts: {}\npath extractor: enabled for every repository\nimport extractors: typescript, javascript, rust, python, go\n",
+        "NAOME Architecture Fitness\nrules: {}\nlayers: {}\ncontexts: {}\npath extractor: enabled for every repository\nimport extractors: typescript, javascript, rust, python, go, swift\n",
         ARCHITECTURE_RULE_IDS.join(", "),
         empty_label(&layers),
         empty_label(&contexts)

package/crates/naome-core/src/architecture/rules/budgets.rs

@@ -1,4 +1,5 @@
-use crate::architecture::output::{ArchitectureViolation, Severity};
+use crate::architecture::model::Severity;
+use crate::architecture::output::ArchitectureViolation;
 use crate::architecture::scan::{ArchitectureScanReport, FileFact, ImportTarget};
 
 pub(super) fn validate_file_size_budget(

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

@@ -1,8 +1,8 @@
 use crate::paths;
 
+use super::model::Severity;
 use super::output::{
     architecture_agent_feedback, summary_for, ArchitectureValidation, ArchitectureViolation,
-    Severity,
 };
 use super::scan::ArchitectureScanReport;
 use crate::architecture::model::ArchitectureEdgeKind;
@@ -55,6 +55,8 @@ pub fn validate_scan(scan: ArchitectureScanReport) -> ArchitectureValidation {
         rules_executed,
         changed_only_requested: scan.changed_only_requested,
         changed_only_degraded_to_full_scan: scan.changed_only_degraded_to_full_scan,
+        changed_only_mode: scan.changed_only_mode,
+        changed_only_degradation_reason: scan.changed_only_degradation_reason,
         violations,
         agent_feedback,
     }

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

@@ -0,0 +1,145 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::fs;
+use std::path::Path;
+
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+use super::FileFact;
+use crate::models::NaomeError;
+
+const CACHE_SCHEMA: &str = "naome.architecture-cache.v1";
+const EXTRACTOR_VERSION: &str = "architecture-cache-v1.3.14";
+const CACHE_PATH: &str = ".naome/cache/architecture/cache.json";
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct ArchitectureCache {
+    pub schema: String,
+    pub extractor_version: String,
+    pub config_hash: String,
+    pub file_list_hash: String,
+    pub files: BTreeMap<String, CachedFileFact>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct CachedFileFact {
+    pub content_hash: String,
+    pub fact: FileFact,
+}
+
+impl ArchitectureCache {
+    pub(super) fn is_compatible(&self, config_hash: &str, file_list_hash: &str) -> CacheStatus {
+        if self.schema != CACHE_SCHEMA || self.extractor_version != EXTRACTOR_VERSION {
+            return CacheStatus::Miss("cache_miss");
+        }
+        if self.config_hash != config_hash {
+            return CacheStatus::Miss("config_changed");
+        }
+        if self.file_list_hash != file_list_hash {
+            return CacheStatus::Miss("file_set_changed");
+        }
+        CacheStatus::Hit
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum CacheStatus {
+    Hit,
+    Miss(&'static str),
+}
+
+pub(super) fn read(root: &Path) -> Option<ArchitectureCache> {
+    let content = fs::read_to_string(root.join(CACHE_PATH)).ok()?;
+    serde_json::from_str(&content).ok()
+}
+
+pub(super) fn write(
+    root: &Path,
+    config_hash: String,
+    file_list_hash: String,
+    file_facts: &BTreeMap<String, FileFact>,
+) -> Result<(), NaomeError> {
+    let cache = ArchitectureCache {
+        schema: CACHE_SCHEMA.to_string(),
+        extractor_version: EXTRACTOR_VERSION.to_string(),
+        config_hash,
+        file_list_hash,
+        files: file_facts
+            .iter()
+            .filter_map(|(path, fact)| {
+                let content_hash = content_hash(root, path).ok()?;
+                Some((
+                    path.clone(),
+                    CachedFileFact {
+                        content_hash,
+                        fact: fact.clone(),
+                    },
+                ))
+            })
+            .collect(),
+    };
+    let path = root.join(CACHE_PATH);
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    fs::write(path, serde_json::to_string_pretty(&cache)?)?;
+    Ok(())
+}
+
+pub(super) fn config_hash(
+    root: &Path,
+    explicit_path: Option<&Path>,
+    default_content: &str,
+) -> Result<String, NaomeError> {
+    let path = explicit_path
+        .map(Path::to_path_buf)
+        .unwrap_or_else(|| root.join("naome.arch.yaml"));
+    let source = if path.exists() {
+        fs::read_to_string(&path)?
+    } else {
+        default_content.to_string()
+    };
+    let label = display_path(root, &path);
+    Ok(stable_hash([
+        b"architecture-config-v1".as_slice(),
+        label.as_bytes(),
+        source.as_bytes(),
+    ]))
+}
+
+pub(super) fn file_list_hash(files: &[String]) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(b"architecture-file-list-v1");
+    for path in files {
+        hasher.update([0]);
+        hasher.update(path.as_bytes());
+    }
+    format!("sha256:{:x}", hasher.finalize())
+}
+
+pub(super) fn content_hash(root: &Path, path: &str) -> Result<String, NaomeError> {
+    let bytes = fs::read(root.join(path))?;
+    Ok(stable_hash([b"architecture-file-v1".as_slice(), &bytes]))
+}
+
+pub(super) fn changed_set(changed_paths: &[String]) -> BTreeSet<String> {
+    changed_paths.iter().cloned().collect()
+}
+
+fn stable_hash<'a>(parts: impl IntoIterator<Item = &'a [u8]>) -> String {
+    let mut hasher = Sha256::new();
+    for part in parts {
+        hasher.update(part);
+        hasher.update([0]);
+    }
+    format!("sha256:{:x}", hasher.finalize())
+}
+
+fn display_path(root: &Path, path: &Path) -> String {
+    path.strip_prefix(root)
+        .unwrap_or(path)
+        .to_string_lossy()
+        .replace('\\', "/")
+}

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

@@ -18,25 +18,46 @@ pub(super) fn build_path_graph(
     config: &ArchitectureConfig,
     manifests: &[ManifestFact],
 ) -> (ArchitectureGraph, BTreeMap<String, FileFact>) {
-    let mut graph = ArchitectureGraph::default();
     let mut file_facts = BTreeMap::new();
-    let mut emitted_external_nodes = BTreeSet::new();
     let file_set = files.iter().cloned().collect::<BTreeSet<_>>();
+    for path in &files {
+        file_facts.insert(path.clone(), scan_file_fact(root, path, config, &file_set));
+    }
+    let graph = build_graph_from_facts(&files, &file_facts, config, manifests);
+    (graph, file_facts)
+}
+
+pub(super) fn scan_file_fact(
+    root: &Path,
+    path: &str,
+    config: &ArchitectureConfig,
+    file_set: &BTreeSet<String>,
+) -> FileFact {
+    let content = fs::read_to_string(root.join(path)).unwrap_or_default();
+    let mut fact = facts::file_fact(path, &content, config);
+    fact.imports = imports::extract_imports(root, path, &content, file_set);
+    fact
+}
+
+pub(super) fn build_graph_from_facts(
+    files: &[String],
+    file_facts: &BTreeMap<String, FileFact>,
+    config: &ArchitectureConfig,
+    manifests: &[ManifestFact],
+) -> ArchitectureGraph {
+    let mut graph = ArchitectureGraph::default();
+    let mut emitted_external_nodes = BTreeSet::new();
 
     push_repository_and_policy_nodes(&mut graph, config);
-    push_directories(&mut graph, &files);
+    push_directories(&mut graph, files);
     push_manifests(&mut graph, manifests, &mut emitted_external_nodes);
 
-    for path in files {
-        let content = fs::read_to_string(root.join(&path)).unwrap_or_default();
-        let mut fact = facts::file_fact(&path, &content, config);
-        fact.imports = imports::extract_imports(root, &path, &content, &file_set);
+    for fact in file_facts.values() {
         push_file(&mut graph, &fact);
-        file_facts.insert(path, fact);
     }
 
-    push_imports(&mut graph, &file_facts, &mut emitted_external_nodes);
-    (graph, file_facts)
+    push_imports(&mut graph, file_facts, &mut emitted_external_nodes);
+    graph
 }
 
 fn push_repository_and_policy_nodes(graph: &mut ArchitectureGraph, config: &ArchitectureConfig) {