@lamentis/naome 1.3.9 → 1.3.11

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

@@ -0,0 +1,211 @@
+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};
+
+mod emit;
+mod facts;
+
+pub(super) fn build_path_graph(
+    root: &Path,
+    files: Vec<String>,
+    config: &ArchitectureConfig,
+) -> (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 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)
+}
+
+fn push_repository_and_policy_nodes(graph: &mut ArchitectureGraph, config: &ArchitectureConfig) {
+    emit::push_node(
+        graph,
+        "repository:.",
+        ArchitectureNodeKind::Repository,
+        "repository",
+        None,
+        None,
+        json!({ "root": "." }),
+    );
+    for layer in config.layers.keys() {
+        emit::push_node(
+            graph,
+            &format!("layer:{layer}"),
+            ArchitectureNodeKind::Layer,
+            layer,
+            None,
+            None,
+            json!({ "layer": layer }),
+        );
+    }
+    for context in config.contexts.keys() {
+        emit::push_node(
+            graph,
+            &format!("context:{context}"),
+            ArchitectureNodeKind::BoundedContext,
+            context,
+            None,
+            None,
+            json!({ "context": context }),
+        );
+    }
+}
+
+fn push_directories(graph: &mut ArchitectureGraph, files: &[String]) {
+    let mut directories = BTreeSet::new();
+    for path in files {
+        facts::collect_directories(path, &mut directories);
+    }
+    for directory in directories {
+        emit::push_node(
+            graph,
+            &format!("directory:{directory}"),
+            ArchitectureNodeKind::Directory,
+            &directory,
+            Some(directory.clone()),
+            None,
+            json!({ "path": directory }),
+        );
+        emit::push_edge(
+            graph,
+            "repository:.",
+            &format!("directory:{directory}"),
+            ArchitectureEdgeKind::Contains,
+            "contains",
+            Some(directory),
+        );
+    }
+}
+
+fn push_file(graph: &mut ArchitectureGraph, fact: &FileFact) {
+    let path = &fact.path;
+    emit::push_node(
+        graph,
+        &format!("file:{path}"),
+        ArchitectureNodeKind::File,
+        path,
+        Some(path.clone()),
+        fact.language.clone(),
+        json!({ "path": path, "extractor": "path" }),
+    );
+    emit::push_edge(
+        graph,
+        facts::parent_node_id(path)
+            .as_deref()
+            .unwrap_or("repository:."),
+        &format!("file:{path}"),
+        ArchitectureEdgeKind::Contains,
+        "contains",
+        Some(path.clone()),
+    );
+    push_membership_edges(graph, path, "layer", &fact.layers);
+    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,
+    prefix: &str,
+    names: &[String],
+) {
+    for name in names {
+        emit::push_edge(
+            graph,
+            &format!("{prefix}:{name}"),
+            &format!("file:{path}"),
+            ArchitectureEdgeKind::Contains,
+            "contains",
+            Some(path.to_string()),
+        );
+    }
+}
+
+fn stable_fragment(value: &str) -> String {
+    value
+        .chars()
+        .map(|character| {
+            if character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.' | '/') {
+                character
+            } else {
+                '_'
+            }
+        })
+        .collect()
+}

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

@@ -0,0 +1,407 @@
+use super::language_for_path;
+use crate::architecture::model::SourceRange;
+
+#[derive(Debug, Clone)]
+pub(super) struct RawImport {
+    pub specifier: String,
+    pub source_range: SourceRange,
+    pub confidence: f32,
+    pub extractor: String,
+}
+
+pub(super) fn extract_raw_imports(path: &str, content: &str) -> Vec<RawImport> {
+    match language_for_path(path) {
+        Some("typescript" | "javascript") => extract_javascript_like(content),
+        Some("rust") => extract_rust(content),
+        Some("python") => extract_python(content),
+        Some("go") => extract_go(content),
+        _ => Vec::new(),
+    }
+}
+
+fn extract_javascript_like(content: &str) -> Vec<RawImport> {
+    let mut imports = Vec::new();
+    let mut pending_statement: Option<(usize, String)> = None;
+    for (index, line) in content.lines().enumerate() {
+        let trimmed = line.trim();
+        if is_comment_only(trimmed) {
+            continue;
+        }
+        if let Some((start_index, statement)) = pending_statement.as_mut() {
+            if !statement.is_empty() {
+                statement.push(' ');
+            }
+            statement.push_str(trimmed);
+            if let Some(specifier) = javascript_statement_specifier(statement) {
+                imports.push(raw_range(
+                    specifier,
+                    *start_index,
+                    index,
+                    line,
+                    0.86,
+                    "import:javascript",
+                ));
+                pending_statement = None;
+            } else if trimmed.ends_with(';') {
+                pending_statement = None;
+            }
+            continue;
+        }
+
+        let specifier = javascript_statement_specifier(trimmed);
+        if let Some(specifier) = specifier {
+            imports.push(raw(specifier, index, line, 0.86, "import:javascript"));
+        } else if starts_javascript_pending_import(trimmed) && !trimmed.ends_with(';') {
+            pending_statement = Some((index, trimmed.to_string()));
+        }
+    }
+    imports
+}
+
+fn extract_rust(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 specifiers = trimmed
+            .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 ")
+                    .map(|value| vec![value.trim_end_matches(';').trim().to_string()])
+            })
+            .unwrap_or_default();
+        for specifier in specifiers.into_iter().filter(|value| !value.is_empty()) {
+            imports.push(raw(specifier, index, line, 0.82, "import:rust"));
+        }
+    }
+    imports
+}
+
+fn extract_python(content: &str) -> Vec<RawImport> {
+    let mut imports = Vec::new();
+    let mut pending_from: Option<(usize, String, String)> = None;
+    for (index, line) in content.lines().enumerate() {
+        let trimmed = line.trim();
+        if let Some((start_index, module, imports_text)) = pending_from.as_mut() {
+            imports_text.push_str(trimmed.trim_end_matches(')').trim());
+            imports_text.push(',');
+            if trimmed.contains(')') {
+                for specifier in python_from_import_specifiers_from_parts(module, imports_text) {
+                    imports.push(raw_range(
+                        specifier,
+                        *start_index,
+                        index,
+                        line,
+                        0.82,
+                        "import:python",
+                    ));
+                }
+                pending_from = None;
+            }
+            continue;
+        }
+        let specifiers = if let Some(value) = trimmed.strip_prefix("from ") {
+            if let Some((module, imports_text)) = python_multiline_from_import_start(value) {
+                pending_from = Some((index, module, imports_text));
+                Vec::new()
+            } else {
+                python_from_import_specifiers(value)
+            }
+        } else if let Some(value) = trimmed.strip_prefix("import ") {
+            python_import_specifiers(value)
+        } else {
+            Vec::new()
+        };
+        for specifier in specifiers {
+            imports.push(raw(specifier, index, line, 0.82, "import:python"));
+        }
+    }
+    imports
+}
+
+fn extract_go(content: &str) -> Vec<RawImport> {
+    let mut imports = Vec::new();
+    let mut in_block = false;
+    for (index, line) in content.lines().enumerate() {
+        let trimmed = line.trim();
+        if is_comment_only(trimmed) {
+            continue;
+        }
+        if trimmed == "import (" {
+            in_block = true;
+            continue;
+        }
+        if in_block && trimmed == ")" {
+            in_block = false;
+            continue;
+        }
+        let specifier = if in_block {
+            first_quoted(trimmed)
+        } else if let Some(value) = trimmed.strip_prefix("import ") {
+            first_quoted(value)
+        } else {
+            None
+        };
+        if let Some(specifier) = specifier {
+            imports.push(raw(specifier, index, line, 0.9, "import:go"));
+        }
+    }
+    imports
+}
+
+fn quoted_after_keyword(line: &str, keyword: &str) -> Option<String> {
+    let start = line.find(keyword)? + keyword.len();
+    first_quoted(&line[start..])
+}
+
+fn javascript_static_specifier(line: &str) -> Option<String> {
+    quoted_after_keyword(line, " from ").or_else(|| first_quoted(line))
+}
+
+fn javascript_declaration_specifier(line: &str) -> Option<String> {
+    if line.starts_with("import ") {
+        javascript_static_specifier(line)
+    } else if line.starts_with("export ") {
+        quoted_after_keyword(line, " from ")
+    } else {
+        None
+    }
+}
+
+fn javascript_statement_specifier(line: &str) -> Option<String> {
+    if starts_javascript_static_import(line) {
+        javascript_declaration_specifier(line)
+    } else if line.contains("require(") || line.contains("import(") {
+        first_quoted(line)
+    } else {
+        None
+    }
+}
+
+fn starts_javascript_static_import(line: &str) -> bool {
+    line.starts_with("import ") || line.starts_with("export ")
+}
+
+fn starts_javascript_pending_import(line: &str) -> bool {
+    starts_javascript_static_import(line) || line.contains("import(") || line.contains("require(")
+}
+
+fn is_comment_only(line: &str) -> bool {
+    line.starts_with("//") || line.starts_with("/*") || line.starts_with('*') || line.starts_with('#')
+}
+
+fn rust_visible_use_value(line: &str) -> Option<&str> {
+    let (visibility, value) = line.split_once(" use ")?;
+    if visibility == "pub" || visibility.starts_with("pub(") {
+        Some(value)
+    } else {
+        None
+    }
+}
+
+fn rust_use_specifiers(value: &str) -> Vec<String> {
+    let value = value.trim_end_matches(';').trim();
+    rust_expand_use_tree("", value)
+        .into_iter()
+        .map(|specifier| rust_strip_alias(&specifier))
+        .filter(|specifier| !specifier.is_empty())
+        .collect()
+}
+
+fn rust_expand_use_tree(prefix: &str, value: &str) -> Vec<String> {
+    split_top_level_commas(value)
+        .into_iter()
+        .flat_map(|item| {
+            let item = item.trim();
+            let Some(open) = top_level_char(item, '{') else {
+                return vec![rust_join_path(prefix, item)];
+            };
+            let Some(close) = matching_brace(item, open) else {
+                return vec![rust_join_path(prefix, item)];
+            };
+            let nested_prefix = rust_join_path(prefix, item[..open].trim());
+            rust_expand_use_tree(&nested_prefix, &item[open + 1..close])
+        })
+        .collect()
+}
+
+fn split_top_level_commas(value: &str) -> Vec<&str> {
+    let mut parts = Vec::new();
+    let mut depth = 0usize;
+    let mut start = 0usize;
+    for (index, character) in value.char_indices() {
+        match character {
+            '{' => depth += 1,
+            '}' => depth = depth.saturating_sub(1),
+            ',' if depth == 0 => {
+                parts.push(&value[start..index]);
+                start = index + 1;
+            }
+            _ => {}
+        }
+    }
+    parts.push(&value[start..]);
+    parts
+}
+
+fn top_level_char(value: &str, needle: char) -> Option<usize> {
+    let mut depth = 0usize;
+    for (index, character) in value.char_indices() {
+        match character {
+            '{' if depth == 0 && character == needle => return Some(index),
+            '{' => depth += 1,
+            '}' => depth = depth.saturating_sub(1),
+            _ => {}
+        }
+    }
+    None
+}
+
+fn matching_brace(value: &str, open: usize) -> Option<usize> {
+    let mut depth = 0usize;
+    for (index, character) in value[open..].char_indices() {
+        match character {
+            '{' => depth += 1,
+            '}' => {
+                depth = depth.saturating_sub(1);
+                if depth == 0 {
+                    return Some(open + index);
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+fn rust_join_path(prefix: &str, item: &str) -> String {
+    let prefix = prefix.trim().trim_end_matches("::");
+    let item = item.trim().trim_start_matches("::");
+    match (prefix.is_empty(), item.is_empty()) {
+        (true, _) => item.to_string(),
+        (_, true) => prefix.to_string(),
+        _ => format!("{prefix}::{item}"),
+    }
+}
+
+fn rust_strip_alias(value: &str) -> String {
+    value
+        .split_once(" as ")
+        .map(|(specifier, _)| specifier)
+        .unwrap_or(value)
+        .trim()
+        .to_string()
+}
+
+fn python_from_import_specifiers(value: &str) -> Vec<String> {
+    let Some((module, imports)) = value.split_once(" import ") else {
+        return Vec::new();
+    };
+    python_from_import_specifiers_from_parts(module, imports)
+}
+
+fn python_from_import_specifiers_from_parts(module: &str, imports: &str) -> Vec<String> {
+    let module = module.trim();
+    python_imported_names(imports)
+        .into_iter()
+        .map(|name| {
+            if module.chars().all(|character| character == '.') {
+                format!("{module}{name}")
+            } else {
+                format!("{module}.{name}")
+            }
+        })
+        .filter(|specifier| !specifier.is_empty())
+        .collect()
+}
+
+fn python_multiline_from_import_start(value: &str) -> Option<(String, String)> {
+    let (module, imports) = value.split_once(" import ")?;
+    let imports = imports.trim();
+    if !imports.starts_with('(') || imports.contains(')') {
+        return None;
+    }
+    Some((
+        module.trim().to_string(),
+        imports.trim_start_matches('(').to_string(),
+    ))
+}
+
+fn python_import_specifiers(value: &str) -> Vec<String> {
+    python_imported_names(value)
+}
+
+fn python_imported_names(value: &str) -> Vec<String> {
+    value
+        .trim()
+        .trim_start_matches('(')
+        .trim_end_matches(')')
+        .split(',')
+        .filter_map(|part| {
+            part.split_whitespace()
+                .next()
+                .map(|name| name.trim())
+                .filter(|name| !name.is_empty() && *name != "*")
+                .map(ToString::to_string)
+        })
+        .collect()
+}
+
+fn first_quoted(value: &str) -> Option<String> {
+    for quote in ['"', '\'', '`'] {
+        let Some(start) = value.find(quote).map(|index| index + 1) else {
+            continue;
+        };
+        let Some(end) = value[start..].find(quote).map(|index| index + start) else {
+            continue;
+        };
+        if end > start {
+            return Some(value[start..end].to_string());
+        }
+    }
+    None
+}
+
+fn raw(
+    specifier: String,
+    line_index: usize,
+    line: &str,
+    confidence: f32,
+    extractor: &str,
+) -> RawImport {
+    raw_range(
+        specifier, line_index, line_index, line, confidence, extractor,
+    )
+}
+
+fn raw_range(
+    specifier: String,
+    start_line_index: usize,
+    end_line_index: usize,
+    end_line: &str,
+    confidence: f32,
+    extractor: &str,
+) -> RawImport {
+    RawImport {
+        specifier,
+        source_range: SourceRange {
+            start_line: start_line_index + 1,
+            start_column: 1,
+            end_line: end_line_index + 1,
+            end_column: end_line.len() + 1,
+        },
+        confidence,
+        extractor: extractor.to_string(),
+    }
+}