@lamentis/naome 1.1.1 → 1.2.0

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

@@ -0,0 +1,367 @@
+mod repo_paths;
+
+use std::collections::{HashMap, HashSet};
+use std::fs;
+use std::path::Path;
+
+use sha2::{Digest, Sha256};
+
+use crate::{git, models::NaomeError, paths};
+use repo_paths::added_lines_by_path;
+pub(crate) use repo_paths::collect_repo_paths;
+
+use super::types::{
+    default_generated_paths, default_ignored_paths, QualityLimits, QualityMode,
+    RepositoryQualityConfig,
+};
+
+#[derive(Debug, Clone)]
+pub struct QualityContext {
+    pub mode: QualityMode,
+    pub config: RepositoryQualityConfig,
+    pub changed_paths: Vec<String>,
+    pub target_paths: HashSet<String>,
+    pub files: Vec<FileAnalysis>,
+}
+
+impl QualityContext {
+    pub fn scanned_paths(&self) -> Vec<String> {
+        self.files.iter().map(|file| file.path.clone()).collect()
+    }
+
+    pub fn applies_to(&self, path: &str) -> bool {
+        self.mode == QualityMode::Report || self.target_paths.contains(path)
+    }
+
+    pub fn check_applies_to(&self, check_id: &str, path: &str) -> bool {
+        self.applies_to(path) && self.config.check_enabled_for_path(check_id, path)
+    }
+
+    pub fn limits_for(&self, path: &str) -> QualityLimits {
+        self.config.limits_for_path(path)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FileAnalysis {
+    pub path: String,
+    pub line_count: usize,
+    pub added_lines: usize,
+    pub normalized_lines: Vec<NormalizedLine>,
+    pub symbols: Vec<SymbolAnalysis>,
+}
+
+#[derive(Debug, Clone)]
+pub struct NormalizedLine {
+    pub line_number: usize,
+    pub value: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct SymbolAnalysis {
+    pub kind: String,
+    pub name: String,
+    pub start_line: usize,
+    pub end_line: usize,
+    pub indent: usize,
+    pub tokens: HashSet<String>,
+}
+
+impl SymbolAnalysis {
+    pub fn line_count(&self) -> usize {
+        self.end_line.saturating_sub(self.start_line) + 1
+    }
+}
+
+pub fn scan_repository(
+    root: &Path,
+    mode: QualityMode,
+    config: RepositoryQualityConfig,
+) -> Result<QualityContext, NaomeError> {
+    let changed_paths = git::changed_paths(root)?;
+    let target_paths = changed_paths.iter().cloned().collect::<HashSet<_>>();
+    let scan_paths = match mode {
+        QualityMode::Changed => changed_paths.clone(),
+        QualityMode::Report => collect_repo_paths(root)?,
+    };
+    let added_lines = added_lines_by_path(root)?;
+    let ignore_patterns = ignore_patterns(root, &config);
+    let mut files = Vec::new();
+
+    for path in scan_paths {
+        if should_skip_path(&path, &ignore_patterns) {
+            continue;
+        }
+        if let Some(file) = analyze_repo_file(root, &path, &added_lines) {
+            files.push(file);
+        }
+    }
+
+    if mode == QualityMode::Changed {
+        let mut whole_repo_paths = collect_repo_paths(root)?;
+        whole_repo_paths.sort();
+        whole_repo_paths.dedup();
+        let scanned = files
+            .iter()
+            .map(|file| file.path.clone())
+            .collect::<HashSet<_>>();
+        for path in whole_repo_paths {
+            if scanned.contains(&path) || should_skip_path(&path, &ignore_patterns) {
+                continue;
+            }
+            if let Some(file) = analyze_repo_file(root, &path, &added_lines) {
+                files.push(file);
+            }
+        }
+    }
+
+    files.sort_by(|left, right| left.path.cmp(&right.path));
+    Ok(QualityContext {
+        mode,
+        config,
+        changed_paths,
+        target_paths,
+        files,
+    })
+}
+
+pub fn stable_fingerprint(parts: &[&str]) -> String {
+    let mut hasher = Sha256::new();
+    for part in parts {
+        hasher.update(part.as_bytes());
+        hasher.update(b"\0");
+    }
+    format!("sha256:{:x}", hasher.finalize())
+}
+
+fn analyze_repo_file(
+    root: &Path,
+    path: &str,
+    added_lines: &HashMap<String, usize>,
+) -> Option<FileAnalysis> {
+    let full_path = root.join(path);
+    if !full_path.is_file() || is_binary_extension(path) {
+        return None;
+    }
+    let content = fs::read_to_string(&full_path).ok()?;
+    Some(analyze_file(
+        path,
+        &content,
+        added_lines.get(path).copied().unwrap_or(0),
+    ))
+}
+
+fn analyze_file(path: &str, content: &str, added_lines: usize) -> FileAnalysis {
+    let lines = content.lines().collect::<Vec<_>>();
+    let normalized_lines = lines
+        .iter()
+        .enumerate()
+        .filter_map(|(index, line)| normalize_line(line).map(|value| (index + 1, value)))
+        .map(|(line_number, value)| NormalizedLine { line_number, value })
+        .collect::<Vec<_>>();
+    let symbols = detect_symbols(&lines);
+    FileAnalysis {
+        path: path.to_string(),
+        line_count: lines.len(),
+        added_lines,
+        normalized_lines,
+        symbols,
+    }
+}
+
+fn detect_symbols(lines: &[&str]) -> Vec<SymbolAnalysis> {
+    let mut starts = Vec::new();
+    for (index, line) in lines.iter().enumerate() {
+        let indent = indentation(line);
+        if let Some((kind, name)) = symbol_start(line.trim()) {
+            starts.push((index, indent, kind, name));
+        }
+    }
+
+    let mut symbols = Vec::new();
+    for (position, (start_index, indent, kind, name)) in starts.iter().enumerate() {
+        let end_index = starts
+            .iter()
+            .skip(position + 1)
+            .find(|(_, next_indent, _, _)| next_indent <= indent)
+            .map(|(next_index, _, _, _)| next_index.saturating_sub(1))
+            .unwrap_or_else(|| lines.len().saturating_sub(1));
+        let normalized_body = lines[*start_index..=end_index]
+            .iter()
+            .filter_map(|line| normalize_line(line))
+            .collect::<Vec<_>>();
+        let tokens = normalized_body
+            .iter()
+            .flat_map(|line| token_set(line))
+            .collect::<HashSet<_>>();
+        symbols.push(SymbolAnalysis {
+            kind: kind.clone(),
+            name: name.clone(),
+            start_line: start_index + 1,
+            end_line: end_index + 1,
+            indent: *indent,
+            tokens,
+        });
+    }
+    symbols
+}
+
+fn symbol_start(trimmed: &str) -> Option<(String, String)> {
+    let candidates = [
+        ("function", "function "),
+        ("function", "export function "),
+        ("function", "async function "),
+        ("function", "export async function "),
+        ("function", "def "),
+        ("function", "fn "),
+        ("function", "pub fn "),
+        ("function", "func "),
+        ("class", "class "),
+        ("struct", "struct "),
+        ("struct", "pub struct "),
+        ("enum", "enum "),
+        ("enum", "pub enum "),
+        ("impl", "impl "),
+    ];
+    for (kind, prefix) in candidates {
+        if let Some(rest) = trimmed.strip_prefix(prefix) {
+            return Some((kind.to_string(), symbol_name(rest)));
+        }
+    }
+    for prefix in ["const ", "let ", "export const ", "export let "] {
+        if let Some(rest) = trimmed.strip_prefix(prefix) {
+            if trimmed.contains("=>") || trimmed.contains("function") || trimmed.contains("React.")
+            {
+                return Some(("function".to_string(), symbol_name(rest)));
+            }
+        }
+    }
+    None
+}
+
+fn symbol_name(rest: &str) -> String {
+    rest.chars()
+        .take_while(|character| character.is_ascii_alphanumeric() || *character == '_')
+        .collect::<String>()
+        .trim_matches('_')
+        .to_string()
+}
+
+fn normalize_line(line: &str) -> Option<String> {
+    let trimmed = line.trim();
+    if trimmed.is_empty() || is_comment_only(trimmed) || is_generated_hash_mapping(trimmed) {
+        return None;
+    }
+
+    let mut normalized = String::new();
+    let mut in_string = false;
+    let mut quote = '\0';
+    let mut previous_space = false;
+    for character in trimmed.chars() {
+        if in_string {
+            if character == quote {
+                in_string = false;
+                normalized.push('S');
+                previous_space = false;
+            }
+            continue;
+        }
+        if character == '"' || character == '\'' || character == '`' {
+            in_string = true;
+            quote = character;
+            continue;
+        }
+        let next = if character.is_ascii_digit() {
+            '0'
+        } else if character.is_whitespace() {
+            ' '
+        } else {
+            character.to_ascii_lowercase()
+        };
+        if next == ' ' {
+            if !previous_space {
+                normalized.push(next);
+            }
+            previous_space = true;
+        } else {
+            normalized.push(next);
+            previous_space = false;
+        }
+    }
+    let value = normalized.trim().to_string();
+    (!value.is_empty()).then_some(value)
+}
+
+fn is_comment_only(trimmed: &str) -> bool {
+    trimmed.starts_with("//")
+        || trimmed.starts_with('#')
+        || trimmed.starts_with("/*")
+        || trimmed.starts_with('*')
+        || trimmed.starts_with("--")
+}
+
+fn is_generated_hash_mapping(trimmed: &str) -> bool {
+    let Some((key, value)) = trimmed.split_once(':') else {
+        return false;
+    };
+    key.trim_start().starts_with('"')
+        && value.trim_start().starts_with("\"sha256:")
+        && value.chars().filter(|character| *character == '"').count() >= 2
+}
+
+fn token_set(line: &str) -> Vec<String> {
+    line.split(|character: char| !character.is_ascii_alphanumeric() && character != '_')
+        .filter(|token| token.len() > 1)
+        .map(ToString::to_string)
+        .collect()
+}
+
+fn indentation(line: &str) -> usize {
+    line.chars()
+        .take_while(|character| character.is_whitespace())
+        .map(|character| if character == '\t' { 2 } else { 1 })
+        .sum()
+}
+
+fn ignore_patterns(root: &Path, config: &RepositoryQualityConfig) -> Vec<String> {
+    let mut patterns = Vec::new();
+    patterns.extend(read_naomeignore_patterns(root));
+    patterns.extend(default_ignored_paths());
+    patterns.extend(default_generated_paths());
+    patterns.extend(config.ignored_paths.clone());
+    patterns.extend(config.generated_paths.clone());
+    patterns
+}
+
+fn read_naomeignore_patterns(root: &Path) -> Vec<String> {
+    let Ok(content) = fs::read_to_string(root.join(".naomeignore")) else {
+        return Vec::new();
+    };
+    content
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty() && !line.starts_with('#') && !line.starts_with('!'))
+        .map(|pattern| {
+            let normalized = pattern.trim_start_matches("./").replace('\\', "/");
+            if normalized.ends_with('/') {
+                format!("{normalized}**")
+            } else {
+                normalized
+            }
+        })
+        .collect()
+}
+
+fn should_skip_path(path: &str, patterns: &[String]) -> bool {
+    paths::matches_any(path, patterns)
+}
+
+fn is_binary_extension(path: &str) -> bool {
+    let lower = path.to_ascii_lowercase();
+    [
+        ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz", ".tgz", ".wasm",
+        ".dylib", ".so", ".dll", ".exe", ".bin",
+    ]
+    .iter()
+    .any(|extension| lower.ends_with(extension))
+}

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

@@ -0,0 +1,289 @@
+use serde::{Deserialize, Serialize};
+
+use crate::paths;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum QualityMode {
+    Changed,
+    Report,
+}
+
+impl QualityMode {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Changed => "changed",
+            Self::Report => "report",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityLimits {
+    pub max_file_lines: usize,
+    pub max_new_file_lines: usize,
+    pub max_diff_added_lines: usize,
+    pub max_function_lines: usize,
+    pub max_top_level_symbols: usize,
+    pub duplicate_block_lines: usize,
+    pub near_duplicate_similarity: f64,
+}
+
+impl Default for QualityLimits {
+    fn default() -> Self {
+        Self {
+            max_file_lines: 450,
+            max_new_file_lines: 300,
+            max_diff_added_lines: 180,
+            max_function_lines: 100,
+            max_top_level_symbols: 30,
+            duplicate_block_lines: 10,
+            near_duplicate_similarity: 0.9,
+        }
+    }
+}
+
+impl QualityLimits {
+    pub fn with_overrides(&self, overrides: &QualityLimitOverrides) -> Self {
+        Self {
+            max_file_lines: overrides.max_file_lines.unwrap_or(self.max_file_lines),
+            max_new_file_lines: overrides
+                .max_new_file_lines
+                .unwrap_or(self.max_new_file_lines),
+            max_diff_added_lines: overrides
+                .max_diff_added_lines
+                .unwrap_or(self.max_diff_added_lines),
+            max_function_lines: overrides
+                .max_function_lines
+                .unwrap_or(self.max_function_lines),
+            max_top_level_symbols: overrides
+                .max_top_level_symbols
+                .unwrap_or(self.max_top_level_symbols),
+            duplicate_block_lines: overrides
+                .duplicate_block_lines
+                .unwrap_or(self.duplicate_block_lines),
+            near_duplicate_similarity: overrides
+                .near_duplicate_similarity
+                .unwrap_or(self.near_duplicate_similarity),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityLimitOverrides {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_file_lines: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_new_file_lines: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_diff_added_lines: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_function_lines: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_top_level_symbols: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub duplicate_block_lines: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub near_duplicate_similarity: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityPathRule {
+    pub id: String,
+    pub paths: Vec<String>,
+    #[serde(default, skip_serializing_if = "QualityLimitOverrides::is_empty")]
+    pub limits: QualityLimitOverrides,
+    #[serde(default)]
+    pub disabled_checks: Vec<String>,
+}
+
+impl QualityLimitOverrides {
+    pub fn is_empty(&self) -> bool {
+        self.max_file_lines.is_none()
+            && self.max_new_file_lines.is_none()
+            && self.max_diff_added_lines.is_none()
+            && self.max_function_lines.is_none()
+            && self.max_top_level_symbols.is_none()
+            && self.duplicate_block_lines.is_none()
+            && self.near_duplicate_similarity.is_none()
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryQualityConfig {
+    pub schema: String,
+    pub version: u32,
+    pub status: String,
+    pub limits: QualityLimits,
+    #[serde(default)]
+    pub enabled_adapters: Vec<String>,
+    #[serde(default)]
+    pub disabled_checks: Vec<String>,
+    #[serde(default)]
+    pub ignored_paths: Vec<String>,
+    #[serde(default)]
+    pub generated_paths: Vec<String>,
+    #[serde(default)]
+    pub path_rules: Vec<QualityPathRule>,
+}
+
+impl Default for RepositoryQualityConfig {
+    fn default() -> Self {
+        Self {
+            schema: "naome.repository-quality.v1".to_string(),
+            version: 1,
+            status: "ready".to_string(),
+            limits: QualityLimits::default(),
+            enabled_adapters: Vec::new(),
+            disabled_checks: Vec::new(),
+            ignored_paths: default_ignored_paths(),
+            generated_paths: default_generated_paths(),
+            path_rules: Vec::new(),
+        }
+    }
+}
+
+impl RepositoryQualityConfig {
+    pub fn limits_for_path(&self, path: &str) -> QualityLimits {
+        self.path_rules
+            .iter()
+            .filter(|rule| paths::matches_any(path, &rule.paths))
+            .fold(self.limits.clone(), |limits, rule| {
+                limits.with_overrides(&rule.limits)
+            })
+    }
+
+    pub fn check_enabled_for_path(&self, check_id: &str, path: &str) -> bool {
+        !self
+            .disabled_checks
+            .iter()
+            .any(|disabled| disabled == check_id)
+            && !self.path_rules.iter().any(|rule| {
+                paths::matches_any(path, &rule.paths)
+                    && rule
+                        .disabled_checks
+                        .iter()
+                        .any(|disabled| disabled == check_id)
+            })
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityReport {
+    pub schema: String,
+    pub mode: String,
+    pub ok: bool,
+    pub changed_paths: Vec<String>,
+    pub scanned_paths: Vec<String>,
+    pub summary: QualitySummary,
+    pub violations: Vec<QualityViolation>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualitySummary {
+    pub scanned_files: usize,
+    pub violation_count: usize,
+    pub baseline_violation_count: usize,
+    pub blocking_violation_count: usize,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityViolation {
+    pub check_id: String,
+    pub severity: String,
+    pub path: String,
+    pub line: Option<usize>,
+    pub message: String,
+    pub value: Option<f64>,
+    pub limit: Option<f64>,
+    pub fingerprint: String,
+    pub related_paths: Vec<String>,
+    pub baseline: bool,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityInitResult {
+    pub schema: String,
+    pub config_written: bool,
+    pub baseline_written: bool,
+    pub baseline_violations: usize,
+    pub config_path: String,
+    pub baseline_path: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityCleanupPlan {
+    pub schema: String,
+    pub tasks: Vec<QualityCleanupTask>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityCleanupTask {
+    pub path: String,
+    pub violation_count: usize,
+    pub check_ids: Vec<String>,
+    pub summary: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityCleanupRoute {
+    pub schema: String,
+    pub path: String,
+    pub violations: Vec<QualityViolation>,
+    pub related_paths: Vec<String>,
+    pub agent_instructions: String,
+    pub required_checks: Vec<String>,
+}
+
+pub fn default_ignored_paths() -> Vec<String> {
+    listed_paths(DEFAULT_IGNORED_PATHS)
+}
+
+pub fn default_generated_paths() -> Vec<String> {
+    listed_paths(DEFAULT_GENERATED_PATHS)
+}
+
+const DEFAULT_IGNORED_PATHS: &str = r#"
+.git/**
+.naome/archive/**
+.naome/task-state.json
+.naome/task-journal.jsonl
+.naome/repository-quality.json
+.naome/repository-quality-baseline.json
+node_modules/**
+.npm/**
+target/**
+**/target/**
+**/Cargo.lock
+package-lock.json
+pnpm-lock.yaml
+yarn.lock
+*.tgz
+*.lock
+"#;
+
+const DEFAULT_GENERATED_PATHS: &str = r#"
+**/*.min.js
+**/*.map
+**/dist/**
+**/build/**
+"#;
+
+fn listed_paths(paths: &str) -> Vec<String> {
+    paths
+        .lines()
+        .map(str::trim)
+        .filter(|path| !path.is_empty())
+        .map(ToString::to_string)
+        .collect()
+}