@lamentis/naome 1.3.9 → 1.3.11

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

@@ -0,0 +1,80 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ArchitectureNodeKind {
+    Repository,
+    Package,
+    Directory,
+    File,
+    Module,
+    Symbol,
+    Layer,
+    BoundedContext,
+    ExternalDependency,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ArchitectureEdgeKind {
+    Contains,
+    Imports,
+    DependsOn,
+    Calls,
+    Exports,
+    Implements,
+    Extends,
+    ReadsFrom,
+    WritesTo,
+    Unknown,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SourceRange {
+    pub start_line: usize,
+    pub start_column: usize,
+    pub end_line: usize,
+    pub end_column: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ArchitectureMetadata {
+    pub path: Option<String>,
+    pub language: Option<String>,
+    pub source_range: Option<SourceRange>,
+    pub confidence: f32,
+    pub extractor: String,
+    pub raw_origin: Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ArchitectureNode {
+    pub id: String,
+    pub kind: ArchitectureNodeKind,
+    pub label: String,
+    pub metadata: ArchitectureMetadata,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ArchitectureEdge {
+    pub id: String,
+    pub from: String,
+    pub to: String,
+    pub kind: ArchitectureEdgeKind,
+    pub label: String,
+    pub metadata: ArchitectureMetadata,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ArchitectureGraph {
+    pub nodes: Vec<ArchitectureNode>,
+    pub edges: Vec<ArchitectureEdge>,
+}
+
+impl ArchitectureGraph {
+    pub fn sort_stable(&mut self) {
+        self.nodes.sort_by(|left, right| left.id.cmp(&right.id));
+        self.edges.sort_by(|left, right| left.id.cmp(&right.id));
+    }
+}

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

@@ -0,0 +1,178 @@
+use serde::{Deserialize, Serialize};
+
+use super::model::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 {
+    pub errors: usize,
+    pub warnings: usize,
+    pub info: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ArchitectureViolation {
+    pub id: String,
+    pub severity: Severity,
+    #[serde(rename = "type")]
+    pub violation_type: String,
+    pub message: String,
+    pub from: Option<String>,
+    pub to: Option<String>,
+    pub path: Option<String>,
+    pub source_range: Option<SourceRange>,
+    pub suggestion: String,
+    pub agent_instruction: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ArchitectureAgentFeedback {
+    pub problem: String,
+    pub repair: String,
+    pub files: Vec<String>,
+    pub must_not_do: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ArchitectureValidation {
+    pub schema: String,
+    pub status: String,
+    pub summary: ViolationSummary,
+    pub files_scanned: usize,
+    pub graph_nodes: usize,
+    pub graph_edges: usize,
+    pub rules_executed: Vec<String>,
+    pub changed_only_requested: bool,
+    pub changed_only_degraded_to_full_scan: bool,
+    pub violations: Vec<ArchitectureViolation>,
+    #[serde(rename = "agent_feedback")]
+    pub agent_feedback: Vec<ArchitectureAgentFeedback>,
+}
+
+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> {
+    violations
+        .iter()
+        .map(|violation| ArchitectureAgentFeedback {
+            problem: violation.message.clone(),
+            repair: violation.suggestion.clone(),
+            files: violation.path.iter().cloned().collect(),
+            must_not_do: vec![
+                "Do not suppress architecture rules without an explicit ignore reason.".to_string(),
+                "Do not edit generated files unless the architecture config allows it.".to_string(),
+            ],
+        })
+        .collect()
+}
+
+pub fn summary_for(violations: &[ArchitectureViolation]) -> ViolationSummary {
+    ViolationSummary {
+        errors: violations
+            .iter()
+            .filter(|violation| violation.severity == Severity::Error)
+            .count(),
+        warnings: violations
+            .iter()
+            .filter(|violation| violation.severity == Severity::Warning)
+            .count(),
+        info: violations
+            .iter()
+            .filter(|violation| violation.severity == Severity::Info)
+            .count(),
+    }
+}
+
+pub fn format_architecture_validation(report: &ArchitectureValidation) -> String {
+    let mut lines = vec![
+        format!(
+            "NAOME architecture fitness {}",
+            report.status.to_uppercase()
+        ),
+        format!("files scanned: {}", report.files_scanned),
+        format!("graph nodes: {}", report.graph_nodes),
+        format!("graph edges: {}", report.graph_edges),
+        format!("rules executed: {}", report.rules_executed.join(", ")),
+        format!(
+            "violations: {} errors, {} warnings, {} info",
+            report.summary.errors, report.summary.warnings, report.summary.info
+        ),
+    ];
+
+    if report.changed_only_degraded_to_full_scan {
+        lines.push("changed-only requested: degraded to full scan for soundness".to_string());
+    }
+
+    for violation in report.violations.iter().take(10) {
+        lines.push(format!(
+            "- {:?} {} {}",
+            violation.severity,
+            violation.path.as_deref().unwrap_or("<repository>"),
+            violation.message
+        ));
+        lines.push(format!("  fix: {}", violation.suggestion));
+    }
+
+    lines.push(String::new());
+    lines.join("\n")
+}
+
+pub fn format_architecture_scan(report: &ArchitectureScanReport) -> String {
+    format!(
+        "NAOME architecture scan\nfiles scanned: {}\ngraph nodes: {}\ngraph edges: {}\n",
+        report.files_scanned,
+        report.graph.nodes.len(),
+        report.graph.edges.len()
+    )
+}
+
+pub fn format_architecture_explain(scan: &ArchitectureScanReport) -> String {
+    let layers = scan
+        .config
+        .layers
+        .keys()
+        .cloned()
+        .collect::<Vec<_>>()
+        .join(", ");
+    let contexts = scan
+        .config
+        .contexts
+        .keys()
+        .cloned()
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!(
+        "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)
+    )
+}
+
+fn empty_label(value: &str) -> &str {
+    if value.is_empty() {
+        "<none>"
+    } else {
+        value
+    }
+}

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

@@ -0,0 +1,212 @@
+use crate::paths;
+
+use super::output::{
+    architecture_agent_feedback, summary_for, ArchitectureValidation, ArchitectureViolation,
+    Severity,
+};
+use super::scan::ArchitectureScanReport;
+use crate::architecture::model::ArchitectureEdgeKind;
+
+pub fn validate_scan(scan: ArchitectureScanReport) -> ArchitectureValidation {
+    let mut violations = Vec::new();
+    let mut rules_executed = Vec::new();
+
+    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| {
+        (
+            severity_rank(left.severity),
+            left.id.as_str(),
+            left.path.as_deref().unwrap_or(""),
+            left.message.as_str(),
+        )
+            .cmp(&(
+                severity_rank(right.severity),
+                right.id.as_str(),
+                right.path.as_deref().unwrap_or(""),
+                right.message.as_str(),
+            ))
+    });
+    let summary = summary_for(&violations);
+    let status = if summary.errors > 0 { "fail" } else { "pass" }.to_string();
+    let agent_feedback = architecture_agent_feedback(&violations);
+
+    ArchitectureValidation {
+        schema: "naome.arch.validation.v1".to_string(),
+        status,
+        summary,
+        files_scanned: scan.files_scanned,
+        graph_nodes: scan.graph.nodes.len(),
+        graph_edges: scan.graph.edges.len(),
+        rules_executed,
+        changed_only_requested: scan.changed_only_requested,
+        changed_only_degraded_to_full_scan: scan.changed_only_degraded_to_full_scan,
+        violations,
+        agent_feedback,
+    }
+}
+
+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>,
+    rules_executed: &mut Vec<String>,
+) {
+    let rule = scan.config.rule("max_file_lines");
+    if !rule.enabled {
+        return;
+    }
+    rules_executed.push("arch.max_file_lines".to_string());
+    let Some(limit) = rule.value else {
+        return;
+    };
+    for fact in scan.file_facts.values() {
+        if fact.line_count <= limit {
+            continue;
+        }
+        violations.push(ArchitectureViolation {
+            id: "arch.max_file_lines".to_string(),
+            severity: rule.severity,
+            violation_type: "file_size_budget".to_string(),
+            message: format!(
+                "{} has {} lines, exceeding the configured budget of {}.",
+                fact.path, fact.line_count, limit
+            ),
+            from: Some(format!("file:{}", fact.path)),
+            to: None,
+            path: Some(fact.path.clone()),
+            source_range: None,
+            suggestion: "Split the file into cohesive modules or move generated content behind an explicit ignore rule.".to_string(),
+            agent_instruction: format!(
+                "Reduce {} below {} lines or add a justified generated-code ignore rule if it is not manually owned.",
+                fact.path, limit
+            ),
+        });
+    }
+}
+
+fn validate_generated_manual_boundary(
+    scan: &ArchitectureScanReport,
+    violations: &mut Vec<ArchitectureViolation>,
+    rules_executed: &mut Vec<String>,
+) {
+    let rule = scan.config.rule("generated_manual_boundary");
+    if !rule.enabled {
+        return;
+    }
+    rules_executed.push("arch.generated_manual_boundary".to_string());
+    if scan.changed_paths.is_empty() {
+        return;
+    }
+
+    for changed_path in &scan.changed_paths {
+        let Some(ignore_rule) = scan
+            .config
+            .ignore
+            .iter()
+            .find(|rule| paths::matches_any(changed_path, std::slice::from_ref(&rule.path)))
+        else {
+            continue;
+        };
+        violations.push(ArchitectureViolation {
+            id: "arch.generated_manual_boundary".to_string(),
+            severity: rule.severity,
+            violation_type: "generated_manual_boundary".to_string(),
+            message: format!(
+                "{} matches ignored architecture-owned boundary {}.",
+                changed_path, ignore_rule.path
+            ),
+            from: Some(format!("file:{changed_path}")),
+            to: None,
+            path: Some(changed_path.clone()),
+            source_range: None,
+            suggestion: format!(
+                "Do not edit this generated path directly. Regenerate it from its source or remove the ignore only with an explicit reason. Current reason: {}",
+                ignore_rule.reason
+            ),
+            agent_instruction: format!(
+                "Do not modify {} directly; regenerate it or explain and change naome.arch.yaml intentionally.",
+                changed_path
+            ),
+        });
+    }
+}
+
+fn severity_rank(severity: Severity) -> u8 {
+    match severity {
+        Severity::Error => 0,
+        Severity::Warning => 1,
+        Severity::Info => 2,
+    }
+}

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

@@ -0,0 +1,118 @@
+use serde_json::json;
+
+use crate::architecture::model::{
+    ArchitectureEdge, ArchitectureEdgeKind, ArchitectureGraph, ArchitectureMetadata,
+    ArchitectureNode, ArchitectureNodeKind, SourceRange,
+};
+
+pub(super) fn push_node(
+    graph: &mut ArchitectureGraph,
+    id: &str,
+    kind: ArchitectureNodeKind,
+    label: &str,
+    path: Option<String>,
+    language: Option<String>,
+    raw_origin: serde_json::Value,
+) {
+    graph.nodes.push(ArchitectureNode {
+        id: id.to_string(),
+        kind,
+        label: label.to_string(),
+        metadata: metadata(path, language, raw_origin),
+    });
+}
+
+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,
+    to: &str,
+    kind: ArchitectureEdgeKind,
+    label: &str,
+    path: Option<String>,
+) {
+    graph.edges.push(ArchitectureEdge {
+        id: format!("edge:{from}:{to}:{kind:?}"),
+        from: from.to_string(),
+        to: to.to_string(),
+        kind,
+        label: label.to_string(),
+        metadata: metadata(path, None, json!({ "extractor": "path" })),
+    });
+}
+
+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>,
+    raw_origin: serde_json::Value,
+) -> ArchitectureMetadata {
+    ArchitectureMetadata {
+        path,
+        language,
+        source_range: None,
+        confidence: 1.0,
+        extractor: "path".to_string(),
+        raw_origin,
+    }
+}

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

@@ -0,0 +1,87 @@
+use std::collections::BTreeSet;
+use std::path::Path;
+
+use crate::architecture::config::ArchitectureConfig;
+use crate::architecture::scan::FileFact;
+use crate::paths;
+
+pub(super) fn file_fact(path: &str, content: &str, config: &ArchitectureConfig) -> FileFact {
+    FileFact {
+        path: path.to_string(),
+        language: language_for_path(path),
+        line_count: content.lines().count(),
+        layers: matching_named_patterns(
+            path,
+            config
+                .layers
+                .iter()
+                .map(|(name, value)| (name, &value.paths)),
+        ),
+        contexts: matching_named_patterns(
+            path,
+            config
+                .contexts
+                .iter()
+                .map(|(name, value)| (name, &value.paths)),
+        ),
+        ignored: ignore_reason(path, config),
+        imports: Vec::new(),
+    }
+}
+
+pub(super) fn collect_directories(path: &str, directories: &mut BTreeSet<String>) {
+    let mut current = Path::new(path).parent();
+    while let Some(dir) = current {
+        let normalized = normalize_path(dir);
+        if normalized.is_empty() {
+            break;
+        }
+        directories.insert(normalized);
+        current = dir.parent();
+    }
+}
+
+pub(super) fn parent_node_id(path: &str) -> Option<String> {
+    Path::new(path)
+        .parent()
+        .map(normalize_path)
+        .filter(|path| !path.is_empty())
+        .map(|path| format!("directory:{path}"))
+}
+
+fn matching_named_patterns<'a>(
+    path: &str,
+    patterns: impl Iterator<Item = (&'a String, &'a Vec<String>)>,
+) -> Vec<String> {
+    patterns
+        .filter(|(_, patterns)| paths::matches_any(path, patterns))
+        .map(|(name, _)| name.clone())
+        .collect()
+}
+
+fn ignore_reason(path: &str, config: &ArchitectureConfig) -> Option<String> {
+    config
+        .ignore
+        .iter()
+        .find(|rule| paths::matches_any(path, std::slice::from_ref(&rule.path)))
+        .map(|rule| rule.reason.clone())
+}
+
+fn language_for_path(path: &str) -> Option<String> {
+    let extension = Path::new(path).extension()?.to_str()?;
+    match extension {
+        "ts" | "tsx" => Some("typescript".to_string()),
+        "js" | "jsx" | "mjs" | "cjs" => Some("javascript".to_string()),
+        "rs" => Some("rust".to_string()),
+        "py" => Some("python".to_string()),
+        "go" => Some("go".to_string()),
+        "java" => Some("java".to_string()),
+        "kt" | "kts" => Some("kotlin".to_string()),
+        "swift" => Some("swift".to_string()),
+        _ => None,
+    }
+}
+
+fn normalize_path(path: impl AsRef<Path>) -> String {
+    path.as_ref().to_string_lossy().replace('\\', "/")
+}