@lamentis/naome 1.1.2 → 1.2.1

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

@@ -0,0 +1,107 @@
+use super::model::{RepositoryStructureConfig, StructureLimits};
+
+pub fn default_structure_config() -> RepositoryStructureConfig {
+    RepositoryStructureConfig {
+        schema: "naome.repository-structure.v1".to_string(),
+        version: 1,
+        status: "ready".to_string(),
+        enabled_adapters: Vec::new(),
+        source_roots: string_list(DEFAULT_SOURCE_ROOTS),
+        test_roots: string_list(DEFAULT_TEST_ROOTS),
+        docs_roots: string_list(DEFAULT_DOCS_ROOTS),
+        generated_roots: string_list(DEFAULT_GENERATED_ROOTS),
+        artifact_roots: string_list(DEFAULT_ARTIFACT_ROOTS),
+        module_roots: string_list(DEFAULT_MODULE_ROOTS),
+        allowed_root_files: string_list(DEFAULT_ALLOWED_ROOT_FILES),
+        directory_role_rules: Vec::new(),
+        layer_rules: Vec::new(),
+        ignored_paths: string_list(DEFAULT_IGNORED_PATHS),
+        disabled_checks: Vec::new(),
+        changed_code_policy: default_changed_policy(),
+        debt_policy: default_debt_policy(),
+        limits: StructureLimits::default(),
+    }
+}
+
+pub fn default_changed_policy() -> String {
+    "block".to_string()
+}
+
+pub fn default_debt_policy() -> String {
+    "report".to_string()
+}
+
+const DEFAULT_SOURCE_ROOTS: &[&str] = &[
+    "src/**",
+    "app/**",
+    "apps/*/src/**",
+    "packages/*/src/**",
+    "crates/*/src/**",
+    "**/src/**",
+    "lib/**",
+];
+const DEFAULT_TEST_ROOTS: &[&str] = &[
+    "test/**",
+    "tests/**",
+    "__tests__/**",
+    "packages/*/test/**",
+    "packages/*/tests/**",
+    "crates/*/tests/**",
+    "**/tests/**",
+    "scripts/*.test.js",
+];
+const DEFAULT_DOCS_ROOTS: &[&str] = &["docs/**", "doc/**"];
+const DEFAULT_GENERATED_ROOTS: &[&str] = &[
+    "**/generated/**",
+    "**/__generated__/**",
+    "**/codegen/**",
+    "**/*.generated.*",
+];
+const DEFAULT_ARTIFACT_ROOTS: &[&str] = &[
+    "dist/**",
+    "build/**",
+    "coverage/**",
+    ".next/**",
+    "target/**",
+    "**/dist/**",
+    "**/build/**",
+];
+const DEFAULT_MODULE_ROOTS: &[&str] = &[
+    "src/**",
+    "app/**",
+    "packages/*/src/**",
+    "crates/*/src/**",
+    "**/src/**",
+];
+const DEFAULT_ALLOWED_ROOT_FILES: &[&str] = &[
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "AGENTS.md",
+    "package.json",
+    "Cargo.toml",
+    "pyproject.toml",
+    "go.mod",
+    "go.sum",
+    "Makefile",
+    ".gitignore",
+    ".naomeignore",
+];
+const DEFAULT_IGNORED_PATHS: &[&str] = &[
+    ".git/**",
+    "node_modules/**",
+    "vendor/**",
+    "target/**",
+    "**/target/**",
+    "dist/**",
+    "build/**",
+    "coverage/**",
+    ".next/**",
+];
+
+fn string_list(values: &[&str]) -> Vec<String> {
+    values.iter().map(|value| (*value).to_string()).collect()
+}

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

@@ -0,0 +1,77 @@
+mod adapters;
+mod checks;
+mod classify;
+mod config;
+mod defaults;
+mod model;
+
+use std::collections::HashSet;
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::scanner::QualityContext;
+use super::types::{QualityMode, QualityViolation};
+use checks::run_structure_checks;
+use classify::build_structure_model;
+use config::read_structure_config;
+pub use config::{structure_config_relative_path, write_default_structure_config_if_missing};
+pub use model::{RepositoryStructureConfig, StructurePathExplanation};
+
+pub fn run_repository_structure_checks(
+    root: &Path,
+    context: &QualityContext,
+    baseline_fingerprints: &HashSet<String>,
+) -> Result<Vec<QualityViolation>, NaomeError> {
+    let model = structure_model(root, context, baseline_fingerprints)?;
+    let mut violations = run_structure_checks(&model, context.mode);
+    violations.retain(|violation| {
+        violation.check_id != "test-source-pairing"
+            || context
+                .files
+                .iter()
+                .find(|file| file.path == violation.path)
+                .is_some_and(|file| !file.symbols.is_empty())
+    });
+    if context.mode == QualityMode::Report {
+        for violation in &mut violations {
+            violation.baseline = baseline_fingerprints.contains(&violation.fingerprint);
+        }
+    }
+    Ok(violations)
+}
+
+pub fn explain_repository_structure(
+    root: &Path,
+    path: impl AsRef<str>,
+) -> Result<StructurePathExplanation, NaomeError> {
+    let repo_paths = super::scanner::collect_repo_paths(root)?;
+    let changed_paths = crate::git::changed_paths(root)?;
+    let config = read_structure_config(root, &repo_paths)?;
+    let model = build_structure_model(config, &repo_paths, &changed_paths, &HashSet::new());
+    let normalized = path.as_ref().replace('\\', "/");
+    model
+        .paths
+        .into_iter()
+        .find(|entry| entry.explanation.path == normalized)
+        .map(|entry| entry.explanation)
+        .ok_or_else(|| {
+            NaomeError::new(format!(
+                "{normalized} is not visible to structure analysis."
+            ))
+        })
+}
+
+fn structure_model(
+    root: &Path,
+    context: &QualityContext,
+    baseline_fingerprints: &HashSet<String>,
+) -> Result<model::RepositoryStructureModel, NaomeError> {
+    let config = read_structure_config(root, &context.repo_paths)?;
+    Ok(build_structure_model(
+        config,
+        &context.repo_paths,
+        &context.changed_paths,
+        baseline_fingerprints,
+    ))
+}

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

@@ -0,0 +1,124 @@
+use std::collections::BTreeSet;
+
+use serde::{Deserialize, Serialize};
+
+use super::defaults::{default_changed_policy, default_debt_policy, default_structure_config};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StructureLimits {
+    pub max_directory_files: usize,
+    pub max_path_depth: usize,
+    pub max_directory_roles: usize,
+    pub max_dumping_ground_files: usize,
+}
+
+impl Default for StructureLimits {
+    fn default() -> Self {
+        Self {
+            max_directory_files: 40,
+            max_path_depth: 10,
+            max_directory_roles: 2,
+            max_dumping_ground_files: 12,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DirectoryRoleRule {
+    pub id: String,
+    pub paths: Vec<String>,
+    #[serde(default)]
+    pub allowed_roles: Vec<String>,
+    #[serde(default)]
+    pub max_roles: Option<usize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LayerRule {
+    pub id: String,
+    pub paths: Vec<String>,
+    pub layer: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryStructureConfig {
+    pub schema: String,
+    pub version: u32,
+    pub status: String,
+    #[serde(default)]
+    pub enabled_adapters: Vec<String>,
+    #[serde(default)]
+    pub source_roots: Vec<String>,
+    #[serde(default)]
+    pub test_roots: Vec<String>,
+    #[serde(default)]
+    pub docs_roots: Vec<String>,
+    #[serde(default)]
+    pub generated_roots: Vec<String>,
+    #[serde(default)]
+    pub artifact_roots: Vec<String>,
+    #[serde(default)]
+    pub module_roots: Vec<String>,
+    #[serde(default)]
+    pub allowed_root_files: Vec<String>,
+    #[serde(default)]
+    pub directory_role_rules: Vec<DirectoryRoleRule>,
+    #[serde(default)]
+    pub layer_rules: Vec<LayerRule>,
+    #[serde(default)]
+    pub ignored_paths: Vec<String>,
+    #[serde(default)]
+    pub disabled_checks: Vec<String>,
+    #[serde(default = "default_changed_policy")]
+    pub changed_code_policy: String,
+    #[serde(default = "default_debt_policy")]
+    pub debt_policy: String,
+    #[serde(default)]
+    pub limits: StructureLimits,
+}
+
+impl Default for RepositoryStructureConfig {
+    fn default() -> Self {
+        default_structure_config()
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StructurePathExplanation {
+    pub path: String,
+    pub role: String,
+    pub module: Option<String>,
+    pub layer: String,
+    pub language: Option<String>,
+    pub generated: bool,
+    pub debt: bool,
+    pub changed: bool,
+    pub directory: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct StructurePath {
+    pub explanation: StructurePathExplanation,
+    pub segments: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct StructureDirectory {
+    pub path: String,
+    pub roles: BTreeSet<String>,
+    pub modules: BTreeSet<String>,
+    pub file_count: usize,
+    pub direct_changed_paths: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct RepositoryStructureModel {
+    pub config: RepositoryStructureConfig,
+    pub paths: Vec<StructurePath>,
+    pub directories: Vec<StructureDirectory>,
+}

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

@@ -0,0 +1,292 @@
+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 structure_config_written: bool,
+    pub baseline_written: bool,
+    pub baseline_violations: usize,
+    pub config_path: String,
+    pub structure_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-structure.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()
+}