@lamentis/naome 1.3.11 → 1.3.13

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

@@ -5,7 +5,7 @@ use std::path::Path;
 use serde_json::json;
 
 use super::imports;
-use super::FileFact;
+use super::{FileFact, ManifestFact};
 use crate::architecture::config::ArchitectureConfig;
 use crate::architecture::model::{ArchitectureEdgeKind, ArchitectureGraph, ArchitectureNodeKind};
 
@@ -16,13 +16,16 @@ pub(super) fn build_path_graph(
     root: &Path,
     files: Vec<String>,
     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<_>>();
 
     push_repository_and_policy_nodes(&mut graph, config);
     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();
@@ -32,7 +35,7 @@ pub(super) fn build_path_graph(
         file_facts.insert(path, fact);
     }
 
-    push_imports(&mut graph, &file_facts);
+    push_imports(&mut graph, &file_facts, &mut emitted_external_nodes);
     (graph, file_facts)
 }
 
@@ -121,44 +124,117 @@ 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();
+fn push_manifests(
+    graph: &mut ArchitectureGraph,
+    manifests: &[ManifestFact],
+    emitted_external_nodes: &mut BTreeSet<String>,
+) {
+    for manifest in manifests {
+        let package_id = manifest_package_id(manifest);
+        emit::push_node_with_metadata(
+            graph,
+            &package_id,
+            ArchitectureNodeKind::Package,
+            &manifest.package_name,
+            Some(manifest.path.clone()),
+            None,
+            manifest.confidence,
+            &manifest.extractor,
+            json!({
+                "path": manifest.path,
+                "ecosystem": manifest.ecosystem,
+                "packageName": manifest.package_name
+            }),
+        );
+        emit::push_edge(
+            graph,
+            facts::parent_node_id(&manifest.path)
+                .as_deref()
+                .unwrap_or("repository:."),
+            &package_id,
+            ArchitectureEdgeKind::Contains,
+            "contains",
+            Some(manifest.path.clone()),
+        );
+        for dependency in &manifest.dependencies {
+            let external_id = format!("external:{}", dependency.name);
+            push_external_node(
+                graph,
+                emitted_external_nodes,
+                &external_id,
+                &dependency.name,
+                dependency.confidence,
+                &manifest.extractor,
+                json!({
+                    "manifestPath": manifest.path,
+                    "ecosystem": manifest.ecosystem,
+                    "dependencyKind": dependency.dependency_kind,
+                    "version": dependency.version
+                }),
+            );
+            emit::push_edge_with_metadata(
+                graph,
+                &package_id,
+                &external_id,
+                ArchitectureEdgeKind::DependsOn,
+                "depends_on",
+                Some(manifest.path.clone()),
+                None,
+                None,
+                dependency.confidence,
+                &manifest.extractor,
+                json!({
+                    "specifier": dependency.name,
+                    "manifestPath": manifest.path,
+                    "dependencyKind": dependency.dependency_kind,
+                    "version": dependency.version
+                }),
+            );
+        }
+    }
+}
+
+fn manifest_package_id(manifest: &ManifestFact) -> String {
+    format!(
+        "package:{}:{}",
+        stable_fragment(&manifest.ecosystem),
+        stable_fragment(&manifest.path)
+    )
+}
+
+fn push_imports(
+    graph: &mut ArchitectureGraph,
+    file_facts: &BTreeMap<String, FileFact>,
+    emitted_external_nodes: &mut BTreeSet<String>,
+) {
     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" }),
-                        );
-                    }
+                    push_external_node(
+                        graph,
+                        emitted_external_nodes,
+                        &id,
+                        name,
+                        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" }),
-                        );
-                    }
+                    push_external_node(
+                        graph,
+                        emitted_external_nodes,
+                        &id,
+                        specifier,
+                        import.confidence,
+                        &import.extractor,
+                        json!({ "specifier": specifier, "resolvedAs": "unknown" }),
+                    );
                     id
                 }
             };
@@ -179,6 +255,30 @@ fn push_imports(graph: &mut ArchitectureGraph, file_facts: &BTreeMap<String, Fil
     }
 }
 
+fn push_external_node(
+    graph: &mut ArchitectureGraph,
+    emitted_external_nodes: &mut BTreeSet<String>,
+    id: &str,
+    label: &str,
+    confidence: f32,
+    extractor: &str,
+    raw_origin: serde_json::Value,
+) {
+    if emitted_external_nodes.insert(id.to_string()) {
+        emit::push_node_with_metadata(
+            graph,
+            id,
+            ArchitectureNodeKind::ExternalDependency,
+            label,
+            None,
+            None,
+            confidence,
+            extractor,
+            raw_origin,
+        );
+    }
+}
+
 fn push_membership_edges(
     graph: &mut ArchitectureGraph,
     path: &str,

package/crates/naome-core/src/architecture/scan/imports/extractors/swift.rs

@@ -0,0 +1,48 @@
+use super::{is_comment_only, raw, RawImport};
+
+pub(super) fn extract(content: &str) -> Vec<RawImport> {
+    let mut imports = Vec::new();
+    for (index, line) in content.lines().enumerate() {
+        let trimmed = line.trim();
+        if is_comment_only(trimmed) {
+            continue;
+        }
+        let Some(import_value) = swift_import_value(trimmed) else {
+            continue;
+        };
+        if let Some(specifier) = swift_import_specifier(import_value) {
+            imports.push(raw(specifier, index, line, 0.88, "import:swift"));
+        }
+    }
+    imports
+}
+
+fn swift_import_value(line: &str) -> Option<&str> {
+    let mut remaining = line.trim();
+    while remaining.starts_with('@') {
+        let Some((_, after_attribute)) = remaining.split_once(' ') else {
+            return None;
+        };
+        remaining = after_attribute.trim_start();
+    }
+    remaining.strip_prefix("import ")
+}
+
+fn swift_import_specifier(value: &str) -> Option<String> {
+    let mut parts = value.split_whitespace();
+    let first = parts.next()?;
+    let module = if matches!(
+        first,
+        "class" | "struct" | "enum" | "protocol" | "func" | "var" | "typealias"
+    ) {
+        parts.next()?
+    } else {
+        first
+    };
+    module
+        .split('.')
+        .next()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToString::to_string)
+}

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

@@ -1,6 +1,8 @@
 use super::language_for_path;
 use crate::architecture::model::SourceRange;
 
+mod swift;
+
 #[derive(Debug, Clone)]
 pub(super) struct RawImport {
     pub specifier: String,
@@ -15,6 +17,7 @@ pub(super) fn extract_raw_imports(path: &str, content: &str) -> Vec<RawImport> {
         Some("rust") => extract_rust(content),
         Some("python") => extract_python(content),
         Some("go") => extract_go(content),
+        Some("swift") => swift::extract(content),
         _ => Vec::new(),
     }
 }
@@ -69,12 +72,6 @@ fn extract_rust(content: &str) -> Vec<RawImport> {
             .strip_prefix("use ")
             .or_else(|| rust_visible_use_value(trimmed))
             .map(rust_use_specifiers)
-            .or_else(|| {
-                trimmed
-                    .strip_prefix("mod ")
-                    .or_else(|| trimmed.strip_prefix("pub mod "))
-                    .map(|value| vec![format!("rustmod:{}", value.trim_end_matches(';').trim())])
-            })
             .or_else(|| {
                 trimmed
                     .strip_prefix("extern crate ")
@@ -198,7 +195,10 @@ fn starts_javascript_pending_import(line: &str) -> bool {
 }
 
 fn is_comment_only(line: &str) -> bool {
-    line.starts_with("//") || line.starts_with("/*") || line.starts_with('*') || line.starts_with('#')
+    line.starts_with("//")
+        || line.starts_with("/*")
+        || line.starts_with('*')
+        || line.starts_with('#')
 }
 
 fn rust_visible_use_value(line: &str) -> Option<&str> {

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

@@ -12,13 +12,6 @@ pub(super) fn resolve_import(
     repository_files: &BTreeSet<String>,
 ) -> ImportTarget {
     let language = language_for_path(from_path);
-    if from_path.ends_with(".rs") {
-        if let Some(module) = specifier.strip_prefix("rustmod:") {
-            return resolve_rust_module_declaration(from_path, module, repository_files)
-                .map(ImportTarget::File)
-                .unwrap_or_else(|| ImportTarget::Unknown(specifier.to_string()));
-        }
-    }
     if specifier.starts_with('.') {
         if from_path.ends_with(".py") {
             return resolve_python_relative(from_path, specifier, repository_files)
@@ -42,6 +35,11 @@ pub(super) fn resolve_import(
             return ImportTarget::File(path);
         }
     }
+    if from_path.ends_with(".swift") {
+        if let Some(path) = resolve_swift_module_import(from_path, specifier, repository_files) {
+            return ImportTarget::File(path);
+        }
+    }
     external_target(specifier)
 }
 
@@ -155,19 +153,6 @@ fn resolve_rust_local(
     }
 }
 
-fn resolve_rust_module_declaration(
-    from_path: &str,
-    module: &str,
-    repository_files: &BTreeSet<String>,
-) -> Option<String> {
-    let module = module.trim();
-    if module.is_empty() || module.contains("::") || module.contains('/') {
-        return None;
-    }
-    let module_base = normalize(Path::new(&rust_module_directory(from_path)).join(module));
-    resolve_candidates(&module_base, repository_files, Some("rust"))
-}
-
 fn rust_module_directory(from_path: &str) -> String {
     let source = Path::new(from_path);
     let parent = source.parent().unwrap_or_else(|| Path::new(""));
@@ -217,7 +202,9 @@ fn go_module_for_file(
     from_path: &str,
     repository_files: &BTreeSet<String>,
 ) -> Option<String> {
-    let mut current = Path::new(from_path).parent().unwrap_or_else(|| Path::new(""));
+    let mut current = Path::new(from_path)
+        .parent()
+        .unwrap_or_else(|| Path::new(""));
     loop {
         let go_mod_path = normalize(current.join("go.mod"));
         if repository_files.contains(&go_mod_path) {
@@ -243,6 +230,40 @@ fn go_mod_module(root: &Path, go_mod_path: &str) -> Option<String> {
     })
 }
 
+fn resolve_swift_module_import(
+    from_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    if specifier.contains('/') || specifier.contains('.') {
+        return None;
+    }
+    let sources_root = swift_sources_root(from_path)?;
+    let target_prefix = format!("{sources_root}{specifier}/");
+    let conventional_file = format!("{target_prefix}{specifier}.swift");
+    if repository_files.contains(&conventional_file) {
+        return Some(conventional_file);
+    }
+    repository_files
+        .iter()
+        .find(|path| path.starts_with(&target_prefix) && path.ends_with(".swift"))
+        .cloned()
+}
+
+fn swift_sources_root(from_path: &str) -> Option<String> {
+    if from_path.starts_with("Sources/") {
+        return Some("Sources/".to_string());
+    }
+    if from_path.starts_with("Tests/") {
+        return Some("Sources/".to_string());
+    }
+    if let Some((prefix, _)) = from_path.split_once("/Sources/") {
+        return Some(format!("{prefix}/Sources/"));
+    }
+    let (prefix, _) = from_path.split_once("/Tests/")?;
+    Some(format!("{prefix}/Sources/"))
+}
+
 fn resolve_candidates(
     candidate: &str,
     repository_files: &BTreeSet<String>,
@@ -304,10 +325,11 @@ fn extensions_for_language(language: Option<&str>) -> &'static [&'static str] {
         Some("rust") => &["", ".rs"],
         Some("python") => &["", ".py"],
         Some("go") => &["", ".go"],
+        Some("swift") => &["", ".swift"],
         Some("typescript") => &["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
         Some("javascript") => &["", ".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"],
         _ => &[
-            "", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".rs", ".py", ".go",
+            "", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".rs", ".py", ".go", ".swift",
         ],
     }
 }

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

@@ -26,12 +26,25 @@ pub(super) fn extract_imports(
 }
 
 pub(super) fn package_name(specifier: &str) -> String {
+    let specifier = specifier
+        .split_once(" as ")
+        .map(|(package, _alias)| package)
+        .unwrap_or(specifier)
+        .trim();
     if let Some(rest) = specifier.strip_prefix('@') {
         let mut parts = rest.split('/');
         let scope = parts.next().unwrap_or_default();
         let package = parts.next().unwrap_or_default();
         return format!("@{scope}/{package}");
     }
+    if specifier
+        .split('/')
+        .next()
+        .is_some_and(|prefix| prefix.contains('.'))
+        && specifier.contains('/')
+    {
+        return specifier.to_string();
+    }
     specifier
         .split("::")
         .next()
@@ -39,6 +52,9 @@ pub(super) fn package_name(specifier: &str) -> String {
         .split('/')
         .next()
         .unwrap_or(specifier)
+        .split('.')
+        .next()
+        .unwrap_or(specifier)
         .to_string()
 }
 
@@ -54,6 +70,7 @@ pub(super) fn language_for_path(path: &str) -> Option<&'static str> {
         "rs" => Some("rust"),
         "py" => Some("python"),
         "go" => Some("go"),
+        "swift" => Some("swift"),
         _ => None,
     }
 }

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

@@ -0,0 +1,102 @@
+use std::path::Path;
+
+use crate::architecture::scan::{ManifestDependency, ManifestFact};
+
+pub(super) enum ManifestKind {
+    PackageJson,
+    CargoToml,
+    PyprojectToml,
+    GoMod,
+    PomXml,
+    BuildGradle,
+    PackageSwift,
+    XcodeProject,
+}
+
+pub(super) fn manifest_kind(path: &str) -> Option<ManifestKind> {
+    match path.rsplit('/').next()? {
+        "package.json" => Some(ManifestKind::PackageJson),
+        "Cargo.toml" => Some(ManifestKind::CargoToml),
+        "pyproject.toml" => Some(ManifestKind::PyprojectToml),
+        "go.mod" => Some(ManifestKind::GoMod),
+        "pom.xml" => Some(ManifestKind::PomXml),
+        "build.gradle" | "build.gradle.kts" => Some(ManifestKind::BuildGradle),
+        "Package.swift" => Some(ManifestKind::PackageSwift),
+        "project.pbxproj" => {
+            if path.contains(".xcodeproj/") {
+                Some(ManifestKind::XcodeProject)
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+pub(super) fn fact(
+    path: &str,
+    ecosystem: &str,
+    package_name: String,
+    mut dependencies: Vec<ManifestDependency>,
+    confidence: f32,
+) -> ManifestFact {
+    dependencies.sort_by(|left, right| {
+        left.name
+            .cmp(&right.name)
+            .then(left.dependency_kind.cmp(&right.dependency_kind))
+    });
+    dependencies.dedup_by(|left, right| {
+        left.name == right.name && left.dependency_kind == right.dependency_kind
+    });
+    ManifestFact {
+        path: path.to_string(),
+        ecosystem: ecosystem.to_string(),
+        package_name,
+        dependencies,
+        confidence,
+        extractor: format!("manifest:{}", manifest_kind_label(path)),
+    }
+}
+
+pub(super) fn dependency(
+    name: impl Into<String>,
+    dependency_kind: impl Into<String>,
+    version: Option<String>,
+    confidence: f32,
+) -> ManifestDependency {
+    ManifestDependency {
+        name: name.into(),
+        dependency_kind: dependency_kind.into(),
+        version,
+        confidence,
+    }
+}
+
+pub(super) fn fallback_package_name(path: &str, ecosystem: &str) -> String {
+    let parent = Path::new(path)
+        .parent()
+        .map(|path| path.to_string_lossy().replace('\\', "/"))
+        .filter(|path| !path.is_empty())
+        .unwrap_or_else(|| path.to_string());
+    format!("{ecosystem}:{parent}")
+}
+
+pub(super) fn quoted_value(value: &str) -> Option<String> {
+    let trimmed = value.trim();
+    trimmed
+        .strip_prefix('"')
+        .and_then(|value| value.split_once('"').map(|(value, _)| value.to_string()))
+        .or_else(|| {
+            trimmed
+                .strip_prefix('\'')
+                .and_then(|value| value.split_once('\'').map(|(value, _)| value.to_string()))
+        })
+}
+
+pub(super) fn clean_toml_line(line: &str) -> &str {
+    line.split('#').next().unwrap_or_default().trim()
+}
+
+fn manifest_kind_label(path: &str) -> &str {
+    path.rsplit('/').next().unwrap_or(path)
+}

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

@@ -0,0 +1,46 @@
+use serde_json::Value;
+
+use crate::architecture::scan::{ManifestDependency, ManifestFact};
+
+use super::super::common::{dependency, fact, fallback_package_name};
+
+pub(in crate::architecture::scan::manifest) fn package_json(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let value = serde_json::from_str::<Value>(content).ok()?;
+    let package_name = value
+        .get("name")
+        .and_then(Value::as_str)
+        .map(str::to_string)
+        .unwrap_or_else(|| fallback_package_name(path, "npm"));
+    let mut dependencies = Vec::new();
+    push_dependency_object(&mut dependencies, &value, "dependencies", "runtime");
+    push_dependency_object(&mut dependencies, &value, "devDependencies", "development");
+    push_dependency_object(&mut dependencies, &value, "peerDependencies", "peer");
+    push_dependency_object(
+        &mut dependencies,
+        &value,
+        "optionalDependencies",
+        "optional",
+    );
+    Some(fact(path, "npm", package_name, dependencies, 0.98))
+}
+
+fn push_dependency_object(
+    dependencies: &mut Vec<ManifestDependency>,
+    value: &Value,
+    field: &str,
+    kind: &str,
+) {
+    if let Some(object) = value.get(field).and_then(Value::as_object) {
+        dependencies.extend(object.iter().map(|(name, version)| {
+            dependency(
+                name.clone(),
+                kind,
+                version.as_str().map(str::to_string),
+                0.98,
+            )
+        }));
+    }
+}