@lamentis/naome 1.1.1 → 1.2.0

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

@@ -8,6 +8,7 @@ use serde::Serialize;
 use serde_json::Value;
 
 use crate::models::NaomeError;
+use crate::task_state::canonical_proof_check_ids;
 
 const JOURNAL_PATH: &str = ".naome/task-journal.jsonl";
 
@@ -121,17 +122,7 @@ fn journal_contains(root: &Path, entry: &TaskJournalEntry) -> Result<bool, Naome
 }
 
 fn proof_summary(active_task: &Value) -> Vec<String> {
-    active_task
-        .get("proofResults")
-        .and_then(Value::as_array)
-        .map(|proofs| {
-            proofs
-                .iter()
-                .filter_map(|proof| proof.get("checkId").and_then(Value::as_str))
-                .map(ToString::to_string)
-                .collect()
-        })
-        .unwrap_or_default()
+    canonical_proof_check_ids(active_task)
 }
 
 fn read_json(root: &Path, relative_path: &str) -> Result<Value, NaomeError> {
@@ -148,16 +139,14 @@ fn string_at(value: &Value, key: &str) -> Option<String> {
 }
 
 fn git_head(root: &Path) -> Result<Option<String>, NaomeError> {
-    let output = Command::new("git")
-        .args(["rev-parse", "HEAD"])
-        .current_dir(root)
-        .output()?;
-    if !output.status.success() {
-        return Ok(None);
+    let mut command = Command::new("git");
+    command.current_dir(root).arg("rev-parse").arg("HEAD");
+    let output = command.output()?;
+    if output.status.success() {
+        let head = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        return Ok(Some(head));
     }
-    Ok(Some(
-        String::from_utf8_lossy(&output.stdout).trim().to_string(),
-    ))
+    Ok(None)
 }
 
 fn timestamp_now() -> String {

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

@@ -6,10 +6,12 @@ mod intent;
 mod journal;
 mod models;
 mod paths;
+mod quality;
 mod route;
 mod task_state;
 mod verification;
 mod verification_contract;
+mod workflow;
 
 pub use decision::{evaluate_decision, format_decision, EvaluationOptions};
 pub use harness_health::{validate_harness_health, HarnessHealthOptions};
@@ -17,6 +19,11 @@ pub use install_plan::{install_plan, InstallPlan};
 pub use intent::{evaluate_intent, format_intent, IntentDecision, PromptEvidence};
 pub use journal::{append_task_journal, TaskJournalEntry};
 pub use models::{Decision, NaomeError};
+pub use quality::{
+    check_repository_quality, init_repository_quality, plan_quality_cleanup, route_quality_cleanup,
+    QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask, QualityInitResult, QualityMode,
+    QualityReport, QualitySummary, QualityViolation, RepositoryQualityConfig,
+};
 pub use route::{evaluate_route, explain_route, ExplainDecision, RouteDecision, RouteOptions};
 pub use task_state::{
     completed_task_commit_paths, validate_task_state, TaskStateMode, TaskStateOptions,
@@ -24,3 +31,9 @@ pub use task_state::{
 };
 pub use verification::seed_builtin_verification_checks;
 pub use verification_contract::validate_verification_contract;
+pub use workflow::{
+    classify_mutations, refresh_integrity, safe_rg_args, summarize_command_output,
+    tracked_process_report, validate_read_boundaries, validate_search_command,
+    verification_phase_plan, CommandCheckResult, CommandOutputSummary, IntegrityRefreshReport,
+    MutationClassification, ProcessReport, ReadActivity, VerificationPhasePlan, WorkflowFinding,
+};

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

@@ -0,0 +1,178 @@
+use std::collections::HashSet;
+
+use crate::models::NaomeError;
+
+use super::types::{QualityLimitOverrides, QualityPathRule, RepositoryQualityConfig};
+
+pub(crate) struct QualityAdapter {
+    pub id: &'static str,
+    pub generated_paths: &'static [&'static str],
+    detect: fn(&RepoSignals<'_>) -> bool,
+    path_rules: fn() -> Vec<QualityPathRule>,
+}
+
+struct RepoSignals<'a> {
+    paths: &'a [String],
+}
+impl RepoSignals<'_> {
+    fn has_manifest(&self, expected: &str) -> bool {
+        let nested_suffix = format!("/{expected}");
+        self.paths
+            .iter()
+            .any(|path| path == expected || path.ends_with(&nested_suffix))
+    }
+
+    fn has_extension(&self, extensions: &[&str]) -> bool {
+        self.paths
+            .iter()
+            .any(|path| extensions.iter().any(|extension| path.ends_with(extension)))
+    }
+}
+pub(crate) fn detected_adapter_ids(paths: &[String]) -> Vec<String> {
+    let signals = RepoSignals { paths };
+    registry()
+        .iter()
+        .filter(|adapter| (adapter.detect)(&signals))
+        .map(|adapter| adapter.id.to_string())
+        .collect()
+}
+pub(crate) fn apply_enabled_adapters(
+    mut config: RepositoryQualityConfig,
+) -> Result<RepositoryQualityConfig, NaomeError> {
+    let mut seen = HashSet::new();
+    let local_path_rules = std::mem::take(&mut config.path_rules);
+
+    for adapter_id in config.enabled_adapters.clone() {
+        if !seen.insert(adapter_id.clone()) {
+            return Err(NaomeError::new(format!(
+                ".naome/repository-quality.json enabledAdapters contains duplicate adapter '{adapter_id}'."
+            )));
+        }
+        let adapter = adapter_by_id(&adapter_id)?;
+        extend_unique(&mut config.generated_paths, adapter.generated_paths);
+        config.path_rules.extend((adapter.path_rules)());
+    }
+
+    config.path_rules.extend(local_path_rules);
+    Ok(config)
+}
+pub(crate) fn validate_adapter_ids(ids: &[String]) -> Result<(), NaomeError> {
+    let mut seen = HashSet::new();
+    for adapter_id in ids {
+        if !seen.insert(adapter_id) {
+            return Err(NaomeError::new(format!(
+                ".naome/repository-quality.json enabledAdapters contains duplicate adapter '{adapter_id}'."
+            )));
+        }
+        adapter_by_id(adapter_id)?;
+    }
+    Ok(())
+}
+fn adapter_by_id(id: &str) -> Result<&'static QualityAdapter, NaomeError> {
+    registry()
+        .iter()
+        .find(|adapter| adapter.id == id)
+        .ok_or_else(|| {
+            NaomeError::new(format!(
+                ".naome/repository-quality.json enabledAdapters contains unknown adapter '{id}'."
+            ))
+        })
+}
+
+fn registry() -> &'static [QualityAdapter] {
+    &[
+        QualityAdapter {
+            id: "rust",
+            generated_paths: &[],
+            detect: detects_rust,
+            path_rules: rust_path_rules,
+        },
+        QualityAdapter {
+            id: "javascript-typescript",
+            generated_paths: &["coverage/**", "**/coverage/**", ".next/**", "**/.next/**"],
+            detect: detects_javascript_typescript,
+            path_rules: javascript_typescript_path_rules,
+        },
+    ]
+}
+
+fn detects_rust(signals: &RepoSignals<'_>) -> bool {
+    signals.has_manifest("Cargo.toml") || signals.has_extension(&[".rs"])
+}
+
+fn detects_javascript_typescript(signals: &RepoSignals<'_>) -> bool {
+    signals.has_manifest("package.json")
+        || signals.has_extension(&[".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"])
+}
+
+fn rust_path_rules() -> Vec<QualityPathRule> {
+    vec![path_rule(
+        "rust-tests",
+        &["**/tests/*.rs", "**/tests/**/*.rs"],
+        test_file_limits(80),
+        &[],
+    )]
+}
+
+fn javascript_typescript_path_rules() -> Vec<QualityPathRule> {
+    vec![QualityPathRule {
+        id: "javascript-typescript-tests".to_string(),
+        paths: javascript_typescript_test_paths(),
+        limits: test_file_limits(80),
+        disabled_checks: Vec::new(),
+    }]
+}
+
+fn javascript_typescript_test_paths() -> Vec<String> {
+    let mut paths = Vec::new();
+    for marker in ["test", "spec"] {
+        for extension in ["js", "jsx", "ts", "tsx"] {
+            paths.push(format!("**/*.{marker}.{extension}"));
+        }
+    }
+    for directory in ["test", "tests"] {
+        for extension in ["js", "jsx", "ts", "tsx"] {
+            paths.push(format!("**/{directory}/**/*.{extension}"));
+        }
+    }
+    paths.push("scripts/*.test.js".to_string());
+    paths
+}
+
+fn test_file_limits(max_top_level_symbols: usize) -> QualityLimitOverrides {
+    QualityLimitOverrides {
+        max_file_lines: Some(650),
+        max_diff_added_lines: Some(220),
+        max_function_lines: Some(140),
+        max_top_level_symbols: Some(max_top_level_symbols),
+        duplicate_block_lines: Some(14),
+        near_duplicate_similarity: Some(0.96),
+        ..QualityLimitOverrides::default()
+    }
+}
+
+fn path_rule(
+    id: &str,
+    paths: &[&str],
+    limits: QualityLimitOverrides,
+    disabled_checks: &[&str],
+) -> QualityPathRule {
+    QualityPathRule {
+        id: id.to_string(),
+        paths: string_list(paths),
+        limits,
+        disabled_checks: string_list(disabled_checks),
+    }
+}
+
+fn string_list(values: &[&str]) -> Vec<String> {
+    values.iter().map(|value| (*value).to_string()).collect()
+}
+
+fn extend_unique(target: &mut Vec<String>, values: &[&str]) {
+    for value in values {
+        if !target.iter().any(|existing| existing == value) {
+            target.push((*value).to_string());
+        }
+    }
+}

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

@@ -0,0 +1,75 @@
+use std::collections::HashSet;
+use std::fs;
+use std::path::Path;
+
+use serde::{Deserialize, Serialize};
+
+use crate::models::NaomeError;
+
+use super::types::QualityViolation;
+
+const BASELINE_RELATIVE_PATH: &str = ".naome/repository-quality-baseline.json";
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct QualityBaseline {
+    schema: String,
+    version: u32,
+    violations: Vec<QualityBaselineEntry>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct QualityBaselineEntry {
+    fingerprint: String,
+    check_id: String,
+    path: String,
+    message: String,
+}
+
+pub fn baseline_relative_path() -> &'static str {
+    BASELINE_RELATIVE_PATH
+}
+
+pub fn read_baseline_fingerprints(root: &Path) -> Result<HashSet<String>, NaomeError> {
+    let path = root.join(BASELINE_RELATIVE_PATH);
+    if !path.is_file() {
+        return Ok(HashSet::new());
+    }
+
+    let baseline: QualityBaseline = serde_json::from_str(&fs::read_to_string(path)?)?;
+    Ok(baseline
+        .violations
+        .into_iter()
+        .map(|violation| violation.fingerprint)
+        .collect())
+}
+
+pub fn write_baseline(root: &Path, violations: &[QualityViolation]) -> Result<bool, NaomeError> {
+    let path = root.join(BASELINE_RELATIVE_PATH);
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    let entries = violations
+        .iter()
+        .map(|violation| QualityBaselineEntry {
+            fingerprint: violation.fingerprint.clone(),
+            check_id: violation.check_id.clone(),
+            path: violation.path.clone(),
+            message: violation.message.clone(),
+        })
+        .collect();
+    let baseline = QualityBaseline {
+        schema: "naome.repository-quality-baseline.v1".to_string(),
+        version: 1,
+        violations: entries,
+    };
+    let content = serde_json::to_string_pretty(&baseline)?;
+    let next = format!("{content}\n");
+    let changed = fs::read_to_string(&path).map_or(true, |current| current != next);
+    if changed {
+        fs::write(path, next)?;
+    }
+    Ok(changed)
+}

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

@@ -0,0 +1,175 @@
+use std::collections::{HashMap, HashSet};
+
+use super::super::scanner::{stable_fingerprint, QualityContext};
+use super::super::types::QualityViolation;
+use super::{is_code_like_path, QualityCheck};
+
+pub(super) struct DuplicateBlockCheck;
+
+impl QualityCheck for DuplicateBlockCheck {
+    fn id(&self) -> &'static str {
+        "duplicate-blocks"
+    }
+
+    fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>) {
+        let mut occurrences: HashMap<String, Vec<DuplicateOccurrence>> = HashMap::new();
+        for file in context.files.iter().filter(|file| {
+            is_code_like_path(&file.path)
+                && context.config.check_enabled_for_path(self.id(), &file.path)
+        }) {
+            let window = context.limits_for(&file.path).duplicate_block_lines;
+            if file.normalized_lines.len() < window {
+                continue;
+            }
+            for lines in file.normalized_lines.windows(window) {
+                let joined = lines
+                    .iter()
+                    .map(|line| line.value.as_str())
+                    .collect::<Vec<_>>()
+                    .join("\n");
+                let fingerprint = stable_fingerprint(&[self.id(), &joined]);
+                occurrences
+                    .entry(fingerprint.clone())
+                    .or_default()
+                    .push(DuplicateOccurrence {
+                        path: file.path.clone(),
+                        line: lines[0].line_number,
+                        window,
+                        fingerprint,
+                    });
+            }
+        }
+
+        let mut emitted = HashSet::new();
+        let mut candidates = Vec::new();
+        for group in occurrences.values() {
+            for occurrence in group {
+                if !context.check_applies_to(self.id(), &occurrence.path)
+                    || !is_code_like_path(&occurrence.path)
+                {
+                    continue;
+                }
+                let related_paths = related_duplicate_paths(group, occurrence);
+                if related_paths.is_empty() {
+                    continue;
+                }
+                let key = format!(
+                    "{}:{}:{}",
+                    occurrence.path, occurrence.line, occurrence.fingerprint
+                );
+                if emitted.insert(key) {
+                    candidates.push(DuplicateCandidate {
+                        path: occurrence.path.clone(),
+                        line: occurrence.line,
+                        window: occurrence.window,
+                        related_paths,
+                        fingerprint: occurrence.fingerprint.clone(),
+                    });
+                }
+            }
+        }
+        emit_duplicate_regions(self.id(), candidates, violations);
+    }
+}
+
+#[derive(Debug, Clone)]
+struct DuplicateOccurrence {
+    path: String,
+    line: usize,
+    window: usize,
+    fingerprint: String,
+}
+
+#[derive(Debug, Clone)]
+struct DuplicateCandidate {
+    path: String,
+    line: usize,
+    window: usize,
+    related_paths: Vec<String>,
+    fingerprint: String,
+}
+
+fn emit_duplicate_regions(
+    check_id: &str,
+    mut candidates: Vec<DuplicateCandidate>,
+    violations: &mut Vec<QualityViolation>,
+) {
+    candidates.sort_by(|left, right| {
+        left.path
+            .cmp(&right.path)
+            .then(left.related_paths.cmp(&right.related_paths))
+            .then(left.line.cmp(&right.line))
+            .then(left.window.cmp(&right.window))
+            .then(left.fingerprint.cmp(&right.fingerprint))
+    });
+
+    let mut regions: Vec<DuplicateCandidate> = Vec::new();
+    for candidate in candidates {
+        if let Some(previous) = regions.last_mut() {
+            if previous.path == candidate.path
+                && previous.related_paths == candidate.related_paths
+                && candidate.line <= previous.line.saturating_add(previous.window)
+            {
+                previous.window = previous
+                    .window
+                    .max(candidate.line.saturating_sub(previous.line) + candidate.window);
+                continue;
+            }
+        }
+        regions.push(candidate);
+    }
+
+    for region in regions {
+        violations.push(QualityViolation {
+            check_id: check_id.to_string(),
+            severity: "blocking".to_string(),
+            path: region.path.clone(),
+            line: Some(region.line),
+            message: format!(
+                "{} repeats a normalized code region already present in {}.",
+                region.path,
+                region.related_paths.join(", ")
+            ),
+            value: Some(region.window as f64),
+            limit: Some(region.window as f64),
+            fingerprint: stable_fingerprint(&[
+                check_id,
+                &region.path,
+                &region.line.to_string(),
+                &region.window.to_string(),
+                &region.related_paths.join("\0"),
+                &region.fingerprint,
+            ]),
+            related_paths: region.related_paths,
+            baseline: false,
+        });
+    }
+}
+
+fn related_duplicate_paths(
+    group: &[DuplicateOccurrence],
+    occurrence: &DuplicateOccurrence,
+) -> Vec<String> {
+    let mut related = group
+        .iter()
+        .filter(|other| duplicate_occurrences_are_related(occurrence, other))
+        .map(|other| other.path.clone())
+        .collect::<HashSet<_>>()
+        .into_iter()
+        .collect::<Vec<_>>();
+    related.sort();
+    related
+}
+
+fn duplicate_occurrences_are_related(
+    occurrence: &DuplicateOccurrence,
+    other: &DuplicateOccurrence,
+) -> bool {
+    if occurrence.path != other.path {
+        return true;
+    }
+    if occurrence.line == other.line {
+        return false;
+    }
+    other.line.saturating_add(other.window).saturating_sub(1) < occurrence.line
+}

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

@@ -0,0 +1,130 @@
+use std::collections::HashSet;
+
+use super::super::scanner::{FileAnalysis, QualityContext, SymbolAnalysis};
+use super::super::types::QualityViolation;
+use super::{is_code_like_path, violation, QualityCheck};
+
+pub(super) struct NearDuplicateFunctionCheck;
+
+impl QualityCheck for NearDuplicateFunctionCheck {
+    fn id(&self) -> &'static str {
+        "near-duplicate-functions"
+    }
+
+    fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>) {
+        let symbols = collect_function_occurrences(context, self.id());
+        let mut emitted = HashSet::new();
+
+        for (index, left) in symbols.iter().enumerate() {
+            if !context.applies_to(&left.file.path) {
+                continue;
+            }
+            for right in symbols.iter().skip(index + 1) {
+                if same_symbol(left, right)
+                    || symbols_have_parent_child_relationship(left.symbol, right.symbol)
+                    || !context
+                        .config
+                        .check_enabled_for_path(self.id(), &right.file.path)
+                {
+                    continue;
+                }
+                let threshold = duplicate_threshold(context, left.file, right.file);
+                let similarity = jaccard(&left.symbol.tokens, &right.symbol.tokens);
+                if similarity < threshold {
+                    continue;
+                }
+                let key = format!(
+                    "{}:{}:{}:{}",
+                    left.file.path,
+                    left.symbol.start_line,
+                    right.file.path,
+                    right.symbol.start_line
+                );
+                if emitted.insert(key) {
+                    emit_near_duplicate(self.id(), left, right, similarity, threshold, violations);
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+struct FunctionOccurrence<'a> {
+    file: &'a FileAnalysis,
+    symbol: &'a SymbolAnalysis,
+}
+
+fn collect_function_occurrences<'a>(
+    context: &'a QualityContext,
+    check_id: &str,
+) -> Vec<FunctionOccurrence<'a>> {
+    context
+        .files
+        .iter()
+        .filter(|file| {
+            is_code_like_path(&file.path)
+                && context.config.check_enabled_for_path(check_id, &file.path)
+        })
+        .flat_map(|file| {
+            file.symbols
+                .iter()
+                .map(move |symbol| FunctionOccurrence { file, symbol })
+        })
+        .filter(|occurrence| {
+            occurrence.symbol.kind == "function" && occurrence.symbol.tokens.len() >= 12
+        })
+        .collect()
+}
+
+fn emit_near_duplicate(
+    check_id: &str,
+    left: &FunctionOccurrence<'_>,
+    right: &FunctionOccurrence<'_>,
+    similarity: f64,
+    threshold: f64,
+    violations: &mut Vec<QualityViolation>,
+) {
+    violations.push(violation(
+        check_id,
+        &left.file.path,
+        Some(left.symbol.start_line),
+        format!(
+            "{} {} is {:.0}% similar to {} {} in {}.",
+            left.symbol.kind,
+            left.symbol.name,
+            similarity * 100.0,
+            right.symbol.kind,
+            right.symbol.name,
+            right.file.path
+        ),
+        Some(similarity),
+        Some(threshold),
+        vec![right.file.path.clone()],
+    ));
+}
+
+fn same_symbol(left: &FunctionOccurrence<'_>, right: &FunctionOccurrence<'_>) -> bool {
+    left.file.path == right.file.path && left.symbol.start_line == right.symbol.start_line
+}
+
+fn duplicate_threshold(context: &QualityContext, left: &FileAnalysis, right: &FileAnalysis) -> f64 {
+    context
+        .limits_for(&left.path)
+        .near_duplicate_similarity
+        .max(context.limits_for(&right.path).near_duplicate_similarity)
+}
+
+fn symbols_have_parent_child_relationship(left: &SymbolAnalysis, right: &SymbolAnalysis) -> bool {
+    (left.start_line < right.start_line && left.end_line >= right.end_line)
+        || (right.start_line < left.start_line && right.end_line >= left.end_line)
+}
+
+fn jaccard(left: &HashSet<String>, right: &HashSet<String>) -> f64 {
+    let intersection = left.intersection(right).count();
+    let union = left.union(right).count();
+    if union == 0 {
+        0.0
+    } else {
+        intersection as f64 / union as f64
+    }
+}