@lamentis/naome 1.3.14 → 1.3.16

package/Cargo.lock

@@ -76,7 +76,7 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "naome-cli"
-version = "1.3.14"
+version = "1.3.16"
 dependencies = [
  "naome-core",
  "serde_json",
@@ -84,7 +84,7 @@ dependencies = [
 
 [[package]]
 name = "naome-core"
-version = "1.3.14"
+version = "1.3.16"
 dependencies = [
  "serde",
  "serde_json",

package/crates/naome-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-cli"
-version = "1.3.14"
+version = "1.3.16"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

package/crates/naome-cli/src/architecture_commands.rs

@@ -2,9 +2,9 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 use naome_core::{
-    default_architecture_config_text, format_architecture_explain, format_architecture_scan,
-    format_architecture_validation, scan_architecture, validate_architecture,
-    ArchitectureScanOptions, ARCHITECTURE_RULE_IDS,
+    config_findings_for, default_architecture_config_text, format_architecture_explain,
+    format_architecture_scan, format_architecture_validation, scan_architecture,
+    validate_architecture, ArchitectureScanOptions, ARCHITECTURE_RULE_IDS,
 };
 
 use crate::cli_args::{has_flag, option_value};
@@ -53,7 +53,8 @@ fn run_arch_explain(root: &Path, args: &[String]) -> Result<(), Box<dyn std::err
                 "layers": scan.config.layers.keys().collect::<Vec<_>>(),
                 "contexts": scan.config.contexts.keys().collect::<Vec<_>>(),
                 "rules": ARCHITECTURE_RULE_IDS,
-                "extractors": ["path", "typescript", "javascript", "rust", "python", "go", "swift"]
+                "extractors": ["path", "typescript", "javascript", "rust", "python", "go", "swift"],
+                "configFindings": config_findings_for(&scan)
             }))?
         );
     } else {

package/crates/naome-cli/src/quality_commands.rs

@@ -1,10 +1,10 @@
 use std::path::Path;
 
 use naome_core::{
-    check_repository_quality, check_repository_quality_paths, check_semantic_legacy, check_semantic_legacy_paths,
-    clear_quality_cache, explain_repository_structure, init_repository_quality_with_mode,
-    plan_quality_cleanup, quality_cache_status, route_quality_cleanup, semantic_route_for_finding,
-    QualityInitMode, QualityMode,
+    check_repository_quality, check_repository_quality_paths, check_semantic_legacy,
+    check_semantic_legacy_paths, clear_quality_cache, explain_repository_structure,
+    init_repository_quality_with_mode, plan_quality_cleanup, quality_cache_status,
+    route_quality_cleanup, semantic_route_for_finding, QualityInitMode, QualityMode,
 };
 
 use crate::cli_args::option_value;

package/crates/naome-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-core"
-version = "1.3.14"
+version = "1.3.16"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

package/crates/naome-core/src/architecture/config/parser/sections.rs

@@ -5,7 +5,7 @@ use super::ConfigParser;
 use crate::architecture::config::{
     ContextConfig, ExternalDependencyPolicy, IgnoreRule, LayerConfig, RuleConfig,
 };
-use crate::architecture::output::Severity;
+use crate::architecture::model::Severity;
 
 pub(super) fn parse_layers(parser: &mut ConfigParser<'_>) -> Result<(), NaomeError> {
     while let Some((_, line)) = parser.peek_line() {

package/crates/naome-core/src/architecture/config.rs

@@ -4,7 +4,7 @@ use std::path::Path;
 
 use crate::models::NaomeError;
 
-use super::output::Severity;
+use super::model::Severity;
 
 mod parser;
 

package/crates/naome-core/src/architecture/model.rs

@@ -38,6 +38,25 @@ pub struct SourceRange {
     pub end_column: usize,
 }
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum Severity {
+    Error,
+    Warning,
+    Info,
+}
+
+impl Severity {
+    pub fn parse(value: &str) -> Option<Self> {
+        match value {
+            "error" => Some(Self::Error),
+            "warning" | "warn" => Some(Self::Warning),
+            "info" => Some(Self::Info),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ArchitectureMetadata {
     pub path: Option<String>,

package/crates/naome-core/src/architecture/output.rs

@@ -1,16 +1,8 @@
 use serde::{Deserialize, Serialize};
 
-use super::model::SourceRange;
+use super::model::{Severity, SourceRange};
 use super::scan::ArchitectureScanReport;
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum Severity {
-    Error,
-    Warning,
-    Info,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct ViolationSummary {
@@ -42,6 +34,17 @@ pub struct ArchitectureAgentFeedback {
     pub must_not_do: Vec<String>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ArchitectureConfigFinding {
+    pub id: String,
+    pub severity: String,
+    pub subject: String,
+    pub message: String,
+    pub suggestion: String,
+    pub agent_instruction: String,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ArchitectureValidation {
@@ -56,6 +59,7 @@ pub struct ArchitectureValidation {
     pub changed_only_degraded_to_full_scan: bool,
     pub changed_only_mode: String,
     pub changed_only_degradation_reason: Option<String>,
+    pub config_findings: Vec<ArchitectureConfigFinding>,
     pub violations: Vec<ArchitectureViolation>,
     #[serde(rename = "agent_feedback")]
     pub agent_feedback: Vec<ArchitectureAgentFeedback>,
@@ -74,17 +78,6 @@ pub const ARCHITECTURE_RULE_IDS: &[&str] = &[
     "arch.external_dependency_policy",
 ];
 
-impl Severity {
-    pub fn parse(value: &str) -> Option<Self> {
-        match value {
-            "error" => Some(Self::Error),
-            "warning" | "warn" => Some(Self::Warning),
-            "info" => Some(Self::Info),
-            _ => None,
-        }
-    }
-}
-
 pub fn architecture_agent_feedback(
     violations: &[ArchitectureViolation],
 ) -> Vec<ArchitectureAgentFeedback> {
@@ -102,6 +95,131 @@ pub fn architecture_agent_feedback(
         .collect()
 }
 
+pub fn config_findings_for(scan: &ArchitectureScanReport) -> Vec<ArchitectureConfigFinding> {
+    let mut findings = Vec::new();
+    findings.extend(broad_layer_findings(scan));
+    findings.extend(catch_all_context_findings(scan));
+    findings.sort_by(|left, right| {
+        (left.id.as_str(), left.subject.as_str()).cmp(&(right.id.as_str(), right.subject.as_str()))
+    });
+    findings.dedup_by(|left, right| left.id == right.id && left.subject == right.subject);
+    findings
+}
+
+fn broad_layer_findings(scan: &ArchitectureScanReport) -> Vec<ArchitectureConfigFinding> {
+    let mut findings = Vec::new();
+    for (layer_name, layer) in &scan.config.layers {
+        let Some(broad_pattern) = layer
+            .paths
+            .iter()
+            .find(|pattern| is_broad_source_pattern(pattern))
+        else {
+            continue;
+        };
+        let overlapping_layers = scan
+            .config
+            .layers
+            .iter()
+            .filter(|(other_name, other_layer)| {
+                other_name.as_str() != layer_name.as_str()
+                    && other_layer
+                        .paths
+                        .iter()
+                        .any(|pattern| pattern_is_narrower_than(pattern, broad_pattern))
+            })
+            .map(|(name, _)| name.clone())
+            .collect::<Vec<_>>();
+        if overlapping_layers.is_empty() {
+            continue;
+        }
+        findings.push(ArchitectureConfigFinding {
+            id: "arch.config.broad_layer_overlap".to_string(),
+            severity: "warning".to_string(),
+            subject: format!("layer:{layer_name}"),
+            message: format!(
+                "Layer {layer_name} uses broad path pattern {broad_pattern} while narrower layers also match inside it: {}.",
+                overlapping_layers.join(", ")
+            ),
+            suggestion: format!(
+                "Keep broad compatibility layers intentional and make allowed_dependencies explicit, or narrow {layer_name} so files do not inherit multiple architectural meanings by default."
+            ),
+            agent_instruction: format!(
+                "Do not rely on broad layer {layer_name} to hide architecture boundaries; prefer narrower layer paths or explicit allow rules."
+            ),
+        });
+    }
+    findings
+}
+
+fn catch_all_context_findings(scan: &ArchitectureScanReport) -> Vec<ArchitectureConfigFinding> {
+    if scan.config.contexts.len() <= 1 {
+        return Vec::new();
+    }
+    scan.config
+        .contexts
+        .iter()
+        .filter(|(_, context)| {
+            context
+                .paths
+                .iter()
+                .any(|pattern| is_broad_source_pattern(pattern))
+        })
+        .filter_map(|(context_name, context)| {
+            let broad_pattern = context
+                .paths
+                .iter()
+                .find(|pattern| is_broad_source_pattern(pattern))?;
+            let specific_contexts = scan
+                .config
+                .contexts
+                .iter()
+                .filter(|(other_name, other_context)| {
+                    other_name.as_str() != context_name.as_str()
+                        && other_context
+                            .paths
+                            .iter()
+                            .any(|pattern| pattern_is_narrower_than(pattern, broad_pattern))
+                })
+                .map(|(name, _)| name.clone())
+                .collect::<Vec<_>>();
+            if specific_contexts.is_empty() {
+                return None;
+            }
+            Some(ArchitectureConfigFinding {
+                id: "arch.config.catch_all_context_with_specific_contexts".to_string(),
+                severity: "warning".to_string(),
+                subject: format!("context:{context_name}"),
+                message: format!(
+                    "Context {context_name} uses catch-all path pattern {broad_pattern} alongside narrower contexts: {}.",
+                    specific_contexts.join(", ")
+                ),
+                suggestion: format!(
+                    "Treat {context_name} as a compatibility bucket only. Move shared code into explicit public APIs or replace the catch-all context with narrower bounded contexts."
+                ),
+                agent_instruction: format!(
+                    "Do not classify cross-context imports as safe only because {context_name} also matches them; model the real bounded context or public API."
+                ),
+            })
+        })
+        .collect()
+}
+
+fn is_broad_source_pattern(pattern: &str) -> bool {
+    matches!(pattern, "**" | "**/*" | "src/**" | "packages/**/src/**")
+}
+
+fn pattern_is_narrower_than(pattern: &str, broad_pattern: &str) -> bool {
+    if pattern == broad_pattern {
+        return false;
+    }
+    match broad_pattern {
+        "**" | "**/*" => true,
+        "src/**" => pattern.starts_with("src/") && pattern != "src/**",
+        "packages/**/src/**" => pattern.starts_with("packages/") && pattern.contains("/src/"),
+        _ => false,
+    }
+}
+
 pub fn summary_for(violations: &[ArchitectureViolation]) -> ViolationSummary {
     ViolationSummary {
         errors: violations
@@ -147,6 +265,21 @@ pub fn format_architecture_validation(report: &ArchitectureValidation) -> String
         lines.push("changed-only requested: using incremental architecture cache".to_string());
     }
 
+    if !report.config_findings.is_empty() {
+        lines.push(format!(
+            "configuration findings: {}",
+            report.config_findings.len()
+        ));
+    }
+
+    for finding in report.config_findings.iter().take(5) {
+        lines.push(format!(
+            "- Config {} {} {}",
+            finding.severity, finding.subject, finding.message
+        ));
+        lines.push(format!("  fix: {}", finding.suggestion));
+    }
+
     for violation in report.violations.iter().take(10) {
         lines.push(format!(
             "- {:?} {} {}",
@@ -183,6 +316,7 @@ pub fn format_architecture_scan(report: &ArchitectureScanReport) -> String {
 }
 
 pub fn format_architecture_explain(scan: &ArchitectureScanReport) -> String {
+    let findings = config_findings_for(scan);
     let layers = scan
         .config
         .layers
@@ -197,12 +331,22 @@ pub fn format_architecture_explain(scan: &ArchitectureScanReport) -> String {
         .cloned()
         .collect::<Vec<_>>()
         .join(", ");
-    format!(
+    let mut output = format!(
         "NAOME Architecture Fitness\nrules: {}\nlayers: {}\ncontexts: {}\npath extractor: enabled for every repository\nimport extractors: typescript, javascript, rust, python, go, swift\n",
         ARCHITECTURE_RULE_IDS.join(", "),
         empty_label(&layers),
         empty_label(&contexts)
-    )
+    );
+    if !findings.is_empty() {
+        output.push_str(&format!("configuration findings: {}\n", findings.len()));
+        for finding in findings.iter().take(5) {
+            output.push_str(&format!(
+                "- {} {}: {}\n",
+                finding.severity, finding.subject, finding.message
+            ));
+        }
+    }
+    output
 }
 
 fn empty_label(value: &str) -> &str {

package/crates/naome-core/src/architecture/rules/budgets.rs

@@ -1,4 +1,5 @@
-use crate::architecture::output::{ArchitectureViolation, Severity};
+use crate::architecture::model::Severity;
+use crate::architecture::output::ArchitectureViolation;
 use crate::architecture::scan::{ArchitectureScanReport, FileFact, ImportTarget};
 
 pub(super) fn validate_file_size_budget(

package/crates/naome-core/src/architecture/rules.rs

@@ -1,8 +1,9 @@
 use crate::paths;
 
+use super::model::Severity;
 use super::output::{
-    architecture_agent_feedback, summary_for, ArchitectureValidation, ArchitectureViolation,
-    Severity,
+    architecture_agent_feedback, config_findings_for, summary_for, ArchitectureValidation,
+    ArchitectureViolation,
 };
 use super::scan::ArchitectureScanReport;
 use crate::architecture::model::ArchitectureEdgeKind;
@@ -44,6 +45,7 @@ pub fn validate_scan(scan: ArchitectureScanReport) -> ArchitectureValidation {
     let summary = summary_for(&violations);
     let status = if summary.errors > 0 { "fail" } else { "pass" }.to_string();
     let agent_feedback = architecture_agent_feedback(&violations);
+    let config_findings = config_findings_for(&scan);
 
     ArchitectureValidation {
         schema: "naome.arch.validation.v1".to_string(),
@@ -57,6 +59,7 @@ pub fn validate_scan(scan: ArchitectureScanReport) -> ArchitectureValidation {
         changed_only_degraded_to_full_scan: scan.changed_only_degraded_to_full_scan,
         changed_only_mode: scan.changed_only_mode,
         changed_only_degradation_reason: scan.changed_only_degradation_reason,
+        config_findings,
         violations,
         agent_feedback,
     }

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

@@ -13,12 +13,12 @@ pub use config::{
 };
 pub use model::{
     ArchitectureEdge, ArchitectureEdgeKind, ArchitectureGraph, ArchitectureMetadata,
-    ArchitectureNode, ArchitectureNodeKind, SourceRange,
+    ArchitectureNode, ArchitectureNodeKind, Severity, SourceRange,
 };
 pub use output::{
-    format_architecture_explain, format_architecture_scan, format_architecture_validation,
-    ArchitectureAgentFeedback, ArchitectureValidation, ArchitectureViolation, Severity,
-    ViolationSummary, ARCHITECTURE_RULE_IDS,
+    config_findings_for, format_architecture_explain, format_architecture_scan,
+    format_architecture_validation, ArchitectureAgentFeedback, ArchitectureConfigFinding,
+    ArchitectureValidation, ArchitectureViolation, ViolationSummary, ARCHITECTURE_RULE_IDS,
 };
 pub use scan::{scan_architecture, ArchitectureScanOptions, ArchitectureScanReport};
 

package/crates/naome-core/src/intent/legacy.rs

@@ -4,8 +4,8 @@ use crate::models::Decision;
 
 use super::classifier::{has_candidate, winning_intent};
 use super::legacy_response::response_policy;
+use super::model::ResolvedIntent;
 use super::model::{CanonicalIntent, IntentKind};
-use super::resolver::ResolvedIntent;
 
 #[derive(Debug, Clone, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]

package/crates/naome-core/src/intent/model.rs

@@ -75,3 +75,30 @@ pub(crate) struct CanonicalIntent {
     pub has_workflow_conflict: bool,
     pub validation_errors: Vec<String>,
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum CompletedTaskReadiness {
+    Valid,
+    ValidAfterHarnessRefresh,
+    ValidWithUnrelatedDirty,
+    Invalid,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum DirtyDiffReadiness {
+    Unclassified,
+    HarnessRefreshOnly,
+    HarnessRefreshWithUnrelatedDirty,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct ResolvedIntent {
+    pub prompt_intent: IntentKind,
+    pub certainty: String,
+    pub policy_action: String,
+    pub allowed: bool,
+    pub summary: String,
+    pub next_action: String,
+    pub reason_codes: Vec<String>,
+    pub risk_codes: Vec<String>,
+}

package/crates/naome-core/src/intent/resolver.rs

@@ -1,37 +1,12 @@
 use crate::models::Decision;
 
 use super::classifier::winning_intent;
-use super::model::{CanonicalIntent, IntentKind};
+use super::model::{
+    CanonicalIntent, CompletedTaskReadiness, DirtyDiffReadiness, IntentKind, ResolvedIntent,
+};
 use super::resolver_policy::state_policy;
 use super::resolver_shared::{ambiguous_conflict, ambiguous_empty, unsafe_policy, Policy};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum CompletedTaskReadiness {
-    Valid,
-    ValidAfterHarnessRefresh,
-    ValidWithUnrelatedDirty,
-    Invalid,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum DirtyDiffReadiness {
-    Unclassified,
-    HarnessRefreshOnly,
-    HarnessRefreshWithUnrelatedDirty,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct ResolvedIntent {
-    pub prompt_intent: IntentKind,
-    pub certainty: String,
-    pub policy_action: String,
-    pub allowed: bool,
-    pub summary: String,
-    pub next_action: String,
-    pub reason_codes: Vec<String>,
-    pub risk_codes: Vec<String>,
-}
-
 pub(crate) fn resolve_intent(
     decision: &Decision,
     canonical: &CanonicalIntent,

package/crates/naome-core/src/intent/resolver_baseline.rs

@@ -1,5 +1,4 @@
-use super::model::IntentKind;
-use super::resolver::DirtyDiffReadiness;
+use super::model::{DirtyDiffReadiness, IntentKind};
 use super::resolver_catalog::{
     POLICY_BASELINE_BLOCK, POLICY_BASELINE_CANCEL, POLICY_BASELINE_COMMIT_UPGRADE,
     POLICY_BASELINE_NEW_REFRESH, POLICY_BASELINE_NEW_UPGRADE, POLICY_BASELINE_NO_COMMIT,

package/crates/naome-core/src/intent/resolver_policy.rs

@@ -1,7 +1,6 @@
 use crate::models::Decision;
 
-use super::model::IntentKind;
-use super::resolver::{CompletedTaskReadiness, DirtyDiffReadiness};
+use super::model::{CompletedTaskReadiness, DirtyDiffReadiness, IntentKind};
 use super::resolver_active::active_policy;
 use super::resolver_baseline::{baseline_policy, dirty_policy};
 use super::resolver_catalog::{

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

@@ -24,7 +24,8 @@ use crate::task_state::{
 use classifier::canonical_intent;
 pub(crate) use envelope::prompt_envelope_json;
 pub use legacy::{format_intent, IntentDecision, PromptEvidence};
-use resolver::{resolve_intent, CompletedTaskReadiness, DirtyDiffReadiness};
+use model::{CompletedTaskReadiness, DirtyDiffReadiness};
+use resolver::resolve_intent;
 
 pub fn evaluate_intent(
     root: &Path,

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

@@ -21,13 +21,13 @@ mod verification_contract_policy;
 mod workflow;
 
 pub use architecture::{
-    default_architecture_config_text, format_architecture_explain, format_architecture_scan,
-    format_architecture_validation, scan_architecture, validate_architecture,
-    ArchitectureAgentFeedback, ArchitectureConfig, ArchitectureEdge, ArchitectureEdgeKind,
-    ArchitectureGraph, ArchitectureMetadata, ArchitectureNode, ArchitectureNodeKind,
-    ArchitectureScanOptions, ArchitectureScanReport, ArchitectureValidation, ArchitectureViolation,
-    ContextConfig, LayerConfig, RuleConfig, Severity, SourceRange, ViolationSummary,
-    ARCHITECTURE_RULE_IDS,
+    config_findings_for, default_architecture_config_text, format_architecture_explain,
+    format_architecture_scan, format_architecture_validation, scan_architecture,
+    validate_architecture, ArchitectureAgentFeedback, ArchitectureConfig,
+    ArchitectureConfigFinding, ArchitectureEdge, ArchitectureEdgeKind, ArchitectureGraph,
+    ArchitectureMetadata, ArchitectureNode, ArchitectureNodeKind, ArchitectureScanOptions,
+    ArchitectureScanReport, ArchitectureValidation, ArchitectureViolation, ContextConfig,
+    LayerConfig, RuleConfig, Severity, SourceRange, ViolationSummary, ARCHITECTURE_RULE_IDS,
 };
 pub use context::{
     select_context_for_changed_paths, select_context_for_prompt, ContextBudgetLedger,

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

@@ -1,4 +1,6 @@
-use super::adapters::{path_rule, test_file_limits};
+use super::adapter_support::{
+    quality_path_rule as path_rule, quality_test_file_limits as test_file_limits,
+};
 use super::types::{QualityLimitOverrides, QualityPathRule};
 
 pub(super) fn swift_path_rules() -> Vec<QualityPathRule> {

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

@@ -2,6 +2,8 @@ use std::collections::HashSet;
 
 use crate::models::NaomeError;
 
+use super::types::{QualityLimitOverrides, QualityPathRule};
+
 pub(crate) struct RepoSignals<'a> {
     paths: &'a [String],
 }
@@ -98,6 +100,36 @@ pub(crate) fn extend_unique(target: &mut Vec<String>, values: &[&str]) {
     }
 }
 
+pub(crate) fn quality_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()
+    }
+}
+
+pub(crate) fn quality_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()
+}
+
 pub(crate) fn detects_rust_project(signals: &RepoSignals<'_>) -> bool {
     signals.has_manifest("Cargo.toml") || signals.has_extension(&[".rs"])
 }

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

@@ -5,10 +5,10 @@ use super::adapter_support::{
     detected_ids, detects_generated_ios_project, detects_ios_app_structure_project,
     detects_ios_resources_project, detects_javascript_typescript_project, detects_rust_project,
     detects_swift_package_project, detects_swift_project, detects_swiftui_project,
-    detects_xcode_project, detects_xctest_project, extend_unique, find_adapter_by_id, validate_ids,
-    AdapterDescriptor, RepoSignals,
+    detects_xcode_project, detects_xctest_project, extend_unique, find_adapter_by_id,
+    quality_path_rule, quality_test_file_limits, validate_ids, AdapterDescriptor, RepoSignals,
 };
-use super::types::{QualityLimitOverrides, QualityPathRule, RepositoryQualityConfig};
+use super::types::{QualityPathRule, RepositoryQualityConfig};
 
 const CONFIG_PATH: &str = ".naome/repository-quality.json";
 
@@ -163,32 +163,15 @@ fn javascript_typescript_test_paths() -> Vec<String> {
     paths
 }
 
-pub(super) 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 test_file_limits(max_top_level_symbols: usize) -> super::types::QualityLimitOverrides {
+    quality_test_file_limits(max_top_level_symbols)
 }
 
-pub(super) fn path_rule(
+fn path_rule(
     id: &str,
     paths: &[&str],
-    limits: QualityLimitOverrides,
+    limits: super::types::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()
+    quality_path_rule(id, paths, limits, disabled_checks)
 }