@lamentis/naome 1.3.15 → 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

@@ -34,6 +34,17 @@ pub struct ArchitectureAgentFeedback {
     pub must_not_do: Vec<String>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ArchitectureConfigFinding {
+    pub id: String,
+    pub severity: String,
+    pub subject: String,
+    pub message: String,
+    pub suggestion: String,
+    pub agent_instruction: String,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ArchitectureValidation {
@@ -48,6 +59,7 @@ pub struct ArchitectureValidation {
     pub changed_only_degraded_to_full_scan: bool,
     pub changed_only_mode: String,
     pub changed_only_degradation_reason: Option<String>,
+    pub config_findings: Vec<ArchitectureConfigFinding>,
     pub violations: Vec<ArchitectureViolation>,
     #[serde(rename = "agent_feedback")]
     pub agent_feedback: Vec<ArchitectureAgentFeedback>,
@@ -74,15 +86,42 @@ 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()
 }
 
+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;
+        };
+        if !files.iter().any(|existing| existing == path) {
+            files.push(path.to_string());
+        }
+    }
+    files
+}
+
+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 {
     ViolationSummary {
         errors: violations
@@ -128,6 +167,21 @@ pub fn format_architecture_validation(report: &ArchitectureValidation) -> String
         lines.push("changed-only requested: using incremental architecture cache".to_string());
     }
 
+    if !report.config_findings.is_empty() {
+        lines.push(format!(
+            "configuration findings: {}",
+            report.config_findings.len()
+        ));
+    }
+
+    for finding in report.config_findings.iter().take(5) {
+        lines.push(format!(
+            "- Config {} {} {}",
+            finding.severity, finding.subject, finding.message
+        ));
+        lines.push(format!("  fix: {}", finding.suggestion));
+    }
+
     for violation in report.violations.iter().take(10) {
         lines.push(format!(
             "- {:?} {} {}",
@@ -162,34 +216,3 @@ pub fn format_architecture_scan(report: &ArchitectureScanReport) -> String {
     }
     output
 }
-
-pub fn format_architecture_explain(scan: &ArchitectureScanReport) -> String {
-    let layers = scan
-        .config
-        .layers
-        .keys()
-        .cloned()
-        .collect::<Vec<_>>()
-        .join(", ");
-    let contexts = scan
-        .config
-        .contexts
-        .keys()
-        .cloned()
-        .collect::<Vec<_>>()
-        .join(", ");
-    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)
-    )
-}
-
-fn empty_label(value: &str) -> &str {
-    if value.is_empty() {
-        "<none>"
-    } else {
-        value
-    }
-}

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

@@ -1,5 +1,6 @@
 use crate::paths;
 
+use super::config_findings::{architecture_config_agent_feedback, config_findings_for};
 use super::model::Severity;
 use super::output::{
     architecture_agent_feedback, summary_for, ArchitectureValidation, ArchitectureViolation,
@@ -43,7 +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(),
@@ -57,6 +60,7 @@ pub fn validate_scan(scan: ArchitectureScanReport) -> ArchitectureValidation {
         changed_only_degraded_to_full_scan: scan.changed_only_degraded_to_full_scan,
         changed_only_mode: scan.changed_only_mode,
         changed_only_degradation_reason: scan.changed_only_degradation_reason,
+        config_findings,
         violations,
         agent_feedback,
     }

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())
+}