@lamentis/naome 1.2.0 → 1.3.0

package/crates/naome-core/src/quality/semantic/extract.rs

@@ -0,0 +1,158 @@
+use std::collections::BTreeSet;
+
+use super::model::ObjectCandidate;
+use crate::quality::scanner::{stable_fingerprint, FileAnalysis, SymbolAnalysis};
+
+pub(super) fn extract_object_candidates(file: &FileAnalysis) -> Vec<ObjectCandidate> {
+    let mut candidates = Vec::new();
+    let mut start: Option<usize> = None;
+    let mut depth = 0isize;
+
+    for (index, line) in file.raw_lines.iter().enumerate() {
+        let delta = brace_delta(line);
+        if start.is_none() && line.contains('{') && looks_like_object_start(line) {
+            start = Some(index);
+        }
+        if start.is_some() {
+            depth += delta;
+            if depth <= 0 {
+                if let Some(start_index) = start.take() {
+                    push_candidate(file, start_index, index, &mut candidates);
+                }
+                depth = 0;
+            }
+        }
+    }
+
+    candidates
+}
+
+fn push_candidate(
+    file: &FileAnalysis,
+    start_index: usize,
+    end_index: usize,
+    candidates: &mut Vec<ObjectCandidate>,
+) {
+    let line_count = end_index.saturating_sub(start_index) + 1;
+    if line_count < 8 {
+        return;
+    }
+    let keys = extract_keys(&file.raw_lines[start_index..=end_index]);
+    if keys.len() < 3 {
+        return;
+    }
+    let shape = keys.iter().cloned().collect::<Vec<_>>().join("|");
+    let shape_hash = stable_fingerprint(&["semantic-shape", &shape]);
+    let start_line = start_index + 1;
+    candidates.push(ObjectCandidate {
+        path: file.path.clone(),
+        start_line,
+        end_line: end_index + 1,
+        symbol: nearest_symbol(&file.symbols, start_line),
+        keys,
+        shape_hash,
+        line_count,
+        in_test_context: is_test_context(&file.path),
+    });
+}
+
+fn extract_keys(lines: &[String]) -> BTreeSet<String> {
+    lines
+        .iter()
+        .filter_map(|line| key_from_line(line))
+        .collect::<BTreeSet<_>>()
+}
+
+fn key_from_line(line: &str) -> Option<String> {
+    let trimmed = line.trim().trim_start_matches(['{', ',', '[']);
+    if trimmed.starts_with("//") || trimmed.starts_with('#') {
+        return None;
+    }
+    let (raw_key, _) = trimmed.split_once(':')?;
+    let key = raw_key.trim().trim_matches('"').trim_matches('\'').trim();
+    let valid = !key.is_empty()
+        && key.len() <= 64
+        && key.chars().all(|character| {
+            character.is_ascii_alphanumeric() || character == '_' || character == '-'
+        });
+    valid.then(|| key.to_ascii_lowercase())
+}
+
+fn brace_delta(line: &str) -> isize {
+    let mut delta = 0isize;
+    let mut in_string = false;
+    let mut quote = '\0';
+    let mut escaped = false;
+    for character in line.chars() {
+        if in_string {
+            if escaped {
+                escaped = false;
+            } else if character == '\\' {
+                escaped = true;
+            } else if character == quote {
+                in_string = false;
+            }
+            continue;
+        }
+        if character == '"' || character == '\'' || character == '`' {
+            in_string = true;
+            quote = character;
+        } else if character == '{' {
+            delta += 1;
+        } else if character == '}' {
+            delta -= 1;
+        }
+    }
+    delta
+}
+
+fn looks_like_object_start(line: &str) -> bool {
+    let trimmed = line.trim();
+    if starts_code_block(trimmed) {
+        return false;
+    }
+    trimmed.starts_with('{')
+        || trimmed.ends_with('{')
+        || trimmed.contains("= {")
+        || trimmed.contains(": {")
+        || trimmed.contains("({")
+}
+
+fn starts_code_block(trimmed: &str) -> bool {
+    [
+        "fn ",
+        "pub fn ",
+        "function ",
+        "async function ",
+        "if ",
+        "for ",
+        "while ",
+        "match ",
+        "impl ",
+        "mod ",
+        "class ",
+        "struct ",
+        "enum ",
+    ]
+    .iter()
+    .any(|prefix| trimmed.starts_with(prefix))
+}
+
+fn nearest_symbol(symbols: &[SymbolAnalysis], line: usize) -> Option<String> {
+    symbols
+        .iter()
+        .filter(|symbol| symbol.start_line <= line)
+        .max_by_key(|symbol| symbol.start_line)
+        .map(|symbol| symbol.name.clone())
+        .filter(|name| !name.is_empty())
+}
+
+fn is_test_context(path: &str) -> bool {
+    let lower = path.to_ascii_lowercase();
+    lower.contains("/test")
+        || lower.contains("test/")
+        || lower.contains(".test.")
+        || lower.contains(".spec.")
+        || lower.contains("fixture")
+        || lower.contains("support")
+}

package/crates/naome-core/src/quality/semantic/model.rs

@@ -0,0 +1,85 @@
+use std::collections::BTreeSet;
+
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SemanticReport {
+    pub schema: String,
+    pub mode: String,
+    pub ok: bool,
+    pub changed_paths: Vec<String>,
+    pub summary: SemanticSummary,
+    pub findings: Vec<SemanticFinding>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SemanticSummary {
+    pub scanned_files: usize,
+    pub scanned_path_count: usize,
+    pub finding_count: usize,
+    pub blocking_finding_count: usize,
+    pub truncated: bool,
+    pub reason_codes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SemanticFinding {
+    pub id: String,
+    pub kind: String,
+    pub confidence: f64,
+    pub severity: String,
+    pub mode: String,
+    pub summary: String,
+    pub occurrences: Vec<SemanticOccurrence>,
+    pub cleanup_route: SemanticCleanupRoute,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SemanticOccurrence {
+    pub path: String,
+    pub start_line: usize,
+    pub end_line: usize,
+    pub symbol: Option<String>,
+    pub shape_hash: String,
+    pub key_count: usize,
+    pub line_count: usize,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SemanticCleanupRoute {
+    pub intent: String,
+    pub target_suggestion: String,
+    pub agent_instructions: Vec<String>,
+    pub required_checks: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct ObjectCandidate {
+    pub path: String,
+    pub start_line: usize,
+    pub end_line: usize,
+    pub symbol: Option<String>,
+    pub keys: BTreeSet<String>,
+    pub shape_hash: String,
+    pub line_count: usize,
+    pub in_test_context: bool,
+}
+
+impl ObjectCandidate {
+    pub(super) fn occurrence(&self) -> SemanticOccurrence {
+        SemanticOccurrence {
+            path: self.path.clone(),
+            start_line: self.start_line,
+            end_line: self.end_line,
+            symbol: self.symbol.clone(),
+            shape_hash: self.shape_hash.clone(),
+            key_count: self.keys.len(),
+            line_count: self.line_count,
+        }
+    }
+}

package/crates/naome-core/src/quality/semantic/route.rs

@@ -0,0 +1,52 @@
+use super::model::{SemanticCleanupRoute, SemanticOccurrence};
+use crate::quality::scanner::QualityContext;
+use crate::quality::types::QualityMode;
+
+pub(super) fn finding_mode(context: &QualityContext) -> &'static str {
+    match context.mode {
+        QualityMode::ChangedFast => "changed-blocking",
+        QualityMode::Report => "report",
+        QualityMode::DeepReport => "deep-report",
+    }
+}
+
+pub(super) fn cleanup_route(
+    intent: &str,
+    occurrences: &[SemanticOccurrence],
+    first_instruction: &str,
+) -> SemanticCleanupRoute {
+    let target_suggestion = target_suggestion(occurrences);
+    SemanticCleanupRoute {
+        intent: intent.to_string(),
+        target_suggestion,
+        agent_instructions: vec![
+            first_instruction.to_string(),
+            "Update every occurrence listed in this finding group; do not leave parallel inline copies behind.".to_string(),
+            "Preserve behavior and keep version-specific or schema-specific differences explicit as parameters or named fixtures.".to_string(),
+            "Do not auto-remove compatibility coverage unless focused tests prove the behavior remains covered.".to_string(),
+        ],
+        required_checks: vec![
+            "naome semantic check --changed".to_string(),
+            "naome quality check --changed".to_string(),
+            "git diff --check".to_string(),
+        ],
+    }
+}
+
+fn target_suggestion(occurrences: &[SemanticOccurrence]) -> String {
+    let Some(first) = occurrences.first() else {
+        return "test-support".to_string();
+    };
+    let directory = first
+        .path
+        .rsplit_once('/')
+        .map(|(directory, _)| directory)
+        .unwrap_or(".");
+    if directory == "." {
+        "test-support".to_string()
+    } else if directory.contains("script") {
+        format!("{directory}/test-support")
+    } else {
+        format!("{directory}/fixtures")
+    }
+}

package/crates/naome-core/src/quality/semantic.rs

@@ -0,0 +1,68 @@
+mod checks;
+mod extract;
+mod model;
+mod route;
+
+use checks::{copied_config_findings, inline_legacy_fixture_findings};
+use extract::extract_object_candidates;
+pub use model::{SemanticFinding, SemanticReport};
+
+use super::scanner::QualityContext;
+use model::SemanticSummary;
+
+pub fn run_semantic_checks(context: &QualityContext) -> SemanticReport {
+    let mut candidates = context
+        .files
+        .iter()
+        .flat_map(extract_object_candidates)
+        .collect::<Vec<_>>();
+    candidates.sort_by(|left, right| {
+        left.path
+            .cmp(&right.path)
+            .then(left.start_line.cmp(&right.start_line))
+            .then(left.shape_hash.cmp(&right.shape_hash))
+    });
+
+    let mut findings = Vec::new();
+    findings.extend(copied_config_findings(context, &candidates));
+    findings.extend(inline_legacy_fixture_findings(context, &candidates));
+    findings.sort_by(|left, right| {
+        left.kind
+            .cmp(&right.kind)
+            .then(left.occurrences[0].path.cmp(&right.occurrences[0].path))
+            .then(
+                left.occurrences[0]
+                    .start_line
+                    .cmp(&right.occurrences[0].start_line),
+            )
+            .then(left.id.cmp(&right.id))
+    });
+
+    let blocking_finding_count = findings.len();
+    SemanticReport {
+        schema: "naome.semantic-legacy-report.v1".to_string(),
+        mode: context.mode.as_str().to_string(),
+        ok: blocking_finding_count == 0,
+        changed_paths: context.changed_paths.clone(),
+        summary: SemanticSummary {
+            scanned_files: context.files.len(),
+            scanned_path_count: context.scanned_paths().len(),
+            finding_count: findings.len(),
+            blocking_finding_count,
+            truncated: context.truncated,
+            reason_codes: context.reason_codes.clone(),
+        },
+        findings,
+    }
+}
+
+pub fn semantic_route_for_finding(
+    report: &SemanticReport,
+    finding_id: &str,
+) -> Option<SemanticFinding> {
+    report
+        .findings
+        .iter()
+        .find(|finding| finding.id == finding_id)
+        .cloned()
+}

package/crates/naome-core/src/quality/structure/adapters.rs

@@ -0,0 +1,84 @@
+use crate::models::NaomeError;
+
+use crate::quality::adapter_support::{
+    detected_ids, detects_javascript_typescript_project, detects_rust_project, extend_unique,
+    find_adapter_by_id, validate_ids, AdapterDescriptor, RepoSignals,
+};
+
+use super::model::RepositoryStructureConfig;
+
+const CONFIG_PATH: &str = ".naome/repository-structure.json";
+
+struct StructureAdapter {
+    id: &'static str,
+    detect: fn(&RepoSignals<'_>) -> bool,
+    source_roots: &'static [&'static str],
+    test_roots: &'static [&'static str],
+    module_roots: &'static [&'static str],
+    allowed_root_files: &'static [&'static str],
+}
+
+impl AdapterDescriptor for StructureAdapter {
+    fn id(&self) -> &'static str {
+        self.id
+    }
+
+    fn detects(&self, signals: &RepoSignals<'_>) -> bool {
+        (self.detect)(signals)
+    }
+}
+
+pub fn detected_structure_adapter_ids(paths: &[String]) -> Vec<String> {
+    detected_ids(paths, registry())
+}
+
+pub fn apply_structure_adapters(
+    mut config: RepositoryStructureConfig,
+) -> Result<RepositoryStructureConfig, NaomeError> {
+    validate_structure_adapter_ids(&config.enabled_adapters)?;
+    for adapter_id in config.enabled_adapters.clone() {
+        let adapter = find_adapter_by_id(registry(), &adapter_id, CONFIG_PATH)?;
+        extend_unique(&mut config.source_roots, adapter.source_roots);
+        extend_unique(&mut config.test_roots, adapter.test_roots);
+        extend_unique(&mut config.module_roots, adapter.module_roots);
+        extend_unique(&mut config.allowed_root_files, adapter.allowed_root_files);
+    }
+    Ok(config)
+}
+
+pub fn validate_structure_adapter_ids(ids: &[String]) -> Result<(), NaomeError> {
+    validate_ids(ids, registry(), CONFIG_PATH)
+}
+
+fn registry() -> &'static [StructureAdapter] {
+    &[
+        StructureAdapter {
+            id: "rust",
+            detect: detects_rust_project,
+            source_roots: &["src/**", "crates/*/src/**", "**/crates/*/src/**"],
+            test_roots: &["tests/**", "crates/*/tests/**", "**/crates/*/tests/**"],
+            module_roots: &["src/**", "crates/*/src/**", "**/crates/*/src/**"],
+            allowed_root_files: &["Cargo.toml", "Cargo.lock"],
+        },
+        StructureAdapter {
+            id: "javascript-typescript",
+            detect: detects_javascript_typescript_project,
+            source_roots: &[
+                "src/**",
+                "app/**",
+                "pages/**",
+                "components/**",
+                "packages/*/src/**",
+                "**/packages/*/src/**",
+            ],
+            test_roots: &["test/**", "tests/**", "__tests__/**", "packages/*/tests/**"],
+            module_roots: &["src/**", "app/**", "packages/*/src/**"],
+            allowed_root_files: &[
+                "package.json",
+                "tsconfig.json",
+                "vite.config.ts",
+                "next.config.js",
+            ],
+        },
+    ]
+}

package/crates/naome-core/src/quality/structure/checks/basic.rs

@@ -0,0 +1,153 @@
+use crate::paths;
+use crate::quality::types::{QualityMode, QualityViolation};
+
+use super::{applies, push};
+use crate::quality::structure::model::{DirectoryRoleRule, RepositoryStructureModel};
+
+pub(super) fn root_file_sprawl(
+    model: &RepositoryStructureModel,
+    mode: QualityMode,
+    violations: &mut Vec<QualityViolation>,
+) {
+    for path in model
+        .paths
+        .iter()
+        .filter(|path| applies(path, mode) && path.segments.len() == 1)
+    {
+        if paths::matches_any(&path.explanation.path, &model.config.allowed_root_files) {
+            continue;
+        }
+        push_single_path(
+            "root-file-sprawl",
+            &path.explanation.path,
+            format!(
+                "{} is a root-level file without a recognized root role; place new work inside a module, docs, config, or script directory.",
+                path.explanation.path
+            ),
+            violations,
+        );
+    }
+}
+
+pub(super) fn misplaced_files(
+    model: &RepositoryStructureModel,
+    mode: QualityMode,
+    violations: &mut Vec<QualityViolation>,
+) {
+    for path in model.paths.iter().filter(|path| applies(path, mode)) {
+        let role = path.explanation.role.as_str();
+        let misplaced_test =
+            role == "test" && !paths::matches_any(&path.explanation.path, &model.config.test_roots);
+        if misplaced_test {
+            push_single_path(
+                "misplaced-file-role",
+                &path.explanation.path,
+                format!(
+                    "{} is test code outside a configured test root.",
+                    path.explanation.path
+                ),
+                violations,
+            );
+        }
+    }
+}
+
+pub(super) fn directory_role_mixing(
+    model: &RepositoryStructureModel,
+    mode: QualityMode,
+    violations: &mut Vec<QualityViolation>,
+) {
+    for path in model.paths.iter().filter(|path| {
+        applies(path, mode)
+            && matches!(path.explanation.role.as_str(), "generated" | "artifact")
+            && paths::matches_any(&path.explanation.path, &model.config.source_roots)
+    }) {
+        if role_rule_allows_path(model, &path.explanation.path, &path.explanation.role) {
+            continue;
+        }
+        push_single_path(
+            "directory-role-mixing",
+            &path.explanation.path,
+            format!(
+                "{} is {} content under a source root.",
+                path.explanation.path, path.explanation.role
+            ),
+            violations,
+        );
+    }
+
+    for directory in &model.directories {
+        let rule = directory_role_rule_for(model, &directory.path);
+        let allowed_by_rule = rule
+            .filter(|rule| !rule.allowed_roles.is_empty())
+            .is_some_and(|rule| {
+                directory
+                    .roles
+                    .iter()
+                    .all(|role| rule.allowed_roles.iter().any(|allowed| allowed == role))
+            });
+        let max_roles = rule
+            .and_then(|rule| rule.max_roles)
+            .unwrap_or(model.config.limits.max_directory_roles);
+        let incompatible = directory.roles.contains("source")
+            && (directory.roles.contains("generated")
+                || directory.roles.contains("artifact")
+                || directory.roles.contains("dependency/vendor"));
+        let too_many_roles = directory.roles.len() > max_roles
+            && (directory.roles.contains("source")
+                || directory.roles.contains("generated")
+                || directory.roles.contains("artifact"));
+        if (!incompatible || allowed_by_rule) && !too_many_roles {
+            continue;
+        }
+        for path in model.paths.iter().filter(|path| {
+            path.explanation.directory == directory.path
+                && applies(path, mode)
+                && path.explanation.role != "source"
+        }) {
+            push(
+                "directory-role-mixing",
+                &path.explanation.path,
+                format!(
+                    "{} mixes incompatible directory roles: {}.",
+                    directory.path,
+                    directory
+                        .roles
+                        .iter()
+                        .cloned()
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                ),
+                vec![],
+                violations,
+            );
+        }
+    }
+}
+
+fn role_rule_allows_path(model: &RepositoryStructureModel, path: &str, role: &str) -> bool {
+    model.config.directory_role_rules.iter().any(|rule| {
+        !rule.allowed_roles.is_empty()
+            && paths::matches_any(path, &rule.paths)
+            && rule.allowed_roles.iter().any(|allowed| allowed == role)
+    })
+}
+
+fn directory_role_rule_for<'a>(
+    model: &'a RepositoryStructureModel,
+    directory: &str,
+) -> Option<&'a DirectoryRoleRule> {
+    model.config.directory_role_rules.iter().find(|rule| {
+        paths::matches_any(directory, &rule.paths)
+            || paths::matches_any(&format!("{directory}/_"), &rule.paths)
+    })
+}
+
+fn push_single_path(
+    check_id: &str,
+    path: &str,
+    message: String,
+    violations: &mut Vec<QualityViolation>,
+) {
+    push(check_id, path, message, vec![], violations);
+}