@lamentis/naome 1.2.1 → 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/checks/directory.rs

@@ -1,5 +1,3 @@
-use std::collections::BTreeMap;
-
 use crate::quality::structure::model::{RepositoryStructureModel, StructurePath};
 use crate::quality::types::{QualityMode, QualityViolation};
 
@@ -38,7 +36,7 @@ pub(super) fn directory_size(
         if directory.file_count <= model.config.limits.max_directory_files {
             continue;
         }
-        if mode == QualityMode::Changed && directory.direct_changed_paths.is_empty() {
+        if mode.is_changed() && directory.direct_changed_paths.is_empty() {
             continue;
         }
         push_with_limit(
@@ -85,20 +83,11 @@ pub(super) fn case_collisions(
     mode: QualityMode,
     violations: &mut Vec<QualityViolation>,
 ) {
-    let mut groups: BTreeMap<String, Vec<String>> = BTreeMap::new();
-    for path in &model.paths {
-        groups
-            .entry(path.explanation.path.to_ascii_lowercase())
-            .or_default()
-            .push(path.explanation.path.clone());
-    }
-    for group in groups.values().filter(|group| group.len() > 1) {
+    for group in model.lowercase_paths.values().filter(|group| group.len() > 1) {
         let changed_group = group.iter().any(|path| {
-            model.paths.iter().any(|candidate| {
-                candidate.explanation.path == *path && candidate.explanation.changed
-            })
+            model.changed_paths.contains(path)
         });
-        if mode == QualityMode::Changed && !changed_group {
+        if mode.is_changed() && !changed_group {
             continue;
         }
         for path in group {
@@ -134,10 +123,11 @@ fn related_module_paths(model: &RepositoryStructureModel, path: &StructurePath)
         return Vec::new();
     };
     model
-        .paths
-        .iter()
-        .filter(|candidate| candidate.explanation.module.as_ref() == Some(module))
-        .map(|candidate| candidate.explanation.path.clone())
+        .module_paths
+        .get(module)
+        .into_iter()
+        .flatten()
+        .cloned()
         .filter(|candidate| candidate != &path.explanation.path)
         .take(10)
         .collect()

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

@@ -53,7 +53,7 @@ fn check_enabled(model: &RepositoryStructureModel, check_id: &str) -> bool {
 }
 
 fn applies(path: &StructurePath, mode: QualityMode) -> bool {
-    mode == QualityMode::Report || path.explanation.changed
+    !mode.is_changed() || path.explanation.changed
 }
 
 fn push(

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

@@ -24,10 +24,16 @@ pub fn build_structure_model(
         .collect::<Vec<_>>();
     paths.sort_by(|left, right| left.explanation.path.cmp(&right.explanation.path));
     let directories = directories_for(&paths);
+    let indexes = indexes_for(&paths);
     RepositoryStructureModel {
         config,
         paths,
         directories,
+        module_paths: indexes.module_paths,
+        directory_paths: indexes.directory_paths,
+        role_paths: indexes.role_paths,
+        lowercase_paths: indexes.lowercase_paths,
+        changed_paths: indexes.changed_paths,
     }
 }
 
@@ -92,3 +98,49 @@ fn directory_of(path: &str) -> String {
         .map(|(directory, _)| directory.to_string())
         .unwrap_or_else(|| ".".to_string())
 }
+
+struct StructureIndexes {
+    module_paths: BTreeMap<String, Vec<String>>,
+    directory_paths: BTreeMap<String, Vec<String>>,
+    role_paths: BTreeMap<String, Vec<String>>,
+    lowercase_paths: BTreeMap<String, Vec<String>>,
+    changed_paths: BTreeSet<String>,
+}
+
+fn indexes_for(paths: &[StructurePath]) -> StructureIndexes {
+    let mut module_paths = BTreeMap::new();
+    let mut directory_paths = BTreeMap::new();
+    let mut role_paths = BTreeMap::new();
+    let mut lowercase_paths = BTreeMap::new();
+    let mut changed_paths = BTreeSet::new();
+    for path in paths {
+        let value = path.explanation.path.clone();
+        if let Some(module) = &path.explanation.module {
+            push_index(&mut module_paths, module, &value);
+        }
+        push_index(&mut directory_paths, &path.explanation.directory, &value);
+        push_index(&mut role_paths, &path.explanation.role, &value);
+        push_index(
+            &mut lowercase_paths,
+            &path.explanation.path.to_ascii_lowercase(),
+            &value,
+        );
+        if path.explanation.changed {
+            changed_paths.insert(value);
+        }
+    }
+    StructureIndexes {
+        module_paths,
+        directory_paths,
+        role_paths,
+        lowercase_paths,
+        changed_paths,
+    }
+}
+
+fn push_index(index: &mut BTreeMap<String, Vec<String>>, key: &str, value: &str) {
+    index
+        .entry(key.to_string())
+        .or_default()
+        .push(value.to_string());
+}

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

@@ -11,7 +11,7 @@ use std::path::Path;
 use crate::models::NaomeError;
 
 use super::scanner::QualityContext;
-use super::types::{QualityMode, QualityViolation};
+use super::types::QualityViolation;
 use checks::run_structure_checks;
 use classify::build_structure_model;
 use config::read_structure_config;
@@ -33,7 +33,7 @@ pub fn run_repository_structure_checks(
                 .find(|file| file.path == violation.path)
                 .is_some_and(|file| !file.symbols.is_empty())
     });
-    if context.mode == QualityMode::Report {
+    if !context.mode.is_changed() {
         for violation in &mut violations {
             violation.baseline = baseline_fingerprints.contains(&violation.fingerprint);
         }

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

@@ -1,4 +1,4 @@
-use std::collections::BTreeSet;
+use std::collections::{BTreeMap, BTreeSet};
 
 use serde::{Deserialize, Serialize};
 
@@ -121,4 +121,11 @@ pub struct RepositoryStructureModel {
     pub config: RepositoryStructureConfig,
     pub paths: Vec<StructurePath>,
     pub directories: Vec<StructureDirectory>,
+    pub module_paths: BTreeMap<String, Vec<String>>,
+    #[allow(dead_code)]
+    pub directory_paths: BTreeMap<String, Vec<String>>,
+    #[allow(dead_code)]
+    pub role_paths: BTreeMap<String, Vec<String>>,
+    pub lowercase_paths: BTreeMap<String, Vec<String>>,
+    pub changed_paths: BTreeSet<String>,
 }

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

@@ -4,15 +4,45 @@ use crate::paths;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum QualityMode {
-    Changed,
+    ChangedFast,
     Report,
+    DeepReport,
 }
 
 impl QualityMode {
+    #[allow(non_upper_case_globals)]
+    pub const Changed: Self = Self::ChangedFast;
+
     pub fn as_str(self) -> &'static str {
         match self {
-            Self::Changed => "changed",
+            Self::ChangedFast => "changed",
             Self::Report => "report",
+            Self::DeepReport => "deep-report",
+        }
+    }
+
+    pub fn is_changed(self) -> bool {
+        self == Self::ChangedFast
+    }
+
+    pub fn is_deep(self) -> bool {
+        self == Self::DeepReport
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum QualityInitMode {
+    SeedOnly,
+    Baseline,
+    DeepBaseline,
+}
+
+impl QualityInitMode {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::SeedOnly => "init",
+            Self::Baseline => "baseline",
+            Self::DeepBaseline => "deep-baseline",
         }
     }
 }
@@ -187,9 +217,14 @@ pub struct QualityReport {
 #[serde(rename_all = "camelCase")]
 pub struct QualitySummary {
     pub scanned_files: usize,
+    pub scanned_path_count: usize,
     pub violation_count: usize,
     pub baseline_violation_count: usize,
     pub blocking_violation_count: usize,
+    pub truncated: bool,
+    pub reason_codes: Vec<String>,
+    pub cache_hits: usize,
+    pub cache_misses: usize,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -211,9 +246,11 @@ pub struct QualityViolation {
 #[serde(rename_all = "camelCase")]
 pub struct QualityInitResult {
     pub schema: String,
+    pub mode: String,
     pub config_written: bool,
     pub structure_config_written: bool,
     pub baseline_written: bool,
+    pub baseline_pending: bool,
     pub baseline_violations: usize,
     pub config_path: String,
     pub structure_config_path: String,
@@ -258,6 +295,7 @@ pub fn default_generated_paths() -> Vec<String> {
 const DEFAULT_IGNORED_PATHS: &str = r#"
 .git/**
 .naome/archive/**
+.naome/cache/**
 .naome/task-state.json
 .naome/task-journal.jsonl
 .naome/repository-quality.json

package/crates/naome-core/src/route/builtin_checks.rs

@@ -18,16 +18,6 @@ pub(super) fn run_quality_check(
     check: &QualityCheck,
 ) -> Result<(), NaomeError> {
     match check_id {
-        "installer-tests" => require_builtin_quality_check(
-            check_id,
-            check,
-            "npm run test:naome-installer",
-        ),
-        "rust-build" => require_builtin_quality_check(check_id, check, "npm run build:rust"),
-        "decision-engine-tests" => {
-            require_builtin_quality_check(check_id, check, "npm run test:decision-engine")
-        }
-        "package-dry-run" => require_builtin_quality_check(check_id, check, "npm run pack:dry-run"),
         "diff-check" => {
             require_builtin_quality_check(check_id, check, "git diff --check")?;
             let output = git_output(root, &["diff", "--check"])?;
@@ -46,10 +36,6 @@ pub(super) fn run_quality_check(
             )?;
             run_harness_health_check(root)
         }
-        "dogfood-health" => {
-            require_builtin_quality_check(check_id, check, "npm run dogfood:health")?;
-            run_harness_health_check(root)
-        }
         "task-state-check" => {
             require_builtin_quality_check(check_id, check, "npm run check:task-state")?;
             run_template_task_state_check(root)
@@ -85,7 +71,7 @@ pub(super) fn run_quality_check(
 }
 
 fn run_repository_quality_check(root: &Path) -> Result<(), NaomeError> {
-    let report = check_repository_quality(root, QualityMode::Changed)?;
+    let report = check_repository_quality(root, QualityMode::ChangedFast)?;
     if report.ok {
         return Ok(());
     }