@lamentis/naome 1.3.11 → 1.3.13

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

@@ -0,0 +1,280 @@
+use crate::architecture::scan::{ManifestDependency, ManifestFact};
+
+use super::super::common::{dependency, fact, fallback_package_name, quoted_value};
+
+pub(in crate::architecture::scan::manifest) fn go_mod(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = content
+        .lines()
+        .find_map(|line| line.trim().strip_prefix("module "))
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string)
+        .unwrap_or_else(|| fallback_package_name(path, "go"));
+    let mut dependencies = Vec::new();
+    let mut in_require_block = false;
+    for raw_line in content.lines() {
+        let line = raw_line.split("//").next().unwrap_or_default().trim();
+        if line == "require (" {
+            in_require_block = true;
+            continue;
+        }
+        if in_require_block && line == ")" {
+            in_require_block = false;
+            continue;
+        }
+        let require_line = line.strip_prefix("require ").unwrap_or(line);
+        if !in_require_block && !line.starts_with("require ") {
+            continue;
+        }
+        if let Some((name, version)) = first_two_fields(require_line) {
+            dependencies.push(dependency(name, "runtime", version, 0.95));
+        }
+    }
+    Some(fact(path, "go", package_name, dependencies, 0.95))
+}
+
+pub(in crate::architecture::scan::manifest) fn pom_xml(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let project_content = xml_without_parent_blocks(content);
+    let package_group = first_xml_tag(&project_content, "groupId")
+        .or_else(|| first_xml_tag(content, "groupId"))
+        .unwrap_or_else(|| "maven".to_string());
+    let package_artifact = first_xml_tag(&project_content, "artifactId")
+        .unwrap_or_else(|| fallback_package_name(path, "maven"));
+    let package_name = format!("{package_group}:{package_artifact}");
+    let dependency_content = xml_without_blocks(
+        &xml_without_blocks(content, "dependencyManagement"),
+        "build",
+    );
+    let dependencies = project_dependency_sections(&dependency_content)
+        .into_iter()
+        .flat_map(|section| section.split("<dependency>").skip(1).collect::<Vec<_>>())
+        .filter_map(|block| {
+            let group = first_xml_tag(block, "groupId")?;
+            let artifact = first_xml_tag(block, "artifactId")?;
+            Some(dependency(
+                format!("{group}:{artifact}"),
+                first_xml_tag(block, "scope").unwrap_or_else(|| "runtime".into()),
+                first_xml_tag(block, "version"),
+                0.75,
+            ))
+        })
+        .collect();
+    Some(fact(path, "maven", package_name, dependencies, 0.75))
+}
+
+pub(in crate::architecture::scan::manifest) fn build_gradle(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = fallback_package_name(path, "gradle");
+    let dependencies = content.lines().filter_map(gradle_dependency).collect();
+    Some(fact(path, "gradle", package_name, dependencies, 0.7))
+}
+
+pub(in crate::architecture::scan::manifest) fn package_swift(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let active_content = swift_active_content(content);
+    let package_name = swift_argument_value(&active_content, "name")
+        .unwrap_or_else(|| fallback_package_name(path, "swift"));
+    let dependencies = active_content
+        .split(".package")
+        .skip(1)
+        .filter_map(|block| {
+            let url = swift_argument_value(block, "url")?;
+            Some(dependency(
+                package_name_from_url(&url),
+                "runtime",
+                swift_package_version(block),
+                0.8,
+            ))
+        })
+        .collect();
+    Some(fact(path, "swift", package_name, dependencies, 0.8))
+}
+
+pub(in crate::architecture::scan::manifest) fn xcode_project(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = fallback_package_name(path, "xcode");
+    let dependencies = content
+        .lines()
+        .filter_map(|line| {
+            let url = line
+                .trim()
+                .strip_prefix("repositoryURL = ")
+                .and_then(quoted_value)?;
+            Some(dependency(
+                package_name_from_url(&url),
+                "runtime",
+                None,
+                0.65,
+            ))
+        })
+        .collect();
+    Some(fact(path, "xcode", package_name, dependencies, 0.65))
+}
+
+fn first_two_fields(line: &str) -> Option<(String, Option<String>)> {
+    let mut parts = line.split_whitespace();
+    Some((parts.next()?.to_string(), parts.next().map(str::to_string)))
+}
+
+fn first_xml_tag(content: &str, tag: &str) -> Option<String> {
+    let open = format!("<{tag}>");
+    let close = format!("</{tag}>");
+    content
+        .split_once(&open)?
+        .1
+        .split_once(&close)
+        .map(|(value, _)| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+fn xml_without_parent_blocks(content: &str) -> String {
+    xml_without_blocks(content, "parent")
+}
+
+fn xml_without_blocks(content: &str, tag: &str) -> String {
+    let open = format!("<{tag}>");
+    let close = format!("</{tag}>");
+    let mut remaining = content;
+    let mut output = String::new();
+    while let Some((before, after_open)) = remaining.split_once(&open) {
+        output.push_str(before);
+        let Some((_, after_close)) = after_open.split_once(&close) else {
+            output.push_str(after_open);
+            return output;
+        };
+        remaining = after_close;
+    }
+    output.push_str(remaining);
+    output
+}
+
+fn project_dependency_sections(content: &str) -> Vec<&str> {
+    content
+        .split("<dependencies>")
+        .skip(1)
+        .filter_map(|block| block.split_once("</dependencies>").map(|(block, _)| block))
+        .collect()
+}
+
+fn gradle_dependency(line: &str) -> Option<ManifestDependency> {
+    let trimmed = line.split("//").next().unwrap_or_default().trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+    let kind = [
+        "implementation",
+        "api",
+        "compileOnly",
+        "runtimeOnly",
+        "testImplementation",
+    ]
+    .into_iter()
+    .find(|kind| trimmed.contains(&format!("{kind} ")) || trimmed.contains(&format!("{kind}(")))?;
+    let coordinate_text = trimmed
+        .split_once(&format!("{kind} "))
+        .map(|(_, value)| value.trim())
+        .or_else(|| {
+            trimmed
+                .split_once(&format!("{kind}("))
+                .map(|(_, value)| value.trim_end_matches(')').trim())
+        })?;
+    if let Some(coordinate) = quoted_value(coordinate_text) {
+        return gradle_coordinate_dependency(&coordinate, kind);
+    }
+    let group = gradle_map_value(coordinate_text, "group")?;
+    let artifact = gradle_map_value(coordinate_text, "name")?;
+    Some(dependency(
+        format!("{group}:{artifact}"),
+        kind,
+        gradle_map_value(coordinate_text, "version"),
+        0.7,
+    ))
+}
+
+fn gradle_coordinate_dependency(coordinate: &str, kind: &str) -> Option<ManifestDependency> {
+    let mut parts = coordinate.split(':');
+    let group = parts.next()?;
+    let artifact = parts.next()?;
+    Some(dependency(
+        format!("{group}:{artifact}"),
+        kind,
+        parts.next().map(str::to_string),
+        0.7,
+    ))
+}
+
+fn gradle_map_value(text: &str, key: &str) -> Option<String> {
+    text.split(',').find_map(|part| {
+        let (name, value) = part.trim().split_once(':')?;
+        if name.trim() == key {
+            quoted_value(value.trim())
+        } else {
+            None
+        }
+    })
+}
+
+fn swift_argument_value(content: &str, key: &str) -> Option<String> {
+    let marker = format!("{key}:");
+    let (_, value) = content.split_once(&marker)?;
+    quoted_value(value.trim())
+}
+
+fn swift_active_content(content: &str) -> String {
+    content
+        .lines()
+        .map(strip_swift_line_comment)
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn strip_swift_line_comment(line: &str) -> &str {
+    let mut in_quote = false;
+    let mut escaped = false;
+    let mut previous = '\0';
+    for (index, character) in line.char_indices() {
+        if in_quote {
+            if character == '"' && !escaped {
+                in_quote = false;
+            }
+            escaped = character == '\\' && !escaped;
+        } else if character == '"' {
+            in_quote = true;
+            escaped = false;
+        } else if previous == '/' && character == '/' {
+            return &line[..index - 1];
+        }
+        if character != '\\' {
+            escaped = false;
+        }
+        previous = character;
+    }
+    line
+}
+
+fn swift_package_version(block: &str) -> Option<String> {
+    swift_argument_value(block, "from")
+        .or_else(|| swift_argument_value(block, "exact"))
+        .or_else(|| swift_argument_value(block, "branch"))
+}
+
+fn package_name_from_url(url: &str) -> String {
+    url.trim_end_matches(".git")
+        .trim_end_matches('/')
+        .rsplit('/')
+        .next()
+        .unwrap_or(url)
+        .to_string()
+}

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

@@ -0,0 +1,184 @@
+use crate::architecture::scan::{ManifestDependency, ManifestFact};
+
+use super::super::common::{
+    clean_toml_line, dependency, fact, fallback_package_name, quoted_value,
+};
+
+pub(in crate::architecture::scan::manifest) fn cargo_toml(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = toml_string(content, "package", "name")
+        .unwrap_or_else(|| fallback_package_name(path, "cargo"));
+    let dependencies = toml_dependency_sections(
+        content,
+        &[
+            ("dependencies", "runtime"),
+            ("dev-dependencies", "development"),
+            ("build-dependencies", "build"),
+        ],
+    );
+    Some(fact(path, "cargo", package_name, dependencies, 0.9))
+}
+
+pub(in crate::architecture::scan::manifest) fn pyproject_toml(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = toml_string(content, "project", "name")
+        .unwrap_or_else(|| fallback_package_name(path, "python"));
+    let mut dependencies = toml_string_array(content, "project", "dependencies")
+        .into_iter()
+        .map(|value| dependency(python_dependency_name(&value), "runtime", Some(value), 0.85))
+        .collect::<Vec<_>>();
+    dependencies.extend(
+        toml_dependency_sections(content, &[("tool.poetry.dependencies", "runtime")])
+            .into_iter()
+            .filter(|dependency| dependency.name != "python"),
+    );
+    Some(fact(path, "python", package_name, dependencies, 0.85))
+}
+
+fn toml_string(content: &str, section: &str, key: &str) -> Option<String> {
+    section_value(content, section, key).and_then(quoted_value)
+}
+
+fn toml_string_array(content: &str, section: &str, key: &str) -> Vec<String> {
+    let mut current_section = "";
+    let mut collecting = false;
+    let mut array = String::new();
+    for line in content.lines().map(clean_toml_line) {
+        if !collecting {
+            if let Some(section_name) = line
+                .strip_prefix('[')
+                .and_then(|line| line.strip_suffix(']'))
+            {
+                current_section = section_name.trim();
+                continue;
+            }
+            if current_section != section {
+                continue;
+            }
+            let Some(value) = line
+                .strip_prefix(key)
+                .and_then(|line| line.trim().strip_prefix('='))
+            else {
+                continue;
+            };
+            array.push_str(value.trim());
+            if value.contains(']') {
+                break;
+            }
+            collecting = value.trim_start().starts_with('[');
+            continue;
+        }
+        array.push(' ');
+        array.push_str(line);
+        if line.contains(']') {
+            break;
+        }
+    }
+    array
+        .trim()
+        .trim_start_matches('[')
+        .trim_end_matches(']')
+        .split(',')
+        .filter_map(quoted_value)
+        .collect()
+}
+
+fn section_value<'a>(content: &'a str, section: &str, key: &str) -> Option<&'a str> {
+    let mut current_section = "";
+    for line in content.lines().map(clean_toml_line) {
+        if let Some(section_name) = line
+            .strip_prefix('[')
+            .and_then(|line| line.strip_suffix(']'))
+        {
+            current_section = section_name.trim();
+            continue;
+        }
+        if current_section == section {
+            if let Some(value) = line
+                .strip_prefix(key)
+                .and_then(|line| line.trim().strip_prefix('='))
+            {
+                return Some(value.trim());
+            }
+        }
+    }
+    None
+}
+
+fn toml_dependency_sections(content: &str, sections: &[(&str, &str)]) -> Vec<ManifestDependency> {
+    let mut current_kind = None;
+    let mut table_dependency = None;
+    let mut dependencies = Vec::new();
+    for line in content.lines().map(clean_toml_line) {
+        if let Some(section_name) = line
+            .strip_prefix('[')
+            .and_then(|line| line.strip_suffix(']'))
+        {
+            push_table_dependency(&mut dependencies, table_dependency.take());
+            let section_name = section_name.trim();
+            current_kind = sections
+                .iter()
+                .find(|(section, _)| *section == section_name)
+                .map(|(_, kind)| *kind);
+            if current_kind.is_none() {
+                table_dependency = dependency_table(section_name, sections);
+            }
+            continue;
+        }
+        if let Some((name, kind, version)) = table_dependency.as_mut() {
+            if let Some((key, value)) = line.split_once('=') {
+                if key.trim() == "version" {
+                    *version = quoted_value(value.trim());
+                }
+            }
+            if !name.is_empty() && !kind.is_empty() {
+                continue;
+            }
+        }
+        if let (Some(kind), Some((name, value))) = (current_kind, line.split_once('=')) {
+            dependencies.push(dependency(
+                name.trim().to_string(),
+                kind,
+                quoted_value(value.trim()),
+                0.85,
+            ));
+        }
+    }
+    push_table_dependency(&mut dependencies, table_dependency);
+    dependencies
+}
+
+fn dependency_table<'a>(
+    section_name: &str,
+    sections: &[(&str, &'a str)],
+) -> Option<(String, &'a str, Option<String>)> {
+    sections.iter().find_map(|(section, kind)| {
+        let dependency_name = section_name.strip_prefix(&format!("{section}."))?;
+        if dependency_name.is_empty() || dependency_name.contains('.') {
+            return None;
+        }
+        Some((dependency_name.to_string(), *kind, None))
+    })
+}
+
+fn push_table_dependency(
+    dependencies: &mut Vec<ManifestDependency>,
+    table_dependency: Option<(String, &str, Option<String>)>,
+) {
+    if let Some((name, kind, version)) = table_dependency {
+        dependencies.push(dependency(name, kind, version, 0.85));
+    }
+}
+
+fn python_dependency_name(value: &str) -> String {
+    value
+        .split(['<', '>', '=', '!', '~', '[', ';', ' '])
+        .next()
+        .unwrap_or(value)
+        .trim()
+        .to_string()
+}

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

@@ -0,0 +1,3 @@
+pub(super) mod json;
+pub(super) mod other;
+pub(super) mod toml;

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

@@ -11,6 +11,7 @@ use super::model::ArchitectureGraph;
 
 mod graph_builder;
 mod imports;
+mod manifest;
 mod path_scan;
 
 #[derive(Debug, Clone, Default)]
@@ -32,6 +33,8 @@ pub struct ArchitectureScanReport {
     pub config: ArchitectureConfig,
     #[serde(skip_serializing)]
     pub file_facts: BTreeMap<String, FileFact>,
+    #[serde(skip_serializing)]
+    pub manifest_facts: Vec<ManifestFact>,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -64,6 +67,26 @@ pub enum ImportTarget {
     Unknown(String),
 }
 
+#[derive(Debug, Clone, Serialize)]
+#[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)]
+#[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,7 +94,9 @@ 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 manifest_facts = manifest::extract_manifests(root, &files);
+    let (mut graph, file_facts) =
+        graph_builder::build_path_graph(root, files, &config, &manifest_facts);
 
     graph.sort_stable();
     Ok(ArchitectureScanReport {
@@ -83,6 +108,7 @@ pub fn scan_architecture(
         changed_paths,
         config,
         file_facts,
+        manifest_facts,
     })
 }
 

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

@@ -18,7 +18,7 @@ pub use model::{
 pub use output::{
     format_architecture_explain, format_architecture_scan, format_architecture_validation,
     ArchitectureAgentFeedback, ArchitectureValidation, ArchitectureViolation, Severity,
-    ViolationSummary,
+    ViolationSummary, ARCHITECTURE_RULE_IDS,
 };
 pub use scan::{scan_architecture, ArchitectureScanOptions, ArchitectureScanReport};
 

package/crates/naome-core/src/lib.rs

@@ -27,6 +27,7 @@ pub use architecture::{
     ArchitectureGraph, ArchitectureMetadata, ArchitectureNode, ArchitectureNodeKind,
     ArchitectureScanOptions, ArchitectureScanReport, ArchitectureValidation, ArchitectureViolation,
     ContextConfig, LayerConfig, RuleConfig, Severity, SourceRange, ViolationSummary,
+    ARCHITECTURE_RULE_IDS,
 };
 pub use context::{
     select_context_for_changed_paths, select_context_for_prompt, ContextBudgetLedger,