@lamentis/naome 1.3.15 → 1.3.17

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

@@ -5,6 +5,11 @@ use std::path::{Path, PathBuf};
 use super::{external_target, language_for_path};
 use crate::architecture::scan::ImportTarget;
 
+mod candidates;
+mod js_ts_alias;
+
+use candidates::{resolve_candidates, resolve_progressively};
+
 pub(super) fn resolve_import(
     root: &Path,
     from_path: &str,
@@ -27,9 +32,30 @@ pub(super) fn resolve_import(
             .map(ImportTarget::File)
             .unwrap_or_else(|| ImportTarget::Unknown(specifier.to_string()));
     }
+    if matches!(language, Some("typescript") | Some("javascript")) {
+        match js_ts_alias::resolve(root, from_path, specifier, repository_files, language) {
+            Some(js_ts_alias::AliasResolution::Resolved(path)) => return ImportTarget::File(path),
+            Some(js_ts_alias::AliasResolution::Unresolved) => {
+                return ImportTarget::Unknown(specifier.to_string());
+            }
+            None => {}
+        }
+    }
     if let Some(path) = resolve_repo_absolute(specifier, repository_files, language) {
         return ImportTarget::File(path);
     }
+    if is_repo_absolute_specifier(specifier) {
+        return ImportTarget::Unknown(specifier.to_string());
+    }
+    if from_path.ends_with(".py") {
+        if let Some(path) = resolve_python_absolute_package(from_path, specifier, repository_files)
+        {
+            return ImportTarget::File(path);
+        }
+        if is_python_local_package_specifier(from_path, specifier, repository_files) {
+            return ImportTarget::Unknown(specifier.to_string());
+        }
+    }
     if from_path.ends_with(".go") {
         if let Some(path) = resolve_go_module_path(root, from_path, specifier, repository_files) {
             return ImportTarget::File(path);
@@ -72,12 +98,7 @@ fn resolve_python_relative(
     for _ in 1..dots {
         base = base.parent().unwrap_or_else(|| Path::new(""));
     }
-    resolve_progressively(
-        &normalize(base.join(module)),
-        repository_files,
-        Some("python"),
-        '/',
-    )
+    resolve_python_package_candidate(&normalize(base.join(module)), repository_files)
 }
 
 fn resolve_repo_absolute(
@@ -102,6 +123,86 @@ fn resolve_repo_absolute(
     None
 }
 
+fn resolve_python_absolute_package(
+    from_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    if specifier.contains('/') {
+        return None;
+    }
+    let dotted_candidate = specifier.replace('.', "/");
+    let package_name = dotted_candidate.split('/').next()?;
+    python_package_roots(package_name, from_path, repository_files)
+        .into_iter()
+        .find_map(|root| {
+            resolve_python_package_candidate(&format!("{root}{dotted_candidate}"), repository_files)
+        })
+}
+
+fn resolve_python_package_candidate(
+    candidate: &str,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    resolve_candidates(candidate, repository_files, Some("python")).or_else(|| {
+        let (module_candidate, _) = candidate.rsplit_once('/')?;
+        resolve_candidates(module_candidate, repository_files, Some("python"))
+            .filter(|path| !path.ends_with("/__init__.py"))
+    })
+}
+
+fn is_python_local_package_specifier(
+    from_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+) -> bool {
+    if specifier.contains('/') || !specifier.contains('.') {
+        return false;
+    }
+    let Some(package_name) = specifier.split('.').next() else {
+        return false;
+    };
+    !python_package_roots(package_name, from_path, repository_files).is_empty()
+}
+
+fn python_package_roots(
+    package_name: &str,
+    from_path: &str,
+    repository_files: &BTreeSet<String>,
+) -> Vec<String> {
+    let package_marker = format!("{package_name}/__init__.py");
+    let module_marker = format!("{package_name}.py");
+    let mut roots = repository_files
+        .iter()
+        .filter_map(|path| {
+            if path == &package_marker || path == &module_marker {
+                Some(String::new())
+            } else if let Some(prefix) = path.strip_suffix(&package_marker) {
+                Some(prefix.to_string())
+            } else {
+                path.strip_suffix(&module_marker).map(ToString::to_string)
+            }
+        })
+        .collect::<Vec<_>>();
+    roots.sort_by(|left, right| {
+        let left_local = from_path.starts_with(left.as_str());
+        let right_local = from_path.starts_with(right.as_str());
+        right_local
+            .cmp(&left_local)
+            .then_with(|| right.len().cmp(&left.len()))
+            .then_with(|| left.cmp(right))
+    });
+    roots.dedup();
+    roots
+}
+
+fn is_repo_absolute_specifier(specifier: &str) -> bool {
+    specifier.starts_with("@/")
+        || specifier.starts_with("src/")
+        || specifier.starts_with("packages/")
+        || specifier.starts_with("apps/")
+}
+
 fn resolve_rust_local(
     from_path: &str,
     specifier: &str,
@@ -119,22 +220,27 @@ fn resolve_rust_local(
         "crate" => {
             parts.remove(0);
             let crate_root = rust_crate_src_root(from_path);
-            resolve_progressively(
+            let allow_root_fallback = parts.len() == 1;
+            resolve_rust_path_candidate(
                 &normalize(Path::new(&crate_root).join(parts.join("/"))),
                 repository_files,
-                Some("rust"),
-                '/',
             )
+            .or_else(|| {
+                allow_root_fallback
+                    .then(|| rust_crate_root_file(&crate_root, repository_files))
+                    .flatten()
+            })
         }
         "self" => {
             parts.remove(0);
             let base = PathBuf::from(rust_module_directory(from_path));
-            resolve_progressively(
-                &normalize(base.join(parts.join("/"))),
-                repository_files,
-                Some("rust"),
-                '/',
-            )
+            let allow_module_fallback = parts.len() == 1;
+            resolve_rust_path_candidate(&normalize(base.join(parts.join("/"))), repository_files)
+                .or_else(|| {
+                    allow_module_fallback
+                        .then(|| rust_module_file_for_directory(&base, repository_files))
+                        .flatten()
+                })
         }
         "super" => {
             let mut base = PathBuf::from(rust_module_directory(from_path));
@@ -142,17 +248,52 @@ fn resolve_rust_local(
                 parts.remove(0);
                 base.pop();
             }
-            resolve_progressively(
-                &normalize(base.join(parts.join("/"))),
-                repository_files,
-                Some("rust"),
-                '/',
-            )
+            let allow_module_fallback = parts.len() == 1;
+            resolve_rust_path_candidate(&normalize(base.join(parts.join("/"))), repository_files)
+                .or_else(|| {
+                    allow_module_fallback
+                        .then(|| rust_module_file_for_directory(&base, repository_files))
+                        .flatten()
+                })
         }
         _ => None,
     }
 }
 
+fn resolve_rust_path_candidate(
+    candidate: &str,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    resolve_candidates(candidate, repository_files, Some("rust")).or_else(|| {
+        let (module_candidate, _) = candidate.rsplit_once('/')?;
+        resolve_candidates(module_candidate, repository_files, Some("rust"))
+    })
+}
+
+fn rust_crate_root_file(crate_root: &str, repository_files: &BTreeSet<String>) -> Option<String> {
+    ["lib.rs", "main.rs"]
+        .iter()
+        .map(|file_name| normalize(Path::new(crate_root).join(file_name)))
+        .find(|path| repository_files.contains(path))
+}
+
+fn rust_module_file_for_directory(
+    directory: &Path,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    let normalized = normalize(directory);
+    let mut candidates = Vec::new();
+    if !normalized.is_empty() {
+        candidates.push(format!("{normalized}.rs"));
+        candidates.push(format!("{normalized}/mod.rs"));
+        candidates.push(format!("{normalized}/lib.rs"));
+        candidates.push(format!("{normalized}/main.rs"));
+    }
+    candidates
+        .into_iter()
+        .find(|path| repository_files.contains(path))
+}
+
 fn rust_module_directory(from_path: &str) -> String {
     let source = Path::new(from_path);
     let parent = source.parent().unwrap_or_else(|| Path::new(""));
@@ -264,76 +405,6 @@ fn swift_sources_root(from_path: &str) -> Option<String> {
     Some(format!("{prefix}/Sources/"))
 }
 
-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("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", ".swift",
-        ],
-    }
-}
-
 fn is_rust_local(specifier: &str) -> bool {
     specifier.starts_with("crate::")
         || specifier.starts_with("self::")

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

@@ -19,6 +19,22 @@ mod imports;
 mod manifest;
 mod path_scan;
 
+const IMPORT_RESOLVER_CONTEXT_FILENAMES: &[&str] = &[
+    "Cargo.toml",
+    "Cartfile",
+    "Package.swift",
+    "Podfile",
+    "build.gradle",
+    "build.gradle.kts",
+    "go.mod",
+    "jsconfig.json",
+    "package.json",
+    "pom.xml",
+    "project.pbxproj",
+    "pyproject.toml",
+    "tsconfig.json",
+];
+
 #[derive(Debug, Clone, Default)]
 pub struct ArchitectureScanOptions {
     pub config_path: Option<PathBuf>,
@@ -262,12 +278,10 @@ fn cached_clean_content_changed(
 }
 
 fn import_resolver_context_changed(changed_paths: &[String]) -> bool {
-    changed_paths.iter().any(|path| {
-        Path::new(path)
-            .file_name()
-            .and_then(|value| value.to_str())
-            .is_some_and(|name| matches!(name, "go.mod" | "tsconfig.json" | "jsconfig.json"))
-    })
+    changed_paths
+        .iter()
+        .filter_map(|path| Path::new(path).file_name()?.to_str())
+        .any(|name| IMPORT_RESOLVER_CONTEXT_FILENAMES.contains(&name))
 }
 
 fn degraded_full_scan(

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

@@ -1,4 +1,6 @@
 mod config;
+mod config_findings;
+mod explain;
 mod model;
 mod output;
 mod rules;
@@ -11,13 +13,15 @@ use crate::models::NaomeError;
 pub use config::{
     default_architecture_config_text, ArchitectureConfig, ContextConfig, LayerConfig, RuleConfig,
 };
+pub use config_findings::config_findings_for;
+pub use explain::format_architecture_explain;
 pub use model::{
     ArchitectureEdge, ArchitectureEdgeKind, ArchitectureGraph, ArchitectureMetadata,
     ArchitectureNode, ArchitectureNodeKind, Severity, SourceRange,
 };
 pub use output::{
-    format_architecture_explain, format_architecture_scan, format_architecture_validation,
-    ArchitectureAgentFeedback, ArchitectureValidation, ArchitectureViolation, ViolationSummary,
+    format_architecture_scan, format_architecture_validation, ArchitectureAgentFeedback,
+    ArchitectureConfigFinding, ArchitectureValidation, ArchitectureViolation, ViolationSummary,
     ARCHITECTURE_RULE_IDS,
 };
 pub use scan::{scan_architecture, ArchitectureScanOptions, ArchitectureScanReport};

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

@@ -21,13 +21,13 @@ mod verification_contract_policy;
 mod workflow;
 
 pub use architecture::{
-    default_architecture_config_text, format_architecture_explain, format_architecture_scan,
-    format_architecture_validation, scan_architecture, validate_architecture,
-    ArchitectureAgentFeedback, ArchitectureConfig, ArchitectureEdge, ArchitectureEdgeKind,
-    ArchitectureGraph, ArchitectureMetadata, ArchitectureNode, ArchitectureNodeKind,
-    ArchitectureScanOptions, ArchitectureScanReport, ArchitectureValidation, ArchitectureViolation,
-    ContextConfig, LayerConfig, RuleConfig, Severity, SourceRange, ViolationSummary,
-    ARCHITECTURE_RULE_IDS,
+    config_findings_for, default_architecture_config_text, format_architecture_explain,
+    format_architecture_scan, format_architecture_validation, scan_architecture,
+    validate_architecture, ArchitectureAgentFeedback, ArchitectureConfig,
+    ArchitectureConfigFinding, ArchitectureEdge, ArchitectureEdgeKind, 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,
@@ -44,6 +44,7 @@ pub use install_plan::{MACHINE_OWNED_PATHS, PROJECT_OWNED_PATHS};
 pub use intent::{evaluate_intent, format_intent, IntentDecision, PromptEvidence};
 pub use journal::{append_task_journal, TaskJournalEntry};
 pub use models::{Decision, NaomeError};
+pub use paths::{matches_any as path_matches_any, naomeignore_patterns};
 pub use quality::{
     check_repository_quality, check_repository_quality_paths, check_semantic_legacy,
     check_semantic_legacy_paths, clear_quality_cache, explain_repository_structure,

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

@@ -376,6 +376,36 @@ fn unresolved_relative_imports_are_represented_explicitly() {
     }));
 }
 
+#[test]
+fn rust_root_module_item_imports_resolve_to_crate_root_files() {
+    let repo = FixtureRepo::new();
+    repo.write(
+        "src/lib.rs",
+        "pub fn repository_model_drift() {}\npub fn matches_any() {}\n",
+    );
+    repo.write(
+        "src/quality/mod.rs",
+        "use crate::repository_model_drift;\npub fn check() { repository_model_drift(); }\n",
+    );
+    repo.write(
+        "src/paths.rs",
+        "use super::matches_any;\npub fn check() { matches_any(); }\n",
+    );
+
+    let scan = scan_architecture(repo.path(), ArchitectureScanOptions::default()).unwrap();
+
+    assert!(scan.graph.edges.iter().any(|edge| {
+        edge.kind == ArchitectureEdgeKind::Imports
+            && edge.from == "file:src/quality/mod.rs"
+            && edge.to == "file:src/lib.rs"
+    }));
+    assert!(scan.graph.edges.iter().any(|edge| {
+        edge.kind == ArchitectureEdgeKind::Imports
+            && edge.from == "file:src/paths.rs"
+            && edge.to == "file:src/lib.rs"
+    }));
+}
+
 #[test]
 fn validates_forbidden_layer_dependency_from_import_edges() {
     let repo = FixtureRepo::new();