@lamentis/naome 1.2.1 → 1.3.1

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

@@ -0,0 +1,151 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use super::model::{ObjectCandidate, SemanticFinding};
+use super::route::{cleanup_route, finding_mode};
+use crate::quality::scanner::{stable_fingerprint, QualityContext};
+
+pub(super) fn copied_config_findings(
+    context: &QualityContext,
+    candidates: &[ObjectCandidate],
+) -> Vec<SemanticFinding> {
+    let mut by_shape: BTreeMap<&str, Vec<&ObjectCandidate>> = BTreeMap::new();
+    for candidate in candidates
+        .iter()
+        .filter(|candidate| candidate.keys.len() >= 4 && candidate.line_count >= 8)
+        .filter(|candidate| has_config_shape_signal(&candidate.keys))
+    {
+        by_shape
+            .entry(candidate.shape_hash.as_str())
+            .or_default()
+            .push(candidate);
+    }
+
+    by_shape
+        .into_values()
+        .filter(|group| group.len() >= 2)
+        .filter(|group| group_applies_to_mode(context, group))
+        .map(|group| {
+            let occurrences = group
+                .iter()
+                .map(|candidate| candidate.occurrence())
+                .collect::<Vec<_>>();
+            let primary = &occurrences[0];
+            let id = stable_fingerprint(&[
+                "semantic",
+                "copied-config-object",
+                &primary.shape_hash,
+                &primary.path,
+            ]);
+            SemanticFinding {
+                id,
+                kind: "copied-config-object".to_string(),
+                confidence: 0.92,
+                severity: "medium".to_string(),
+                mode: finding_mode(context).to_string(),
+                summary: format!(
+                    "Same config-like object shape appears in {} locations.",
+                    occurrences.len()
+                ),
+                cleanup_route: cleanup_route(
+                    "Extract shared fixture builder",
+                    &occurrences,
+                    "Create a shared fixture or builder for the repeated object shape.",
+                ),
+                occurrences,
+            }
+        })
+        .collect()
+}
+
+pub(super) fn inline_legacy_fixture_findings(
+    context: &QualityContext,
+    candidates: &[ObjectCandidate],
+) -> Vec<SemanticFinding> {
+    candidates
+        .iter()
+        .filter(|candidate| context.applies_to(&candidate.path))
+        .filter(|candidate| candidate.in_test_context)
+        .filter(|candidate| !is_shared_fixture_factory(candidate))
+        .filter(|candidate| candidate.line_count >= 8)
+        .filter(|candidate| has_legacy_fixture_signal(&candidate.keys))
+        .map(|candidate| {
+            let occurrence = candidate.occurrence();
+            let id = stable_fingerprint(&[
+                "semantic",
+                "inline-legacy-fixture",
+                &occurrence.shape_hash,
+                &occurrence.path,
+                &occurrence.start_line.to_string(),
+            ]);
+            SemanticFinding {
+                id,
+                kind: "inline-legacy-fixture".to_string(),
+                confidence: 0.86,
+                severity: "medium".to_string(),
+                mode: finding_mode(context).to_string(),
+                summary: "Large schema/version fixture is inline in a test or support context."
+                    .to_string(),
+                cleanup_route: cleanup_route(
+                    "Extract compatibility fixture",
+                    std::slice::from_ref(&occurrence),
+                    "Move the inline legacy fixture into a shared test fixture factory and keep version-specific differences explicit.",
+                ),
+                occurrences: vec![occurrence],
+            }
+        })
+        .collect()
+}
+
+fn has_config_shape_signal(keys: &BTreeSet<String>) -> bool {
+    keys.contains("schema")
+        || keys.contains("version")
+        || keys.contains("status")
+        || keys.contains("enabledadapters")
+        || keys.contains("disabledchecks")
+        || keys.contains("limits")
+}
+
+fn has_legacy_fixture_signal(keys: &BTreeSet<String>) -> bool {
+    (keys.contains("schema") && keys.contains("version"))
+        || (keys.contains("version") && keys.contains("status"))
+        || (keys.contains("fromversion") && keys.contains("toversion"))
+}
+
+fn is_shared_fixture_factory(candidate: &ObjectCandidate) -> bool {
+    if is_shared_fixture_path(&candidate.path) {
+        return true;
+    }
+    let Some(symbol) = &candidate.symbol else {
+        return false;
+    };
+    let normalized = symbol.to_ascii_lowercase();
+    [
+        "builder", "contract", "factory", "fixture", "make", "template",
+    ]
+    .iter()
+    .any(|marker| normalized.contains(marker))
+}
+
+fn is_shared_fixture_path(path: &str) -> bool {
+    let normalized = path.replace('\\', "/").to_ascii_lowercase();
+    [
+        "/fixtures/",
+        "/fixture/",
+        "/support/",
+        "_support/",
+        "-support/",
+        "/test-support.",
+    ]
+    .iter()
+    .any(|marker| normalized.contains(marker))
+}
+
+fn group_applies_to_mode(context: &QualityContext, group: &[&ObjectCandidate]) -> bool {
+    if context.mode.is_deep() {
+        return true;
+    }
+    context.mode.is_changed()
+        && group
+            .iter()
+            .any(|candidate| context.applies_to(&candidate.path))
+}

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 | QualityMode::PathScoped => "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/adapter_ios.rs

@@ -0,0 +1,149 @@
+use crate::quality::adapter_support::{
+    detects_generated_ios_project, detects_ios_app_structure_project,
+    detects_ios_resources_project, detects_swift_package_project, detects_swift_project,
+    detects_swiftui_project, detects_xcode_project, detects_xctest_project,
+};
+
+use super::adapters::StructureAdapter;
+
+pub(super) fn adapters() -> Vec<StructureAdapter> {
+    let mut adapters = Vec::new();
+    adapters.extend_from_slice(IOS_CORE_STRUCTURE_ADAPTERS);
+    adapters.extend_from_slice(IOS_APP_STRUCTURE_ADAPTERS);
+    adapters
+}
+
+const IOS_CORE_STRUCTURE_ADAPTERS: &[StructureAdapter] = &[
+    StructureAdapter {
+        id: "swift",
+        detect: detects_swift_project,
+        source_roots: &[
+            "Sources/**",
+            "**/Sources/**",
+            "Source/**",
+            "App/**",
+            "Features/**",
+            "Modules/**",
+            "Shared/**",
+        ],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &[
+            "Sources/*/**",
+            "**/Sources/*/**",
+            "App/**",
+            "Features/*/**",
+            "Modules/*/**",
+        ],
+        allowed_root_files: &[],
+    },
+    StructureAdapter {
+        id: "xcode",
+        detect: detects_xcode_project,
+        source_roots: &[],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[
+            "DerivedData/**",
+            "**/DerivedData/**",
+            "Build/**",
+            "**/Build/**",
+            "**/*.xcarchive/**",
+        ],
+        module_roots: &[],
+        allowed_root_files: &["*.xcodeproj", "*.xcworkspace"],
+    },
+    StructureAdapter {
+        id: "xctest",
+        detect: detects_xctest_project,
+        source_roots: &[],
+        test_roots: &[
+            "Tests/**",
+            "**/Tests/**",
+            "*Tests/**",
+            "**/*Tests/**",
+            "*UITests/**",
+            "**/*UITests/**",
+        ],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &[],
+        allowed_root_files: &[],
+    },
+];
+
+const IOS_APP_STRUCTURE_ADAPTERS: &[StructureAdapter] = &[
+    StructureAdapter {
+        id: "swiftui",
+        detect: detects_swiftui_project,
+        source_roots: &[
+            "Views/**",
+            "**/Views/**",
+            "Preview Content/**",
+            "**/Preview Content/**",
+        ],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &["Views/*/**", "**/Views/*/**"],
+        allowed_root_files: &[],
+    },
+    StructureAdapter {
+        id: "ios-app-structure",
+        detect: detects_ios_app_structure_project,
+        source_roots: &[
+            "App/**",
+            "Application/**",
+            "Features/**",
+            "Modules/**",
+            "Shared/**",
+        ],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &["Features/*/**", "Modules/*/**", "App/**"],
+        allowed_root_files: &["Info.plist", "*.entitlements", "Podfile", "Cartfile"],
+    },
+    StructureAdapter {
+        id: "swift-package",
+        detect: detects_swift_package_project,
+        source_roots: &["Sources/**", "**/Sources/**"],
+        test_roots: &["Tests/**", "**/Tests/**"],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &["Sources/*/**", "**/Sources/*/**"],
+        allowed_root_files: &["Package.swift", "Package.resolved"],
+    },
+    StructureAdapter {
+        id: "ios-resources",
+        detect: detects_ios_resources_project,
+        source_roots: &["Resources/**", "**/Resources/**"],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &["Resources/**", "**/Resources/**"],
+        allowed_root_files: &["Info.plist", "*.entitlements"],
+    },
+    StructureAdapter {
+        id: "generated-ios",
+        detect: detects_generated_ios_project,
+        source_roots: &[],
+        test_roots: &[],
+        generated_roots: &[
+            "Generated/**",
+            "**/Generated/**",
+            "SwiftGen/**",
+            "**/SwiftGen/**",
+            "Sourcery/**",
+            "**/Sourcery/**",
+            "**/*.generated.swift",
+            "**/*.pb.swift",
+            "**/*.grpc.swift",
+            "**/R.generated.swift",
+        ],
+        artifact_roots: &[],
+        module_roots: &[],
+        allowed_root_files: &[],
+    },
+];