@lamentis/naome 1.3.9 → 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/path_scan.rs

@@ -0,0 +1,92 @@
+use std::fs;
+use std::path::Path;
+
+use crate::models::NaomeError;
+use crate::paths;
+
+use crate::architecture::config::ArchitectureConfig;
+
+pub(super) fn repository_files(
+    root: &Path,
+    config: &ArchitectureConfig,
+) -> Result<Vec<String>, NaomeError> {
+    let ignored_patterns = ignored_patterns(root, config);
+    let mut files = Vec::new();
+    collect_files(root, root, &ignored_patterns, &mut files)?;
+    files.sort();
+    Ok(files)
+}
+
+fn collect_files(
+    root: &Path,
+    dir: &Path,
+    ignored_patterns: &[String],
+    files: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        let relative = normalize_path(path.strip_prefix(root).unwrap_or(&path));
+        if is_ignored(&relative, ignored_patterns) {
+            continue;
+        }
+        let metadata = fs::symlink_metadata(&path)?;
+        if metadata.is_symlink() {
+            continue;
+        }
+        if metadata.is_dir() {
+            collect_files(root, &path, ignored_patterns, files)?;
+        } else if metadata.is_file() {
+            files.push(relative);
+        }
+    }
+    Ok(())
+}
+
+fn is_ignored(path: &str, ignored_patterns: &[String]) -> bool {
+    path.is_empty() || is_default_ignored_path(path) || paths::matches_any(path, ignored_patterns)
+}
+
+fn ignored_patterns(root: &Path, config: &ArchitectureConfig) -> Vec<String> {
+    let mut patterns = paths::naomeignore_patterns(root);
+    patterns.extend([
+        ".git/**".to_string(),
+        ".naome/archive/**".to_string(),
+        ".naome/cache/**".to_string(),
+        ".naome/local/**".to_string(),
+        ".naome/tasks/**".to_string(),
+        "node_modules/**".to_string(),
+        "target/**".to_string(),
+        "dist/**".to_string(),
+        "build/**".to_string(),
+    ]);
+    patterns.extend(config.ignore.iter().map(|rule| rule.path.clone()));
+    patterns
+}
+
+fn is_default_ignored_path(path: &str) -> bool {
+    path == ".git"
+        || path.starts_with(".git/")
+        || path == ".naome/archive"
+        || path.starts_with(".naome/archive/")
+        || path == ".naome/cache"
+        || path.starts_with(".naome/cache/")
+        || path == ".naome/local"
+        || path.starts_with(".naome/local/")
+        || path == ".naome/tasks"
+        || path.starts_with(".naome/tasks/")
+        || path == ".npm"
+        || path.starts_with(".npm/")
+        || path == "node_modules"
+        || path.contains("/node_modules/")
+        || path == "target"
+        || path.contains("/target/")
+        || path == "dist"
+        || path.contains("/dist/")
+        || path == "build"
+        || path.contains("/build/")
+}
+
+fn normalize_path(path: impl AsRef<Path>) -> String {
+    path.as_ref().to_string_lossy().replace('\\', "/")
+}

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

@@ -0,0 +1,95 @@
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+use serde::Serialize;
+
+use crate::git;
+use crate::models::NaomeError;
+
+use super::config::{read_architecture_config, ArchitectureConfig};
+use super::model::ArchitectureGraph;
+
+mod graph_builder;
+mod imports;
+mod path_scan;
+
+#[derive(Debug, Clone, Default)]
+pub struct ArchitectureScanOptions {
+    pub config_path: Option<PathBuf>,
+    pub changed_only: bool,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ArchitectureScanReport {
+    pub schema: String,
+    pub graph: ArchitectureGraph,
+    pub files_scanned: usize,
+    pub changed_only_requested: bool,
+    pub changed_only_degraded_to_full_scan: bool,
+    pub changed_paths: Vec<String>,
+    #[serde(skip_serializing)]
+    pub config: ArchitectureConfig,
+    #[serde(skip_serializing)]
+    pub file_facts: BTreeMap<String, FileFact>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FileFact {
+    pub path: String,
+    pub language: Option<String>,
+    pub line_count: usize,
+    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(
+    root: &Path,
+    options: ArchitectureScanOptions,
+) -> Result<ArchitectureScanReport, NaomeError> {
+    let config = read_architecture_config(root, options.config_path.as_deref())?;
+    let changed_paths = changed_paths(root, options.changed_only)?;
+    let files = path_scan::repository_files(root, &config)?;
+    let (mut graph, file_facts) = graph_builder::build_path_graph(root, files, &config);
+
+    graph.sort_stable();
+    Ok(ArchitectureScanReport {
+        schema: "naome.arch.scan.v1".to_string(),
+        files_scanned: file_facts.len(),
+        graph,
+        changed_only_requested: options.changed_only,
+        changed_only_degraded_to_full_scan: options.changed_only,
+        changed_paths,
+        config,
+        file_facts,
+    })
+}
+
+fn changed_paths(root: &Path, changed_only: bool) -> Result<Vec<String>, NaomeError> {
+    if changed_only {
+        git::changed_paths(root)
+    } else {
+        Ok(Vec::new())
+    }
+}

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

@@ -0,0 +1,31 @@
+mod config;
+mod model;
+mod output;
+mod rules;
+mod scan;
+
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+pub use config::{
+    default_architecture_config_text, ArchitectureConfig, ContextConfig, LayerConfig, RuleConfig,
+};
+pub use model::{
+    ArchitectureEdge, ArchitectureEdgeKind, ArchitectureGraph, ArchitectureMetadata,
+    ArchitectureNode, ArchitectureNodeKind, SourceRange,
+};
+pub use output::{
+    format_architecture_explain, format_architecture_scan, format_architecture_validation,
+    ArchitectureAgentFeedback, ArchitectureValidation, ArchitectureViolation, Severity,
+    ViolationSummary,
+};
+pub use scan::{scan_architecture, ArchitectureScanOptions, ArchitectureScanReport};
+
+pub fn validate_architecture(
+    root: &Path,
+    options: ArchitectureScanOptions,
+) -> Result<ArchitectureValidation, NaomeError> {
+    let scan = scan_architecture(root, options)?;
+    Ok(rules::validate_scan(scan))
+}

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

@@ -12,6 +12,7 @@ pub const MACHINE_OWNED_PATHS: &[&str] = &[
     "docs/naome/agent-workflow.md",
     "docs/naome/context-economy.md",
     "docs/naome/task-ledger.md",
+    "docs/naome/architecture-fitness.md",
     "docs/naome/execution.md",
     "docs/naome/upgrade.md",
 ];
@@ -48,6 +49,7 @@ pub const LOCAL_ONLY_MACHINE_OWNED_PATHS: &[&str] = &[
     "docs/naome/agent-workflow.md",
     "docs/naome/context-economy.md",
     "docs/naome/task-ledger.md",
+    "docs/naome/architecture-fitness.md",
     "docs/naome/execution.md",
     "docs/naome/upgrade.md",
 ];

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

@@ -1,3 +1,4 @@
+mod architecture;
 mod context;
 mod decision;
 mod git;
@@ -19,6 +20,14 @@ mod verification_contract;
 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,
+};
 pub use context::{
     select_context_for_changed_paths, select_context_for_prompt, ContextBudgetLedger,
     ContextCapsule, ContextItem, ContextSelection,
@@ -36,14 +45,13 @@ pub use journal::{append_task_journal, TaskJournalEntry};
 pub use models::{Decision, NaomeError};
 pub use quality::{
     check_repository_quality, check_repository_quality_paths, check_semantic_legacy,
-    check_semantic_legacy_paths,
-    clear_quality_cache, explain_repository_structure, init_repository_quality,
-    init_repository_quality_with_mode, plan_quality_cleanup, quality_cache_status,
-    reconcile_repository_quality, route_quality_cleanup, semantic_route_for_finding,
-    QualityCacheStatus, QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask,
-    QualityInitMode, QualityInitResult, QualityMode, QualityReconcileReport, QualityReport,
-    QualitySummary, QualityViolation, RepositoryQualityConfig, RepositoryStructureConfig,
-    SemanticFinding, SemanticReport, StructurePathExplanation,
+    check_semantic_legacy_paths, clear_quality_cache, explain_repository_structure,
+    init_repository_quality, init_repository_quality_with_mode, plan_quality_cleanup,
+    quality_cache_status, reconcile_repository_quality, route_quality_cleanup,
+    semantic_route_for_finding, QualityCacheStatus, QualityCleanupPlan, QualityCleanupRoute,
+    QualityCleanupTask, QualityInitMode, QualityInitResult, QualityMode, QualityReconcileReport,
+    QualityReport, QualitySummary, QualityViolation, RepositoryQualityConfig,
+    RepositoryStructureConfig, SemanticFinding, SemanticReport, StructurePathExplanation,
 };
 pub use repository_model::{
     explain_repository_model_path, refresh_repository_model, repository_model_drift,