@lamentis/naome 1.3.10 → 1.3.11

package/Cargo.lock

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

package/README.md

@@ -88,6 +88,11 @@ naome task render-state --write --json
 naome commit -m "type(scope): summary"
 ```
 
+Architecture fitness builds a language-agnostic graph, extracts direct imports
+for TypeScript, JavaScript, Rust, Python, and Go, and can enforce configured
+layer dependency rules such as keeping domain code independent from
+infrastructure adapters.
+
 `naome sync` installs or repairs the local harness files. It does not run a
 hidden full-repository quality scan. It also migrates any active legacy
 task-state into the local task ledger automatically and untracks local

package/crates/naome-cli/Cargo.toml

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

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

@@ -52,8 +52,12 @@ fn run_arch_explain(root: &Path, args: &[String]) -> Result<(), Box<dyn std::err
                 "schema": "naome.arch.explain.v1",
                 "layers": scan.config.layers.keys().collect::<Vec<_>>(),
                 "contexts": scan.config.contexts.keys().collect::<Vec<_>>(),
-                "rules": ["arch.max_file_lines", "arch.generated_manual_boundary"],
-                "extractors": ["path"]
+                "rules": [
+                    "arch.max_file_lines",
+                    "arch.generated_manual_boundary",
+                    "arch.no_forbidden_layer_dependencies"
+                ],
+                "extractors": ["path", "typescript", "javascript", "rust", "python", "go"]
             }))?
         );
     } else {

package/crates/naome-core/Cargo.toml

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

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

@@ -36,6 +36,23 @@ pub(super) fn parse_contexts(parser: &mut ConfigParser<'_>) -> Result<(), NaomeE
     Ok(())
 }
 
+pub(super) fn parse_allowed_dependencies(parser: &mut ConfigParser<'_>) -> Result<(), NaomeError> {
+    while let Some((_, line)) = parser.peek_line() {
+        if indent(line) == 0 {
+            break;
+        }
+        let (line_number, line) = parser.next_line().unwrap();
+        let name = section_name(line, 2)
+            .ok_or_else(|| parser.error(line_number, "expected dependency source".to_string()))?;
+        let dependencies = parser.parse_list(4)?;
+        parser
+            .config
+            .allowed_dependencies
+            .insert(name.to_string(), dependencies);
+    }
+    Ok(())
+}
+
 fn parse_context(parser: &mut ConfigParser<'_>) -> Result<ContextConfig, NaomeError> {
     let mut context = ContextConfig::default();
     while let Some((_, child)) = parser.peek_line() {

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

@@ -40,6 +40,7 @@ impl<'a> ConfigParser<'a> {
             match line.trim() {
                 "layers:" => sections::parse_layers(self)?,
                 "contexts:" => sections::parse_contexts(self)?,
+                "allowed_dependencies:" => sections::parse_allowed_dependencies(self)?,
                 "rules:" => sections::parse_rules(self)?,
                 "ignore:" => sections::parse_ignore(self)?,
                 other => {

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

@@ -12,6 +12,7 @@ mod parser;
 pub struct ArchitectureConfig {
     pub layers: BTreeMap<String, LayerConfig>,
     pub contexts: BTreeMap<String, ContextConfig>,
+    pub allowed_dependencies: BTreeMap<String, Vec<String>>,
     pub rules: BTreeMap<String, RuleConfig>,
     pub ignore: Vec<IgnoreRule>,
 }
@@ -77,6 +78,14 @@ layers:
     paths:
       - "src/infrastructure/**"
 
+allowed_dependencies:
+  application:
+    - domain
+    - infrastructure
+  domain:
+  infrastructure:
+    - domain
+
 contexts:
   default:
     paths:
@@ -92,6 +101,9 @@ rules:
   generated_manual_boundary:
     enabled: true
     severity: error
+  no_forbidden_layer_dependencies:
+    enabled: true
+    severity: error
 
 ignore:
   - path: "generated/**"

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

@@ -163,7 +163,7 @@ pub fn format_architecture_explain(scan: &ArchitectureScanReport) -> String {
         .collect::<Vec<_>>()
         .join(", ");
     format!(
-        "NAOME Architecture Fitness\nrules: max_file_lines, generated_manual_boundary\nlayers: {}\ncontexts: {}\npath extractor: enabled for every repository\n",
+        "NAOME Architecture Fitness\nrules: max_file_lines, generated_manual_boundary, no_forbidden_layer_dependencies\nlayers: {}\ncontexts: {}\npath extractor: enabled for every repository\nimport extractors: typescript, javascript, rust, python, go\n",
         empty_label(&layers),
         empty_label(&contexts)
     )

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

@@ -5,6 +5,7 @@ use super::output::{
     Severity,
 };
 use super::scan::ArchitectureScanReport;
+use crate::architecture::model::ArchitectureEdgeKind;
 
 pub fn validate_scan(scan: ArchitectureScanReport) -> ArchitectureValidation {
     let mut violations = Vec::new();
@@ -12,6 +13,7 @@ pub fn validate_scan(scan: ArchitectureScanReport) -> ArchitectureValidation {
 
     validate_max_file_lines(&scan, &mut violations, &mut rules_executed);
     validate_generated_manual_boundary(&scan, &mut violations, &mut rules_executed);
+    validate_forbidden_layer_dependencies(&scan, &mut violations, &mut rules_executed);
 
     violations.sort_by(|left, right| {
         (
@@ -46,6 +48,76 @@ pub fn validate_scan(scan: ArchitectureScanReport) -> ArchitectureValidation {
     }
 }
 
+fn validate_forbidden_layer_dependencies(
+    scan: &ArchitectureScanReport,
+    violations: &mut Vec<ArchitectureViolation>,
+    rules_executed: &mut Vec<String>,
+) {
+    let rule = scan.config.rule("no_forbidden_layer_dependencies");
+    if !rule.enabled {
+        return;
+    }
+    rules_executed.push("arch.no_forbidden_layer_dependencies".to_string());
+    for edge in &scan.graph.edges {
+        if edge.kind != ArchitectureEdgeKind::Imports {
+            continue;
+        }
+        let Some(from_path) = edge.from.strip_prefix("file:") else {
+            continue;
+        };
+        let Some(to_path) = edge.to.strip_prefix("file:") else {
+            continue;
+        };
+        let Some(from_fact) = scan.file_facts.get(from_path) else {
+            continue;
+        };
+        let Some(to_fact) = scan.file_facts.get(to_path) else {
+            continue;
+        };
+        if to_fact.layers.is_empty() {
+            continue;
+        }
+        for from_layer in &from_fact.layers {
+            let allowed_layers = scan
+                .config
+                .allowed_dependencies
+                .get(from_layer)
+                .map(Vec::as_slice)
+                .unwrap_or(&[]);
+            if to_fact
+                .layers
+                .iter()
+                .any(|to_layer| from_layer == to_layer || allowed_layers.contains(to_layer))
+            {
+                continue;
+            }
+            let target_layers = to_fact.layers.join(", ");
+            violations.push(ArchitectureViolation {
+                id: "arch.no_forbidden_layer_dependencies".to_string(),
+                severity: rule.severity,
+                violation_type: "forbidden_layer_dependency".to_string(),
+                message: format!(
+                    "{} in layer {} imports {} in forbidden layer {}.",
+                    from_path, from_layer, to_path, target_layers
+                ),
+                from: Some(edge.from.clone()),
+                to: Some(edge.to.clone()),
+                path: Some(from_path.to_string()),
+                source_range: edge.metadata.source_range.clone(),
+                suggestion: format!(
+                    "Move the dependency behind an allowed layer boundary or change naome.arch.yaml allowed_dependencies if this architecture is intentional. {} currently allows: {}.",
+                    from_layer,
+                    allowed_layers.join(", ")
+                ),
+                agent_instruction: format!(
+                    "Do not import {} from {}. Introduce an allowed boundary or invert the dependency before re-running architecture validation.",
+                    target_layers, from_layer
+                ),
+            });
+        }
+    }
+}
+
 fn validate_max_file_lines(
     scan: &ArchitectureScanReport,
     violations: &mut Vec<ArchitectureViolation>,

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

@@ -2,7 +2,7 @@ use serde_json::json;
 
 use crate::architecture::model::{
     ArchitectureEdge, ArchitectureEdgeKind, ArchitectureGraph, ArchitectureMetadata,
-    ArchitectureNode, ArchitectureNodeKind,
+    ArchitectureNode, ArchitectureNodeKind, SourceRange,
 };
 
 pub(super) fn push_node(
@@ -22,6 +22,32 @@ pub(super) fn push_node(
     });
 }
 
+pub(super) fn push_node_with_metadata(
+    graph: &mut ArchitectureGraph,
+    id: &str,
+    kind: ArchitectureNodeKind,
+    label: &str,
+    path: Option<String>,
+    language: Option<String>,
+    confidence: f32,
+    extractor: &str,
+    raw_origin: serde_json::Value,
+) {
+    graph.nodes.push(ArchitectureNode {
+        id: id.to_string(),
+        kind,
+        label: label.to_string(),
+        metadata: ArchitectureMetadata {
+            path,
+            language,
+            source_range: None,
+            confidence,
+            extractor: extractor.to_string(),
+            raw_origin,
+        },
+    });
+}
+
 pub(super) fn push_edge(
     graph: &mut ArchitectureGraph,
     from: &str,
@@ -40,6 +66,42 @@ pub(super) fn push_edge(
     });
 }
 
+pub(super) fn push_edge_with_metadata(
+    graph: &mut ArchitectureGraph,
+    from: &str,
+    to: &str,
+    kind: ArchitectureEdgeKind,
+    label: &str,
+    path: Option<String>,
+    language: Option<String>,
+    source_range: Option<SourceRange>,
+    confidence: f32,
+    extractor: &str,
+    raw_origin: serde_json::Value,
+) {
+    graph.edges.push(ArchitectureEdge {
+        id: format!(
+            "edge:{from}:{to}:{kind:?}:{}",
+            raw_origin
+                .get("specifier")
+                .and_then(serde_json::Value::as_str)
+                .unwrap_or(label)
+        ),
+        from: from.to_string(),
+        to: to.to_string(),
+        kind,
+        label: label.to_string(),
+        metadata: ArchitectureMetadata {
+            path,
+            language,
+            source_range,
+            confidence,
+            extractor: extractor.to_string(),
+            raw_origin,
+        },
+    });
+}
+
 fn metadata(
     path: Option<String>,
     language: Option<String>,

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

@@ -1,13 +1,11 @@
 use std::collections::BTreeSet;
-use std::fs;
 use std::path::Path;
 
 use crate::architecture::config::ArchitectureConfig;
 use crate::architecture::scan::FileFact;
 use crate::paths;
 
-pub(super) fn file_fact(root: &Path, path: &str, config: &ArchitectureConfig) -> FileFact {
-    let content = fs::read_to_string(root.join(path)).unwrap_or_default();
+pub(super) fn file_fact(path: &str, content: &str, config: &ArchitectureConfig) -> FileFact {
     FileFact {
         path: path.to_string(),
         language: language_for_path(path),
@@ -27,6 +25,7 @@ pub(super) fn file_fact(root: &Path, path: &str, config: &ArchitectureConfig) ->
                 .map(|(name, value)| (name, &value.paths)),
         ),
         ignored: ignore_reason(path, config),
+        imports: Vec::new(),
     }
 }
 

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

@@ -1,8 +1,10 @@
 use std::collections::{BTreeMap, BTreeSet};
+use std::fs;
 use std::path::Path;
 
 use serde_json::json;
 
+use super::imports;
 use super::FileFact;
 use crate::architecture::config::ArchitectureConfig;
 use crate::architecture::model::{ArchitectureEdgeKind, ArchitectureGraph, ArchitectureNodeKind};
@@ -17,16 +19,20 @@ pub(super) fn build_path_graph(
 ) -> (ArchitectureGraph, BTreeMap<String, FileFact>) {
     let mut graph = ArchitectureGraph::default();
     let mut file_facts = BTreeMap::new();
+    let file_set = files.iter().cloned().collect::<BTreeSet<_>>();
 
     push_repository_and_policy_nodes(&mut graph, config);
     push_directories(&mut graph, &files);
 
     for path in files {
-        let fact = facts::file_fact(root, &path, config);
+        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);
         push_file(&mut graph, &fact);
         file_facts.insert(path, fact);
     }
 
+    push_imports(&mut graph, &file_facts);
     (graph, file_facts)
 }
 
@@ -115,6 +121,64 @@ fn push_file(graph: &mut ArchitectureGraph, fact: &FileFact) {
     push_membership_edges(graph, path, "context", &fact.contexts);
 }
 
+fn push_imports(graph: &mut ArchitectureGraph, file_facts: &BTreeMap<String, FileFact>) {
+    let mut emitted_target_nodes = BTreeSet::new();
+    for fact in file_facts.values() {
+        for import in &fact.imports {
+            let target_id = match &import.target {
+                super::ImportTarget::File(path) => format!("file:{path}"),
+                super::ImportTarget::ExternalDependency(name) => {
+                    let id = format!("external:{name}");
+                    if emitted_target_nodes.insert(id.clone()) {
+                        emit::push_node_with_metadata(
+                            graph,
+                            &id,
+                            ArchitectureNodeKind::ExternalDependency,
+                            name,
+                            None,
+                            None,
+                            import.confidence,
+                            &import.extractor,
+                            json!({ "specifier": import.specifier, "resolvedAs": "external" }),
+                        );
+                    }
+                    id
+                }
+                super::ImportTarget::Unknown(specifier) => {
+                    let id = format!("unknown-import:{}", stable_fragment(specifier));
+                    if emitted_target_nodes.insert(id.clone()) {
+                        emit::push_node_with_metadata(
+                            graph,
+                            &id,
+                            ArchitectureNodeKind::ExternalDependency,
+                            specifier,
+                            None,
+                            None,
+                            import.confidence,
+                            &import.extractor,
+                            json!({ "specifier": specifier, "resolvedAs": "unknown" }),
+                        );
+                    }
+                    id
+                }
+            };
+            emit::push_edge_with_metadata(
+                graph,
+                &format!("file:{}", fact.path),
+                &target_id,
+                ArchitectureEdgeKind::Imports,
+                "imports",
+                Some(fact.path.clone()),
+                fact.language.clone(),
+                import.source_range.clone(),
+                import.confidence,
+                &import.extractor,
+                json!({ "specifier": import.specifier, "target": import.target }),
+            );
+        }
+    }
+}
+
 fn push_membership_edges(
     graph: &mut ArchitectureGraph,
     path: &str,
@@ -132,3 +196,16 @@ fn push_membership_edges(
         );
     }
 }
+
+fn stable_fragment(value: &str) -> String {
+    value
+        .chars()
+        .map(|character| {
+            if character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.' | '/') {
+                character
+            } else {
+                '_'
+            }
+        })
+        .collect()
+}