@lamentis/naome 1.3.16 → 1.3.17

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

@@ -0,0 +1,50 @@
+mod configuration;
+mod imports;
+
+use super::output::{ArchitectureAgentFeedback, ArchitectureConfigFinding};
+use super::scan::ArchitectureScanReport;
+
+pub fn architecture_config_agent_feedback(
+    findings: &[ArchitectureConfigFinding],
+) -> Vec<ArchitectureAgentFeedback> {
+    findings
+        .iter()
+        .filter(|finding| finding.id == "arch.import.unresolved")
+        .map(|finding| ArchitectureAgentFeedback {
+            problem: finding.message.clone(),
+            repair: finding.suggestion.clone(),
+            files: finding
+                .subject
+                .strip_prefix("file:")
+                .map(|path| vec![path.to_string()])
+                .unwrap_or_default(),
+            must_not_do: vec![
+                "Do not leave unresolved imports hidden from architecture validation.".to_string(),
+                "Do not suppress architecture findings without an explicit ignore reason."
+                    .to_string(),
+            ],
+        })
+        .collect()
+}
+
+pub fn config_findings_for(scan: &ArchitectureScanReport) -> Vec<ArchitectureConfigFinding> {
+    let mut findings = Vec::new();
+    findings.extend(configuration::findings(scan));
+    findings.extend(imports::findings(scan));
+    findings.sort_by(|left, right| {
+        (
+            left.id.as_str(),
+            left.subject.as_str(),
+            left.message.as_str(),
+        )
+            .cmp(&(
+                right.id.as_str(),
+                right.subject.as_str(),
+                right.message.as_str(),
+            ))
+    });
+    findings.dedup_by(|left, right| {
+        left.id == right.id && left.subject == right.subject && left.message == right.message
+    });
+    findings
+}

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

@@ -0,0 +1,45 @@
+use super::config_findings::config_findings_for;
+use super::output::ARCHITECTURE_RULE_IDS;
+use super::scan::ArchitectureScanReport;
+
+pub fn format_architecture_explain(scan: &ArchitectureScanReport) -> String {
+    let findings = config_findings_for(scan);
+    let layers = scan
+        .config
+        .layers
+        .keys()
+        .cloned()
+        .collect::<Vec<_>>()
+        .join(", ");
+    let contexts = scan
+        .config
+        .contexts
+        .keys()
+        .cloned()
+        .collect::<Vec<_>>()
+        .join(", ");
+    let mut output = format!(
+        "NAOME Architecture Fitness\nrules: {}\nlayers: {}\ncontexts: {}\npath extractor: enabled for every repository\nimport extractors: typescript, javascript, rust, python, go, swift\n",
+        ARCHITECTURE_RULE_IDS.join(", "),
+        empty_label(&layers),
+        empty_label(&contexts)
+    );
+    if !findings.is_empty() {
+        output.push_str(&format!("configuration findings: {}\n", findings.len()));
+        for finding in findings.iter().take(5) {
+            output.push_str(&format!(
+                "- {} {}: {}\n",
+                finding.severity, finding.subject, finding.message
+            ));
+        }
+    }
+    output
+}
+
+fn empty_label(value: &str) -> &str {
+    if value.is_empty() {
+        "<none>"
+    } else {
+        value
+    }
+}

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

@@ -86,138 +86,40 @@ pub fn architecture_agent_feedback(
         .map(|violation| ArchitectureAgentFeedback {
             problem: violation.message.clone(),
             repair: violation.suggestion.clone(),
-            files: violation.path.iter().cloned().collect(),
-            must_not_do: vec![
-                "Do not suppress architecture rules without an explicit ignore reason.".to_string(),
-                "Do not edit generated files unless the architecture config allows it.".to_string(),
-            ],
+            files: feedback_files(violation),
+            must_not_do: feedback_must_not_do(violation),
         })
         .collect()
 }
 
-pub fn config_findings_for(scan: &ArchitectureScanReport) -> Vec<ArchitectureConfigFinding> {
-    let mut findings = Vec::new();
-    findings.extend(broad_layer_findings(scan));
-    findings.extend(catch_all_context_findings(scan));
-    findings.sort_by(|left, right| {
-        (left.id.as_str(), left.subject.as_str()).cmp(&(right.id.as_str(), right.subject.as_str()))
-    });
-    findings.dedup_by(|left, right| left.id == right.id && left.subject == right.subject);
-    findings
-}
-
-fn broad_layer_findings(scan: &ArchitectureScanReport) -> Vec<ArchitectureConfigFinding> {
-    let mut findings = Vec::new();
-    for (layer_name, layer) in &scan.config.layers {
-        let Some(broad_pattern) = layer
-            .paths
-            .iter()
-            .find(|pattern| is_broad_source_pattern(pattern))
+fn feedback_files(violation: &ArchitectureViolation) -> Vec<String> {
+    let mut files = Vec::new();
+    if let Some(path) = &violation.path {
+        files.push(path.clone());
+    }
+    for endpoint in [&violation.from, &violation.to] {
+        let Some(path) = endpoint
+            .as_deref()
+            .and_then(|value| value.strip_prefix("file:"))
         else {
             continue;
         };
-        let overlapping_layers = scan
-            .config
-            .layers
-            .iter()
-            .filter(|(other_name, other_layer)| {
-                other_name.as_str() != layer_name.as_str()
-                    && other_layer
-                        .paths
-                        .iter()
-                        .any(|pattern| pattern_is_narrower_than(pattern, broad_pattern))
-            })
-            .map(|(name, _)| name.clone())
-            .collect::<Vec<_>>();
-        if overlapping_layers.is_empty() {
-            continue;
+        if !files.iter().any(|existing| existing == path) {
+            files.push(path.to_string());
         }
-        findings.push(ArchitectureConfigFinding {
-            id: "arch.config.broad_layer_overlap".to_string(),
-            severity: "warning".to_string(),
-            subject: format!("layer:{layer_name}"),
-            message: format!(
-                "Layer {layer_name} uses broad path pattern {broad_pattern} while narrower layers also match inside it: {}.",
-                overlapping_layers.join(", ")
-            ),
-            suggestion: format!(
-                "Keep broad compatibility layers intentional and make allowed_dependencies explicit, or narrow {layer_name} so files do not inherit multiple architectural meanings by default."
-            ),
-            agent_instruction: format!(
-                "Do not rely on broad layer {layer_name} to hide architecture boundaries; prefer narrower layer paths or explicit allow rules."
-            ),
-        });
     }
-    findings
-}
-
-fn catch_all_context_findings(scan: &ArchitectureScanReport) -> Vec<ArchitectureConfigFinding> {
-    if scan.config.contexts.len() <= 1 {
-        return Vec::new();
-    }
-    scan.config
-        .contexts
-        .iter()
-        .filter(|(_, context)| {
-            context
-                .paths
-                .iter()
-                .any(|pattern| is_broad_source_pattern(pattern))
-        })
-        .filter_map(|(context_name, context)| {
-            let broad_pattern = context
-                .paths
-                .iter()
-                .find(|pattern| is_broad_source_pattern(pattern))?;
-            let specific_contexts = scan
-                .config
-                .contexts
-                .iter()
-                .filter(|(other_name, other_context)| {
-                    other_name.as_str() != context_name.as_str()
-                        && other_context
-                            .paths
-                            .iter()
-                            .any(|pattern| pattern_is_narrower_than(pattern, broad_pattern))
-                })
-                .map(|(name, _)| name.clone())
-                .collect::<Vec<_>>();
-            if specific_contexts.is_empty() {
-                return None;
-            }
-            Some(ArchitectureConfigFinding {
-                id: "arch.config.catch_all_context_with_specific_contexts".to_string(),
-                severity: "warning".to_string(),
-                subject: format!("context:{context_name}"),
-                message: format!(
-                    "Context {context_name} uses catch-all path pattern {broad_pattern} alongside narrower contexts: {}.",
-                    specific_contexts.join(", ")
-                ),
-                suggestion: format!(
-                    "Treat {context_name} as a compatibility bucket only. Move shared code into explicit public APIs or replace the catch-all context with narrower bounded contexts."
-                ),
-                agent_instruction: format!(
-                    "Do not classify cross-context imports as safe only because {context_name} also matches them; model the real bounded context or public API."
-                ),
-            })
-        })
-        .collect()
+    files
 }
 
-fn is_broad_source_pattern(pattern: &str) -> bool {
-    matches!(pattern, "**" | "**/*" | "src/**" | "packages/**/src/**")
-}
-
-fn pattern_is_narrower_than(pattern: &str, broad_pattern: &str) -> bool {
-    if pattern == broad_pattern {
-        return false;
-    }
-    match broad_pattern {
-        "**" | "**/*" => true,
-        "src/**" => pattern.starts_with("src/") && pattern != "src/**",
-        "packages/**/src/**" => pattern.starts_with("packages/") && pattern.contains("/src/"),
-        _ => false,
+fn feedback_must_not_do(violation: &ArchitectureViolation) -> Vec<String> {
+    let mut items = vec![
+        "Do not suppress architecture rules without an explicit ignore reason.".to_string(),
+        "Do not edit generated files unless the architecture config allows it.".to_string(),
+    ];
+    if violation.id == "arch.no_forbidden_layer_dependencies" {
+        items.push(violation.agent_instruction.clone());
     }
+    items
 }
 
 pub fn summary_for(violations: &[ArchitectureViolation]) -> ViolationSummary {
@@ -314,45 +216,3 @@ pub fn format_architecture_scan(report: &ArchitectureScanReport) -> String {
     }
     output
 }
-
-pub fn format_architecture_explain(scan: &ArchitectureScanReport) -> String {
-    let findings = config_findings_for(scan);
-    let layers = scan
-        .config
-        .layers
-        .keys()
-        .cloned()
-        .collect::<Vec<_>>()
-        .join(", ");
-    let contexts = scan
-        .config
-        .contexts
-        .keys()
-        .cloned()
-        .collect::<Vec<_>>()
-        .join(", ");
-    let mut output = format!(
-        "NAOME Architecture Fitness\nrules: {}\nlayers: {}\ncontexts: {}\npath extractor: enabled for every repository\nimport extractors: typescript, javascript, rust, python, go, swift\n",
-        ARCHITECTURE_RULE_IDS.join(", "),
-        empty_label(&layers),
-        empty_label(&contexts)
-    );
-    if !findings.is_empty() {
-        output.push_str(&format!("configuration findings: {}\n", findings.len()));
-        for finding in findings.iter().take(5) {
-            output.push_str(&format!(
-                "- {} {}: {}\n",
-                finding.severity, finding.subject, finding.message
-            ));
-        }
-    }
-    output
-}
-
-fn empty_label(value: &str) -> &str {
-    if value.is_empty() {
-        "<none>"
-    } else {
-        value
-    }
-}

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

@@ -1,9 +1,9 @@
 use crate::paths;
 
+use super::config_findings::{architecture_config_agent_feedback, config_findings_for};
 use super::model::Severity;
 use super::output::{
-    architecture_agent_feedback, config_findings_for, summary_for, ArchitectureValidation,
-    ArchitectureViolation,
+    architecture_agent_feedback, summary_for, ArchitectureValidation, ArchitectureViolation,
 };
 use super::scan::ArchitectureScanReport;
 use crate::architecture::model::ArchitectureEdgeKind;
@@ -44,8 +44,9 @@ pub fn validate_scan(scan: ArchitectureScanReport) -> ArchitectureValidation {
     });
     let summary = summary_for(&violations);
     let status = if summary.errors > 0 { "fail" } else { "pass" }.to_string();
-    let agent_feedback = architecture_agent_feedback(&violations);
     let config_findings = config_findings_for(&scan);
+    let mut agent_feedback = architecture_agent_feedback(&violations);
+    agent_feedback.extend(architecture_config_agent_feedback(&config_findings));
 
     ArchitectureValidation {
         schema: "naome.arch.validation.v1".to_string(),

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

@@ -9,7 +9,7 @@ use super::FileFact;
 use crate::models::NaomeError;
 
 const CACHE_SCHEMA: &str = "naome.architecture-cache.v1";
-const EXTRACTOR_VERSION: &str = "architecture-cache-v1.3.14";
+const EXTRACTOR_VERSION: &str = "architecture-cache-v1.3.17";
 const CACHE_PATH: &str = ".naome/cache/architecture/cache.json";
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

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

@@ -0,0 +1,71 @@
+use std::collections::BTreeSet;
+
+pub(super) 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))
+}
+
+pub(super) 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",
+        ],
+    }
+}

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

@@ -0,0 +1,241 @@
+use std::collections::BTreeSet;
+use std::collections::HashSet;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use serde_json::Value;
+
+pub(super) enum AliasResolution {
+    Resolved(String),
+    Unresolved,
+}
+
+pub(super) fn resolve(
+    root: &Path,
+    from_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+    language: Option<&str>,
+) -> Option<AliasResolution> {
+    for config_path in nearest_configs(from_path, repository_files) {
+        let mut seen = HashSet::new();
+        for config_path in config_with_extends(root, &config_path, &mut seen) {
+            let Some(resolution) =
+                resolve_from_config(root, &config_path, specifier, repository_files, language)
+            else {
+                continue;
+            };
+            match resolution {
+                AliasResolution::Resolved(_) => return Some(resolution),
+                AliasResolution::Unresolved => return Some(AliasResolution::Unresolved),
+            }
+        }
+    }
+    None
+}
+
+fn resolve_from_config(
+    root: &Path,
+    config_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+    language: Option<&str>,
+) -> Option<AliasResolution> {
+    let config_dir = Path::new(config_path)
+        .parent()
+        .unwrap_or_else(|| Path::new(""));
+    let raw = read_jsonc(root, config_path)?;
+    let compiler_options = raw.get("compilerOptions")?;
+    let base_url = compiler_options
+        .get("baseUrl")
+        .and_then(Value::as_str)
+        .unwrap_or(".");
+    let paths = compiler_options.get("paths")?.as_object()?;
+    let mut matches = paths
+        .iter()
+        .filter_map(|(alias_pattern, targets)| {
+            let capture = alias_capture(alias_pattern, specifier)?;
+            Some((
+                alias_specificity(alias_pattern),
+                alias_pattern,
+                capture,
+                targets,
+            ))
+        })
+        .collect::<Vec<_>>();
+    matches.sort_by(|left, right| {
+        right
+            .0
+            .cmp(&left.0)
+            .then_with(|| right.1.len().cmp(&left.1.len()))
+            .then_with(|| left.1.cmp(right.1))
+    });
+
+    let (_, _, capture, targets) = matches.into_iter().next()?;
+    let Some(targets) = targets.as_array() else {
+        return Some(AliasResolution::Unresolved);
+    };
+    for target in targets.iter().filter_map(Value::as_str) {
+        let expanded = target.replace('*', &capture);
+        let candidate = super::normalize(config_dir.join(base_url).join(expanded));
+        if let Some(path) = super::resolve_candidates(&candidate, repository_files, language) {
+            return Some(AliasResolution::Resolved(path));
+        }
+    }
+    Some(AliasResolution::Unresolved)
+}
+
+fn read_jsonc(root: &Path, config_path: &str) -> Option<Value> {
+    let content = fs::read_to_string(root.join(config_path)).ok()?;
+    serde_json::from_str::<Value>(&strip_jsonc(&content)).ok()
+}
+
+fn config_with_extends(root: &Path, config_path: &str, seen: &mut HashSet<String>) -> Vec<String> {
+    if !seen.insert(config_path.to_string()) {
+        return Vec::new();
+    }
+    let mut configs = vec![config_path.to_string()];
+    let Some(raw) = read_jsonc(root, config_path) else {
+        return configs;
+    };
+    let Some(extends) = raw.get("extends").and_then(Value::as_str) else {
+        return configs;
+    };
+    let Some(extended_path) = resolve_extends_path(config_path, extends) else {
+        return configs;
+    };
+    configs.extend(config_with_extends(root, &extended_path, seen));
+    configs
+}
+
+fn resolve_extends_path(config_path: &str, extends: &str) -> Option<String> {
+    if extends.is_empty()
+        || extends.starts_with('@')
+        || (!extends.starts_with('.') && !extends.starts_with('/'))
+    {
+        return None;
+    }
+    let config_dir = Path::new(config_path)
+        .parent()
+        .unwrap_or_else(|| Path::new(""));
+    let mut candidate = if Path::new(extends).is_absolute() {
+        PathBuf::from(extends.strip_prefix('/').unwrap_or(extends))
+    } else {
+        config_dir.join(extends)
+    };
+    if candidate.extension().is_none() {
+        candidate.set_extension("json");
+    }
+    Some(super::normalize(candidate))
+}
+
+fn strip_jsonc(content: &str) -> String {
+    let mut stripped = String::with_capacity(content.len());
+    let mut chars = content.chars().peekable();
+    let mut in_string = false;
+    let mut escaped = false;
+    while let Some(character) = chars.next() {
+        if in_string {
+            if character == '"' && !escaped {
+                in_string = false;
+            }
+            stripped.push(character);
+            escaped = character == '\\' && !escaped;
+            continue;
+        }
+        if character == '"' {
+            in_string = true;
+            stripped.push(character);
+            continue;
+        }
+        if character == '/' && chars.peek() == Some(&'/') {
+            chars.next();
+            for next in chars.by_ref() {
+                if next == '\n' {
+                    stripped.push('\n');
+                    break;
+                }
+            }
+            continue;
+        }
+        if character == '/' && chars.peek() == Some(&'*') {
+            chars.next();
+            let mut previous = '\0';
+            for next in chars.by_ref() {
+                if next == '\n' {
+                    stripped.push('\n');
+                }
+                if previous == '*' && next == '/' {
+                    break;
+                }
+                previous = next;
+            }
+            continue;
+        }
+        stripped.push(character);
+    }
+    remove_trailing_commas(&stripped)
+}
+
+fn remove_trailing_commas(content: &str) -> String {
+    let mut output = String::with_capacity(content.len());
+    let chars = content.chars().collect::<Vec<_>>();
+    let mut index = 0usize;
+    while index < chars.len() {
+        if chars[index] == ',' {
+            let mut next = index + 1;
+            while next < chars.len() && chars[next].is_whitespace() {
+                next += 1;
+            }
+            if next < chars.len() && matches!(chars[next], '}' | ']') {
+                index += 1;
+                continue;
+            }
+        }
+        output.push(chars[index]);
+        index += 1;
+    }
+    output
+}
+
+fn nearest_configs(from_path: &str, repository_files: &BTreeSet<String>) -> Vec<String> {
+    let mut configs = Vec::new();
+    let mut current = Path::new(from_path)
+        .parent()
+        .unwrap_or_else(|| Path::new(""));
+    loop {
+        for file_name in ["tsconfig.json", "jsconfig.json"] {
+            let candidate = super::normalize(current.join(file_name));
+            if repository_files.contains(&candidate) {
+                configs.push(candidate);
+            }
+        }
+        let Some(parent) = current.parent() else {
+            break;
+        };
+        if parent == current {
+            break;
+        }
+        current = parent;
+    }
+    configs
+}
+
+fn alias_capture(pattern: &str, specifier: &str) -> Option<String> {
+    let Some((prefix, suffix)) = pattern.split_once('*') else {
+        return (pattern == specifier).then(String::new);
+    };
+    Some(
+        specifier
+            .strip_prefix(prefix)?
+            .strip_suffix(suffix)?
+            .to_string(),
+    )
+}
+
+fn alias_specificity(pattern: &str) -> usize {
+    pattern
+        .split_once('*')
+        .map(|(prefix, _)| prefix.len())
+        .unwrap_or(pattern.len())
+}