@lamentis/naome 1.3.10 → 1.3.11

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

@@ -0,0 +1,334 @@
+use std::collections::BTreeSet;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use super::{external_target, language_for_path};
+use crate::architecture::scan::ImportTarget;
+
+pub(super) fn resolve_import(
+    root: &Path,
+    from_path: &str,
+    specifier: &str,
+    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)
+                .map(ImportTarget::File)
+                .unwrap_or_else(|| ImportTarget::Unknown(specifier.to_string()));
+        }
+        return resolve_relative(from_path, specifier, repository_files, language)
+            .map(ImportTarget::File)
+            .unwrap_or_else(|| ImportTarget::Unknown(specifier.to_string()));
+    }
+    if from_path.ends_with(".rs") && is_rust_local(specifier) {
+        return resolve_rust_local(from_path, specifier, repository_files)
+            .map(ImportTarget::File)
+            .unwrap_or_else(|| ImportTarget::Unknown(specifier.to_string()));
+    }
+    if let Some(path) = resolve_repo_absolute(specifier, repository_files, language) {
+        return ImportTarget::File(path);
+    }
+    if from_path.ends_with(".go") {
+        if let Some(path) = resolve_go_module_path(root, from_path, specifier, repository_files) {
+            return ImportTarget::File(path);
+        }
+    }
+    external_target(specifier)
+}
+
+fn resolve_relative(
+    from_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+    language: Option<&str>,
+) -> Option<String> {
+    let base = Path::new(from_path)
+        .parent()
+        .unwrap_or_else(|| Path::new(""));
+    let candidate = normalize(base.join(specifier));
+    resolve_candidates(&candidate, repository_files, language)
+}
+
+fn resolve_python_relative(
+    from_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    let dots = specifier
+        .chars()
+        .take_while(|character| *character == '.')
+        .count();
+    let module = specifier[dots..].replace('.', "/");
+    let mut base = Path::new(from_path)
+        .parent()
+        .unwrap_or_else(|| Path::new(""));
+    for _ in 1..dots {
+        base = base.parent().unwrap_or_else(|| Path::new(""));
+    }
+    resolve_progressively(
+        &normalize(base.join(module)),
+        repository_files,
+        Some("python"),
+        '/',
+    )
+}
+
+fn resolve_repo_absolute(
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+    language: Option<&str>,
+) -> Option<String> {
+    let candidate = specifier.strip_prefix("@/").unwrap_or(specifier);
+    if candidate.starts_with("src/")
+        || candidate.starts_with("packages/")
+        || candidate.starts_with("apps/")
+    {
+        return resolve_candidates(candidate, repository_files, language);
+    }
+    let dotted_candidate = specifier.replace('.', "/");
+    if dotted_candidate.starts_with("src/")
+        || dotted_candidate.starts_with("packages/")
+        || dotted_candidate.starts_with("apps/")
+    {
+        return resolve_progressively(&dotted_candidate, repository_files, language, '/');
+    }
+    None
+}
+
+fn resolve_rust_local(
+    from_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    let mut parts = specifier
+        .split("::")
+        .map(str::trim)
+        .filter(|part| !part.is_empty())
+        .collect::<Vec<_>>();
+    if parts.is_empty() {
+        return None;
+    }
+    match parts[0] {
+        "crate" => {
+            parts.remove(0);
+            let crate_root = rust_crate_src_root(from_path);
+            resolve_progressively(
+                &normalize(Path::new(&crate_root).join(parts.join("/"))),
+                repository_files,
+                Some("rust"),
+                '/',
+            )
+        }
+        "self" => {
+            parts.remove(0);
+            let base = PathBuf::from(rust_module_directory(from_path));
+            resolve_progressively(
+                &normalize(base.join(parts.join("/"))),
+                repository_files,
+                Some("rust"),
+                '/',
+            )
+        }
+        "super" => {
+            let mut base = PathBuf::from(rust_module_directory(from_path));
+            while parts.first() == Some(&"super") {
+                parts.remove(0);
+                base.pop();
+            }
+            resolve_progressively(
+                &normalize(base.join(parts.join("/"))),
+                repository_files,
+                Some("rust"),
+                '/',
+            )
+        }
+        _ => None,
+    }
+}
+
+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(""));
+    let stem = source
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .unwrap_or("");
+    if matches!(stem, "lib" | "main" | "mod") {
+        normalize(parent)
+    } else {
+        normalize(parent.join(stem))
+    }
+}
+
+fn rust_crate_src_root(from_path: &str) -> String {
+    let parts = from_path.split('/').collect::<Vec<_>>();
+    if let Some(index) = parts.iter().rposition(|part| *part == "src") {
+        return parts[..=index].join("/");
+    }
+    "src".to_string()
+}
+
+fn resolve_go_module_path(
+    root: &Path,
+    from_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    let module = go_module_for_file(root, from_path, repository_files)?;
+    let suffix = specifier.strip_prefix(&module)?;
+    let suffix = suffix.strip_prefix('/')?;
+    if suffix.is_empty() {
+        return None;
+    }
+    if let Some(path) = resolve_candidates(suffix, repository_files, Some("go")) {
+        return Some(path);
+    }
+    let package_prefix = format!("{suffix}/");
+    repository_files
+        .iter()
+        .find(|path| path.starts_with(&package_prefix) && path.ends_with(".go"))
+        .cloned()
+}
+
+fn go_module_for_file(
+    root: &Path,
+    from_path: &str,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    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) {
+            return go_mod_module(root, &go_mod_path);
+        }
+        let Some(parent) = current.parent() else {
+            break;
+        };
+        if parent == current {
+            break;
+        }
+        current = parent;
+    }
+    None
+}
+
+fn go_mod_module(root: &Path, go_mod_path: &str) -> Option<String> {
+    let content = fs::read_to_string(root.join(go_mod_path)).ok()?;
+    content.lines().find_map(|line| {
+        let line = line.trim();
+        let module = line.strip_prefix("module ")?;
+        module.split_whitespace().next().map(ToString::to_string)
+    })
+}
+
+fn resolve_candidates(
+    candidate: &str,
+    repository_files: &BTreeSet<String>,
+    language: Option<&str>,
+) -> Option<String> {
+    candidate_paths(candidate, language)
+        .into_iter()
+        .find(|path| repository_files.contains(path))
+}
+
+fn resolve_progressively(
+    candidate: &str,
+    repository_files: &BTreeSet<String>,
+    language: Option<&str>,
+    separator: char,
+) -> Option<String> {
+    let mut current = candidate.to_string();
+    loop {
+        if let Some(path) = resolve_candidates(&current, repository_files, language) {
+            return Some(path);
+        }
+        let Some((parent, _)) = current.rsplit_once(separator) else {
+            return None;
+        };
+        current = parent.to_string();
+    }
+}
+
+fn candidate_paths(candidate: &str, language: Option<&str>) -> Vec<String> {
+    let extensions = extensions_for_language(language);
+    let mut candidates = extensions
+        .iter()
+        .map(|extension| format!("{candidate}{extension}"))
+        .collect::<Vec<_>>();
+    match language {
+        Some("rust") => candidates.push(format!("{candidate}/mod.rs")),
+        Some("python") => candidates.push(format!("{candidate}/__init__.py")),
+        Some("go") => {}
+        Some("typescript") | Some("javascript") => candidates.extend([
+            format!("{candidate}/index.ts"),
+            format!("{candidate}/index.tsx"),
+            format!("{candidate}/index.js"),
+            format!("{candidate}/index.jsx"),
+        ]),
+        _ => candidates.extend([
+            format!("{candidate}/index.ts"),
+            format!("{candidate}/index.tsx"),
+            format!("{candidate}/index.js"),
+            format!("{candidate}/index.jsx"),
+            format!("{candidate}/mod.rs"),
+            format!("{candidate}/__init__.py"),
+        ]),
+    }
+    candidates
+}
+
+fn extensions_for_language(language: Option<&str>) -> &'static [&'static str] {
+    match language {
+        Some("rust") => &["", ".rs"],
+        Some("python") => &["", ".py"],
+        Some("go") => &["", ".go"],
+        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",
+        ],
+    }
+}
+
+fn is_rust_local(specifier: &str) -> bool {
+    specifier.starts_with("crate::")
+        || specifier.starts_with("self::")
+        || specifier.starts_with("super::")
+        || specifier.starts_with('.')
+}
+
+fn normalize(path: impl AsRef<Path>) -> String {
+    let mut normalized = PathBuf::new();
+    for component in path.as_ref().components() {
+        match component {
+            std::path::Component::ParentDir => {
+                normalized.pop();
+            }
+            std::path::Component::CurDir => {}
+            other => normalized.push(other.as_os_str()),
+        }
+    }
+    normalized.to_string_lossy().replace('\\', "/")
+}

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

@@ -0,0 +1,59 @@
+use std::collections::BTreeSet;
+use std::path::Path;
+
+use super::{ImportFact, ImportTarget};
+
+mod extractors;
+mod resolver;
+
+pub(super) fn extract_imports(
+    root: &Path,
+    path: &str,
+    content: &str,
+    repository_files: &BTreeSet<String>,
+) -> Vec<ImportFact> {
+    let raw_imports = extractors::extract_raw_imports(path, content);
+    raw_imports
+        .into_iter()
+        .map(|raw| ImportFact {
+            target: resolver::resolve_import(root, path, &raw.specifier, repository_files),
+            specifier: raw.specifier,
+            source_range: Some(raw.source_range),
+            confidence: raw.confidence,
+            extractor: raw.extractor,
+        })
+        .collect()
+}
+
+pub(super) fn package_name(specifier: &str) -> String {
+    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}");
+    }
+    specifier
+        .split("::")
+        .next()
+        .unwrap_or(specifier)
+        .split('/')
+        .next()
+        .unwrap_or(specifier)
+        .to_string()
+}
+
+pub(super) fn external_target(specifier: &str) -> ImportTarget {
+    ImportTarget::ExternalDependency(package_name(specifier))
+}
+
+pub(super) fn language_for_path(path: &str) -> Option<&'static str> {
+    let extension = path.rsplit('.').next()?;
+    match extension {
+        "ts" | "tsx" => Some("typescript"),
+        "js" | "jsx" | "mjs" | "cjs" => Some("javascript"),
+        "rs" => Some("rust"),
+        "py" => Some("python"),
+        "go" => Some("go"),
+        _ => None,
+    }
+}

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

@@ -10,6 +10,7 @@ use super::config::{read_architecture_config, ArchitectureConfig};
 use super::model::ArchitectureGraph;
 
 mod graph_builder;
+mod imports;
 mod path_scan;
 
 #[derive(Debug, Clone, Default)]
@@ -42,6 +43,25 @@ pub struct FileFact {
     pub layers: Vec<String>,
     pub contexts: Vec<String>,
     pub ignored: Option<String>,
+    pub imports: Vec<ImportFact>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportFact {
+    pub specifier: String,
+    pub target: ImportTarget,
+    pub source_range: Option<super::model::SourceRange>,
+    pub confidence: f32,
+    pub extractor: String,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub enum ImportTarget {
+    File(String),
+    ExternalDependency(String),
+    Unknown(String),
 }
 
 pub fn scan_architecture(