@lamentis/naome 1.2.0 → 1.3.0

package/crates/naome-core/tests/quality_performance.rs

@@ -0,0 +1,231 @@
+mod repo_support;
+
+use std::fs;
+
+use naome_core::{
+    check_repository_quality, check_semantic_legacy, init_repository_quality,
+    init_repository_quality_with_mode, quality_cache_status, QualityInitMode, QualityMode,
+};
+
+use repo_support::TestRepo;
+
+#[test]
+fn quality_init_seeds_policy_without_baseline_scan() {
+    let repo = quality_repo("quality-init-seed-only");
+    repo.write_file("src/large.js", &large_file());
+    repo.commit_all("legacy debt");
+
+    let init = init_repository_quality(repo.path()).unwrap();
+
+    assert!(init.config_written);
+    assert!(init.structure_config_written);
+    assert!(!init.baseline_written);
+    assert!(init.baseline_pending);
+    assert_eq!(init.baseline_violations, 0);
+    assert!(repo
+        .path()
+        .join(".naome/repository-quality-baseline.json")
+        .is_file());
+}
+
+#[test]
+fn quality_baseline_modes_are_explicit() {
+    let repo = quality_repo("quality-init-explicit-baseline");
+    repo.write_file("src/large.js", &large_file());
+    repo.commit_all("legacy debt");
+
+    let baseline =
+        init_repository_quality_with_mode(repo.path(), QualityInitMode::Baseline).unwrap();
+    assert!(baseline.baseline_written);
+    assert!(!baseline.baseline_pending);
+    assert!(baseline.baseline_violations > 0);
+
+    let deep =
+        init_repository_quality_with_mode(repo.path(), QualityInitMode::DeepBaseline).unwrap();
+    assert_eq!(deep.mode, "deep-baseline");
+    assert!(deep.baseline_violations >= baseline.baseline_violations);
+}
+
+#[test]
+fn changed_fast_scans_only_changed_file_contents() {
+    let repo = quality_repo("quality-changed-fast-focused");
+    for index in 0..1000 {
+        repo.write_file(
+            &format!("src/unchanged_{index}.js"),
+            "export const value = 1;\n",
+        );
+    }
+    repo.write_file("src/changed.js", "export const before = 1;\n");
+    repo.commit_all("large baseline");
+    repo.write_file("src/changed.js", "export const after = 2;\n");
+
+    let report = check_repository_quality(repo.path(), QualityMode::ChangedFast).unwrap();
+
+    assert_eq!(report.mode, "changed");
+    assert_eq!(report.summary.scanned_files, 1);
+    assert_eq!(report.summary.scanned_path_count, 1);
+    assert!(report.changed_paths.contains(&"src/changed.js".to_string()));
+}
+
+#[test]
+fn semantic_changed_check_scans_only_changed_file_contents() {
+    let repo = quality_repo("semantic-changed-fast-focused");
+    for index in 0..1000 {
+        repo.write_file(
+            &format!("src/unchanged_{index}.js"),
+            &legacy_fixture("oldConfig"),
+        );
+    }
+    repo.write_file("scripts/changed.test.js", "const value = 1;\n");
+    repo.commit_all("large baseline");
+    repo.write_file("scripts/changed.test.js", &legacy_fixture("newConfig"));
+
+    let report = check_semantic_legacy(repo.path(), QualityMode::ChangedFast).unwrap();
+
+    assert_eq!(report.mode, "changed");
+    assert_eq!(report.summary.scanned_files, 1);
+}
+
+#[test]
+fn second_report_uses_file_analysis_cache() {
+    let repo = quality_repo("quality-cache-second-report");
+    repo.write_file("src/a.js", "export const value = 1;\n");
+    repo.write_file("src/b.js", "export const other = 2;\n");
+    repo.commit_all("baseline");
+
+    let first = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+    let cache = quality_cache_status(repo.path()).unwrap();
+    let second = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+
+    assert_eq!(first.summary.scanned_files, 2);
+    assert!(cache.entry_count >= 2);
+    assert_eq!(second.summary.cache_hits, 2);
+    assert_eq!(second.summary.cache_misses, 0);
+}
+
+#[test]
+fn report_budget_marks_truncated_reports() {
+    let repo = quality_repo("quality-report-budget");
+    for index in 0..5005 {
+        repo.write_file(&format!("src/file_{index}.js"), "export const value = 1;\n");
+    }
+    repo.commit_all("large baseline");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+
+    assert!(report.summary.truncated);
+    assert!(report
+        .summary
+        .reason_codes
+        .contains(&"max_scanned_files".to_string()));
+    assert_eq!(report.summary.scanned_files, 5000);
+}
+
+#[test]
+fn report_skips_deep_only_duplicate_checks() {
+    let repo = quality_repo("quality-deep-only-duplicates");
+    repo.write_file("src/a.js", &duplicate_block("one"));
+    repo.write_file("src/b.js", &duplicate_block("two"));
+    repo.commit_all("duplicate baseline");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+    let deep = check_repository_quality(repo.path(), QualityMode::DeepReport).unwrap();
+
+    assert!(report
+        .summary
+        .reason_codes
+        .contains(&"deep_checks_skipped".to_string()));
+    assert!(!report
+        .violations
+        .iter()
+        .any(|violation| violation.check_id == "duplicate-blocks"));
+    assert!(deep
+        .violations
+        .iter()
+        .any(|violation| violation.check_id == "duplicate-blocks"));
+}
+
+#[test]
+fn changed_fast_compares_changed_files_to_cached_candidates() {
+    let repo = quality_repo("quality-changed-cache-duplicates");
+    repo.write_file("src/existing.js", &duplicate_block("existing"));
+    repo.write_file("src/new.js", "export const value = 1;\n");
+    repo.commit_all("baseline");
+    let _ = check_repository_quality(repo.path(), QualityMode::DeepReport).unwrap();
+
+    repo.write_file("src/new.js", &duplicate_block("newCopy"));
+    let report = check_repository_quality(repo.path(), QualityMode::ChangedFast).unwrap();
+
+    assert!(report.summary.cache_hits >= 1);
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "duplicate-blocks" && violation.path == "src/new.js"
+    }));
+}
+
+#[test]
+fn changed_fast_compares_changed_files_to_cold_cache_candidates() {
+    let repo = quality_repo("quality-changed-cold-cache-duplicates");
+    repo.write_file("src/existing.js", &duplicate_block("existing"));
+    repo.write_file("src/new.js", "export const value = 1;\n");
+    repo.commit_all("baseline");
+
+    repo.write_file("src/new.js", &duplicate_block("newCopy"));
+    let report = check_repository_quality(repo.path(), QualityMode::ChangedFast).unwrap();
+
+    assert_eq!(report.summary.cache_hits, 0);
+    assert!(report.summary.cache_misses >= 2);
+    assert_eq!(report.summary.scanned_files, 1);
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "duplicate-blocks"
+            && violation.path == "src/new.js"
+            && violation
+                .related_paths
+                .contains(&"src/existing.js".to_string())
+    }));
+}
+
+fn quality_repo(name: &str) -> TestRepo {
+    let repo = TestRepo::new(name);
+    repo.init_git();
+    fs::create_dir_all(repo.path().join(".naome")).unwrap();
+    repo
+}
+
+fn large_file() -> String {
+    (0..520)
+        .map(|index| format!("export const value{index} = {index};\n"))
+        .collect()
+}
+
+fn legacy_fixture(name: &str) -> String {
+    format!(
+        r#"const {name} = {{
+  schema: "naome.performance-fixture.v1",
+  version: 1,
+  status: "ready",
+  checks: [],
+  changeTypes: [],
+  releaseGates: []
+}};
+"#
+    )
+}
+
+fn duplicate_block(name: &str) -> String {
+    format!(
+        r#"export function {name}() {{
+  const one = 1;
+  const two = 2;
+  const three = 3;
+  const four = 4;
+  const five = 5;
+  const six = 6;
+  const seven = 7;
+  const eight = 8;
+  const nine = 9;
+  const ten = 10;
+  return one + two + three + four + five + six + seven + eight + nine + ten;
+}}
+"#
+    )
+}

package/crates/naome-core/tests/quality_structure.rs

@@ -0,0 +1,116 @@
+mod quality_structure_support;
+
+use naome_core::{check_repository_quality, QualityMode};
+use serde_json::json;
+
+use quality_structure_support::{assert_has, StructureFixture};
+
+#[test]
+fn source_and_test_files_in_known_roots_are_ok() {
+    let repo = StructureFixture::new("structure-good-roots");
+    repo.write_js_package();
+    repo.write(
+        "src/feature.js",
+        "export function feature() {\n  return 1;\n}\n",
+    );
+    repo.write("tests/feature.test.js", "import '../src/feature.js';\n");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(report.ok, "{:#?}", report.violations);
+}
+
+#[test]
+fn misplaced_test_file_creates_structure_finding() {
+    let repo = StructureFixture::new("structure-misplaced-test");
+    repo.write_js_package();
+    repo.write(
+        "src/feature.test.js",
+        "export function testFeature() {\n  return 1;\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert_has(&report, "src/feature.test.js", "misplaced-file-role");
+}
+
+#[test]
+fn generated_or_artifact_file_in_source_folder_creates_finding() {
+    let repo = StructureFixture::new("structure-generated-source");
+    repo.write_js_package();
+    repo.write(
+        "src/generated/client.ts",
+        "export const generated = true;\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert_has(&report, "src/generated/client.ts", "directory-role-mixing");
+}
+
+#[test]
+fn unknown_root_files_create_root_sprawl_findings() {
+    let repo = StructureFixture::new("structure-root-sprawl");
+    repo.write("notes.tmp", "temporary notes\n");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert_has(&report, "notes.tmp", "root-file-sprawl");
+}
+
+#[test]
+fn dumping_ground_directory_flags_new_feature_logic() {
+    let repo = StructureFixture::new("structure-dumping-ground");
+    repo.write_js_package();
+    repo.write(
+        "src/payments/service.js",
+        "export function charge() {\n  return 1;\n}\n",
+    );
+    repo.commit_all("module baseline");
+    repo.write(
+        "src/utils/payment-flow.js",
+        "export function capturePayment() {\n  return charge();\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert_has(
+        &report,
+        "src/utils/payment-flow.js",
+        "dumping-ground-directory",
+    );
+}
+
+#[test]
+fn excessive_path_depth_and_directory_size_are_reported() {
+    let repo = StructureFixture::new("structure-limits");
+    repo.write_structure_config(json!({
+        "limits": {
+            "maxDirectoryFiles": 2,
+            "maxPathDepth": 4,
+            "maxDirectoryRoles": 2,
+            "maxDumpingGroundFiles": 8
+        }
+    }));
+    repo.write("src/a/one.js", "export const one = 1;\n");
+    repo.write("src/a/two.js", "export const two = 2;\n");
+    repo.write("src/a/three.js", "export const three = 3;\n");
+    repo.write("src/a/b/c/d/e/deep.js", "export const deep = 1;\n");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert_has(&report, "src/a", "directory-size");
+    assert_has(&report, "src/a/b/c/d/e/deep.js", "path-depth");
+}
+
+#[test]
+fn case_insensitive_path_collisions_block_changed_paths() {
+    let repo = StructureFixture::new("structure-case-collision");
+    repo.add_index_only_path("src/User.ts", "export const upper = 1;\n");
+    repo.add_index_only_path("src/user.ts", "export const lower = 1;\n");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert_has(&report, "src/User.ts", "case-collision");
+    assert_has(&report, "src/user.ts", "case-collision");
+}

package/crates/naome-core/tests/quality_structure_adapters.rs

@@ -0,0 +1,98 @@
+mod quality_structure_support;
+
+use naome_core::{check_repository_quality, explain_repository_structure, QualityMode};
+
+use quality_structure_support::{assert_has, StructureFixture};
+
+#[test]
+fn rust_adapter_recognizes_cargo_source_and_test_structure() {
+    let repo = StructureFixture::new("structure-rust-adapter");
+    repo.write(
+        "Cargo.toml",
+        "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
+    );
+    repo.write("src/lib.rs", "pub fn value() -> u8 {\n    1\n}\n");
+    repo.write(
+        "tests/lib_test.rs",
+        "#[test]\nfn value() {\n    assert_eq!(1, 1);\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+    let source = explain_repository_structure(repo.path(), "src/lib.rs").unwrap();
+
+    assert!(report.ok, "{:#?}", report.violations);
+    assert_eq!(source.role, "source");
+    assert_eq!(source.language.as_deref(), Some("rust"));
+}
+
+#[test]
+fn javascript_typescript_adapter_recognizes_package_source_and_tests() {
+    let repo = StructureFixture::new("structure-js-ts-adapter");
+    repo.write_js_package();
+    repo.write("src/app.ts", "export function app() {\n  return 1;\n}\n");
+    repo.write("src/app.test.ts", "import { app } from './app';\napp();\n");
+
+    let source = explain_repository_structure(repo.path(), "src/app.ts").unwrap();
+    let test = explain_repository_structure(repo.path(), "src/app.test.ts").unwrap();
+
+    assert_eq!(source.role, "source");
+    assert_eq!(source.language.as_deref(), Some("typescript"));
+    assert_eq!(test.role, "test");
+}
+
+#[test]
+fn unknown_repository_gets_generic_roles() {
+    let repo = StructureFixture::new("structure-generic-roles");
+    repo.write("docs/readme.md", "# Docs\n");
+    repo.write("scripts/build.sh", "echo build\n");
+    repo.write("src/main.go", "package main\nfunc main() {}\n");
+
+    assert_eq!(
+        explain_repository_structure(repo.path(), "docs/readme.md")
+            .unwrap()
+            .role,
+        "docs"
+    );
+    assert_eq!(
+        explain_repository_structure(repo.path(), "scripts/build.sh")
+            .unwrap()
+            .role,
+        "script"
+    );
+    assert_eq!(
+        explain_repository_structure(repo.path(), "src/main.go")
+            .unwrap()
+            .language
+            .as_deref(),
+        Some("go")
+    );
+}
+
+#[test]
+fn source_changes_without_nearby_tests_create_pairing_finding() {
+    let repo = StructureFixture::new("structure-missing-test-pair");
+    repo.write_js_package();
+    repo.write(
+        "src/billing/invoice.ts",
+        "export function invoice() {\n  return 1;\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert_has(&report, "src/billing/invoice.ts", "test-source-pairing");
+}
+
+#[test]
+fn repositories_without_structure_config_remain_valid() {
+    let repo = StructureFixture::new("structure-config-backcompat");
+    repo.write_quality_config();
+    repo.write(
+        "src/index.js",
+        "export function index() {\n  return 1;\n}\n",
+    );
+    repo.write("tests/index.test.js", "import '../src/index.js';\n");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(report.ok, "{:#?}", report.violations);
+}

package/crates/naome-core/tests/quality_structure_policy.rs

@@ -0,0 +1,144 @@
+mod quality_structure_support;
+
+use naome_core::{
+    check_repository_quality, explain_repository_structure, route_quality_cleanup, QualityMode,
+};
+
+use quality_structure_support::{assert_has, StructureFixture};
+
+#[test]
+fn legacy_structure_debt_is_reported_but_not_changed_blocking() {
+    let repo = StructureFixture::new("structure-legacy-debt");
+    repo.write("random.tmp", "legacy scratch\n");
+    repo.commit_all("legacy debt");
+
+    let changed = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+
+    assert!(changed.ok);
+    assert_has(&report, "random.tmp", "root-file-sprawl");
+}
+
+#[test]
+fn touched_file_inside_debt_directory_blocks_changed_gate() {
+    let repo = StructureFixture::new("structure-touched-debt-dir");
+    repo.write_js_package();
+    repo.write(
+        "src/utils/legacy-helper.js",
+        "export function legacy() {\n  return 1;\n}\n",
+    );
+    repo.commit_all("legacy dumping ground");
+    repo.write(
+        "src/utils/legacy-helper.js",
+        "export function legacy() {\n  return 2;\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert_has(
+        &report,
+        "src/utils/legacy-helper.js",
+        "dumping-ground-directory",
+    );
+}
+
+#[test]
+fn quality_report_and_cleanup_route_include_structure_findings() {
+    let repo = StructureFixture::new("structure-report-cleanup");
+    repo.write(
+        "src/utils/random.js",
+        "export function random() {\n  return 1;\n}\n",
+    );
+    repo.commit_all("legacy structure debt");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Report).unwrap();
+    let route = route_quality_cleanup(repo.path(), "src/utils/random.js").unwrap();
+
+    assert_has(&report, "src/utils/random.js", "dumping-ground-directory");
+    assert!(route.agent_instructions.contains("structure"));
+    assert!(route
+        .violations
+        .iter()
+        .any(|violation| violation.check_id == "dumping-ground-directory"));
+}
+
+#[test]
+fn cleanup_route_gives_specific_test_pairing_instructions() {
+    let repo = StructureFixture::new("structure-cleanup-test-pairing");
+    repo.write_js_package();
+    repo.write(
+        "src/billing/invoice.js",
+        "export function invoiceTotal() {\n  return 1;\n}\n",
+    );
+
+    let route = route_quality_cleanup(repo.path(), "src/billing/invoice.js").unwrap();
+
+    assert!(route
+        .agent_instructions
+        .contains("Create or update a nearby or module-matched test"));
+    assert!(route
+        .required_checks
+        .contains(&"naome quality check --changed".to_string()));
+}
+
+#[test]
+fn wildcard_module_roots_explain_monorepo_module_names() {
+    let repo = StructureFixture::new("structure-wildcard-module-root");
+    repo.write_structure_config(serde_json::json!({
+        "sourceRoots": ["packages/*/src/**"],
+        "moduleRoots": ["packages/*/src/**"]
+    }));
+    repo.write("packages/payments/src/lib.rs", "pub fn charge() {}\n");
+
+    let explanation =
+        explain_repository_structure(repo.path(), "packages/payments/src/lib.rs").unwrap();
+
+    assert_eq!(explanation.module.as_deref(), Some("payments"));
+}
+
+#[test]
+fn disabled_structure_checks_are_not_reported() {
+    let repo = StructureFixture::new("structure-disabled-checks");
+    repo.write_structure_config(serde_json::json!({
+        "allowedRootFiles": [".naomeignore", "package.json", "README.md"],
+        "disabledChecks": ["test-source-pairing"]
+    }));
+    repo.write(
+        "src/payment-flow.js",
+        "export function paymentFlow() {\n  return 1;\n}\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(report.ok, "{:#?}", report.violations);
+}
+
+#[test]
+fn directory_role_rules_can_allow_configured_role_mixes() {
+    let repo = StructureFixture::new("structure-directory-role-rule");
+    repo.write_structure_config(serde_json::json!({
+        "directoryRoleRules": [
+            {
+                "id": "generated-source-client",
+                "paths": ["src/generated/**"],
+                "allowedRoles": ["generated"],
+                "maxRoles": 1
+            }
+        ]
+    }));
+    repo.write(
+        "src/generated/client.ts",
+        "export const generated = true;\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(
+        !report
+            .violations
+            .iter()
+            .any(|violation| violation.check_id == "directory-role-mixing"),
+        "{:#?}",
+        report.violations
+    );
+}