@lamentis/naome 1.2.1 → 1.3.1

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

@@ -0,0 +1,281 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use naome_core::{explain_repository_model_path, refresh_repository_model, repository_model_drift};
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+#[test]
+fn refresh_write_captures_deterministic_repository_facts() {
+    let repo = Repo::new("repository-model-refresh");
+    repo.write(
+        "Cargo.toml",
+        "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
+    );
+    repo.write("package.json", "{\"scripts\":{\"test\":\"node --test\"}}\n");
+    repo.write("src/lib.rs", "pub fn run() {}\n");
+    repo.write("tests/app.test.ts", "test('works', () => {});\n");
+    repo.write(
+        ".naome/verification.json",
+        "{\"checks\":[{\"id\":\"unit-test\",\"command\":\"cargo test\",\"cwd\":\".\",\"evidence\":[\"src/lib.rs\"]}]}\n",
+    );
+
+    let report = refresh_repository_model(repo.path(), true).unwrap();
+
+    assert!(report.ok);
+    assert_eq!(report.updated_paths, vec![".naome/repository-model.json"]);
+    assert_fact(&report.model, "language", "rust");
+    assert_fact(&report.model, "language", "javascript-typescript");
+    assert_fact(&report.model, "packageManager", "cargo");
+    assert_fact(&report.model, "packageManager", "npm");
+    assert_fact(&report.model, "sourceRoot", "src");
+    assert_fact(&report.model, "testRoot", "tests");
+    assert_fact(&report.model, "verificationCheck", "unit-test");
+    let js_fact = fact(&report.model, "language", "javascript-typescript");
+    assert_eq!(js_fact.evidence, vec!["package.json", "tests/app.test.ts"]);
+    assert!(repo.path().join(".naome/repository-model.json").is_file());
+}
+
+#[test]
+fn refresh_write_prefers_v2_world_model_sections() {
+    let repo = Repo::new("repository-world-model-v2");
+    repo.write(
+        "packages/mobile/Package.swift",
+        "// swift-tools-version: 5.9\n",
+    );
+    repo.write("packages/mobile/Sources/App/App.swift", "import SwiftUI\n");
+    repo.write(
+        "packages/mobile/Tests/AppTests/AppTests.swift",
+        "import XCTest\n",
+    );
+    repo.write(
+        "packages/web/package.json",
+        "{\"scripts\":{\"test\":\"vitest\"}}\n",
+    );
+    repo.write(
+        "packages/web/src/App.tsx",
+        "export function App() { return null; }\n",
+    );
+    repo.write(
+        "packages/web/src/App.test.tsx",
+        "test('works', () => {});\n",
+    );
+    repo.write(
+        ".naome/verification.json",
+        "{\"checks\":[{\"id\":\"unit-test\",\"command\":\"npm test\",\"cwd\":\".\",\"evidence\":[\"packages/web/src/App.tsx\"]}]}\n",
+    );
+
+    let report = refresh_repository_model(repo.path(), true).unwrap();
+
+    assert!(report.ok);
+    assert_eq!(report.model.schema, "naome.repository-model.v2");
+    assert_eq!(report.model.version, 2);
+    assert!(report
+        .model
+        .languages
+        .iter()
+        .any(|language| language.id == "swift"));
+    assert!(report
+        .model
+        .languages
+        .iter()
+        .any(|language| language.id == "javascript-typescript"));
+    assert!(report
+        .model
+        .adapters
+        .iter()
+        .any(|adapter| adapter.id == "swiftui"));
+    assert!(report
+        .model
+        .entities
+        .iter()
+        .any(|entity| entity.id == "package:packages/mobile"));
+    assert!(report
+        .model
+        .entities
+        .iter()
+        .any(|entity| entity.id == "package:packages/web"));
+    assert!(report
+        .model
+        .roots
+        .iter()
+        .any(|root| root.path == "packages/mobile/Sources" && root.role == "source"));
+    assert!(report
+        .model
+        .verification_checks
+        .iter()
+        .any(|check| check.id == "unit-test"));
+}
+
+#[test]
+fn v1_model_files_remain_readable_for_path_explain() {
+    let repo = Repo::new("repository-model-v1-readable");
+    repo.write(
+        ".naome/repository-model.json",
+        "{\"schema\":\"naome.repository-model.v1\",\"version\":1,\"status\":\"ready\",\"facts\":[{\"id\":\"language:rust\",\"category\":\"language\",\"value\":\"rust\",\"confidence\":\"high\",\"source\":\"deterministic-scan\",\"evidence\":[\"src/lib.rs\"]}]}\n",
+    );
+    repo.write("src/lib.rs", "pub fn run() {}\n");
+
+    let explanation = explain_repository_model_path(repo.path(), "src/lib.rs").unwrap();
+
+    assert_eq!(explanation.language.as_deref(), Some("rust"));
+    assert_eq!(explanation.role.as_deref(), Some("source"));
+    assert!(explanation
+        .facts
+        .iter()
+        .any(|fact| fact.id == "language:rust"));
+}
+
+#[test]
+fn path_explain_returns_world_model_entity_and_role() {
+    let repo = Repo::new("repository-model-explain-world");
+    repo.write("packages/api/Cargo.toml", "[package]\nname = \"api\"\n");
+    repo.write("packages/api/src/lib.rs", "pub fn run() {}\n");
+    refresh_repository_model(repo.path(), true).unwrap();
+
+    let explanation =
+        explain_repository_model_path(repo.path(), "packages/api/src/lib.rs").unwrap();
+
+    assert_eq!(explanation.language.as_deref(), Some("rust"));
+    assert_eq!(explanation.role.as_deref(), Some("source"));
+    assert_eq!(explanation.module.as_deref(), Some("packages/api"));
+    assert_eq!(explanation.entity.as_deref(), Some("package:packages/api"));
+}
+
+#[test]
+fn check_reports_stale_model_until_refresh_write_updates_it() {
+    let repo = Repo::new("repository-model-stale");
+    repo.write(".naome/repository-model.json", "{\"schema\":\"naome.repository-model.v1\",\"version\":1,\"status\":\"ready\",\"facts\":[]}\n");
+    repo.write("Package.swift", "// swift-tools-version: 5.9\n");
+    repo.write("Sources/App/App.swift", "public struct App {}\n");
+
+    let check = refresh_repository_model(repo.path(), false).unwrap();
+    assert!(!check.ok);
+    assert!(check.stale);
+    assert_fact(&check.model, "language", "swift");
+
+    let written = refresh_repository_model(repo.path(), true).unwrap();
+    assert!(written.ok);
+    assert!(!written.stale);
+    assert_eq!(written.updated_paths, vec![".naome/repository-model.json"]);
+
+    let repeated = refresh_repository_model(repo.path(), false).unwrap();
+    assert!(repeated.ok);
+    assert!(!repeated.stale);
+}
+
+#[test]
+fn drift_detects_world_sections_when_fact_values_are_unchanged() {
+    let repo = Repo::new("repository-model-world-section-drift");
+    repo.write(
+        "packages/a/package.json",
+        "{\"scripts\":{\"test\":\"node --test\"}}\n",
+    );
+    repo.write("packages/a/src/index.ts", "export const a = 1;\n");
+    refresh_repository_model(repo.path(), true).unwrap();
+
+    let clean = repository_model_drift(repo.path()).unwrap();
+    assert!(clean.ok);
+
+    repo.write(
+        "packages/b/package.json",
+        "{\"scripts\":{\"test\":\"node --test\"}}\n",
+    );
+
+    let drift = repository_model_drift(repo.path()).unwrap();
+
+    assert!(!drift.ok);
+    assert!(drift.stale);
+    assert!(drift
+        .related_paths
+        .contains(&"packages/b/package.json".to_string()));
+}
+
+#[test]
+fn explain_repository_model_path_uses_canonical_facts() {
+    let repo = Repo::new("repository-model-explain");
+    repo.write("Package.swift", "// swift-tools-version: 5.9\n");
+    repo.write("Sources/App/App.swift", "public struct App {}\n");
+    refresh_repository_model(repo.path(), true).unwrap();
+
+    let explanation = explain_repository_model_path(repo.path(), "Sources/App/App.swift").unwrap();
+
+    assert_eq!(explanation.path, "Sources/App/App.swift");
+    assert_eq!(explanation.language.as_deref(), Some("swift"));
+    assert_eq!(explanation.role.as_deref(), Some("source"));
+    assert!(explanation
+        .evidence
+        .contains(&"Sources/App/App.swift".to_string()));
+}
+
+fn assert_fact(model: &naome_core::RepositoryModel, category: &str, value: &str) {
+    assert!(
+        model
+            .facts
+            .iter()
+            .any(|fact| fact.category == category && fact.value == value),
+        "missing {category}:{value}; facts: {:#?}",
+        model.facts
+    );
+}
+
+fn fact<'a>(
+    model: &'a naome_core::RepositoryModel,
+    category: &str,
+    value: &str,
+) -> &'a naome_core::RepositoryFact {
+    model
+        .facts
+        .iter()
+        .find(|fact| fact.category == category && fact.value == value)
+        .unwrap_or_else(|| panic!("missing {category}:{value}; facts: {:#?}", model.facts))
+}
+
+struct Repo {
+    root: PathBuf,
+}
+
+impl Repo {
+    fn new(name: &str) -> Self {
+        let root = std::env::temp_dir().join(format!(
+            "naome-{name}-{}-{}",
+            std::process::id(),
+            FIXTURE_COUNTER.fetch_add(1, Ordering::SeqCst)
+        ));
+        let _ = fs::remove_dir_all(&root);
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        git(&root, &["init"]);
+        git(&root, &["config", "user.email", "test@example.com"]);
+        git(&root, &["config", "user.name", "Test User"]);
+        Self { root }
+    }
+
+    fn path(&self) -> &Path {
+        &self.root
+    }
+
+    fn write(&self, relative_path: &str, content: &str) {
+        let path = self.root.join(relative_path);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).unwrap();
+        }
+        fs::write(path, content).unwrap();
+    }
+}
+
+impl Drop for Repo {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.root);
+    }
+}
+
+fn git(root: &Path, args: &[&str]) {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(root)
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+}

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

@@ -5,7 +5,10 @@ use serde_json::json;
 
 mod repo_support;
 
-use repo_support::{assert_user_diff_committed, route_commit_request, TestRepo};
+use repo_support::{
+    assert_user_diff_committed, change_type, quality_check, repository_quality_config_source,
+    route_commit_request, semantic_repository_quality_fixture_source, verification_value, TestRepo,
+};
 
 #[test]
 fn execute_route_does_not_mutate_or_offer_clear_commit_for_dirty_unowned_diff() {
@@ -70,20 +73,69 @@ fn execute_route_runs_repository_quality_check_without_shelling_to_repo_command(
 }
 
 #[test]
-fn execute_route_commits_product_diff_with_declared_safe_quality_checks() {
+fn execute_route_refuses_semantic_changed_findings_through_repository_quality_gate() {
+    let repo = TestRepo::new("route-semantic-quality-gate");
+    repo.init_git();
+    repo.write_file(
+        ".naome/repository-quality.json",
+        &repository_quality_config_source(),
+    );
+    repo.write_file("scripts/baseline.test.js", "const ok = { value: 1 };\n");
+    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+    repo.write_naome_json(
+        "verification.json",
+        verification_value(
+            "ready",
+            vec![quality_check(
+                "repository-quality-check",
+                "naome quality check --changed",
+                "Validate changed files against repository quality rules.",
+                "fast",
+                vec!["scripts/**"],
+            )],
+            vec![change_type(
+                "scripts",
+                "Script changes.",
+                vec!["scripts/**"],
+                vec!["repository-quality-check"],
+            )],
+        ),
+    );
+    repo.commit_all("baseline");
+    repo.write_file(
+        "scripts/new.test.js",
+        &semantic_repository_quality_fixture_source("newQualityConfig"),
+    );
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+
+    let route = route_commit_request(&repo);
+
+    assert_quality_gate_blocked(&repo, &route, before_head, "scripts/new.test.js");
+    assert!(route.user_message.contains("repository-quality-check"));
+    assert!(route
+        .user_message
+        .contains("semantic-inline-legacy-fixture"));
+}
+
+#[test]
+fn execute_route_refuses_product_named_checks_without_generic_builtin_policy() {
     let repo = TestRepo::product_quality_repo("route-product-diff-quality-pass");
     repo.write_file(
         "packages/naome/crates/naome-core/src/route.rs",
         "pub fn changed() {}\n",
     );
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
 
     let route = route_commit_request(&repo);
 
-    assert_user_diff_committed(&route, &repo);
-
-    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("packages/naome/crates/naome-core/src/route.rs"));
-    assert!(route.user_message.contains("quality gates passed"));
+    assert_quality_gate_blocked(
+        &repo,
+        &route,
+        before_head,
+        "packages/naome/crates/naome-core/src/route.rs",
+    );
+    assert!(route.user_message.contains("installer-tests"));
+    assert!(route.user_message.contains("not a built-in safe check"));
 }
 
 #[test]

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

@@ -0,0 +1,174 @@
+mod repo_support;
+
+use naome_core::{
+    check_repository_quality, check_semantic_legacy, semantic_route_for_finding, QualityMode,
+};
+
+use repo_support::{
+    repository_quality_config_value, semantic_repository_quality_fixture_source, TestRepo,
+};
+
+#[test]
+fn report_groups_repeated_config_fixture_shapes_across_repository() {
+    let repo = semantic_repo("semantic-report-groups");
+    repo.write_file(
+        "scripts/a.test.js",
+        &semantic_repository_quality_fixture_source("qualityConfig"),
+    );
+    repo.write_file(
+        "scripts/b.test.js",
+        &semantic_repository_quality_fixture_source("repositoryQualityConfig"),
+    );
+    repo.commit_all("baseline");
+
+    let report = check_semantic_legacy(repo.path(), QualityMode::DeepReport).unwrap();
+
+    let finding = report
+        .findings
+        .iter()
+        .find(|finding| finding.kind == "copied-config-object")
+        .expect("expected copied config finding");
+    assert_eq!(finding.occurrences.len(), 2);
+    assert!(finding
+        .occurrences
+        .iter()
+        .any(|occurrence| occurrence.path == "scripts/a.test.js"));
+    assert!(finding
+        .cleanup_route
+        .agent_instructions
+        .iter()
+        .any(|instruction| instruction.contains("every occurrence")));
+}
+
+#[test]
+fn changed_check_blocks_new_inline_legacy_fixture_only() {
+    let repo = semantic_repo("semantic-changed-only");
+    repo.write_file(
+        "scripts/old.test.js",
+        &semantic_repository_quality_fixture_source("oldQualityConfig"),
+    );
+    repo.commit_all("baseline");
+    repo.write_file("README.md", "# harmless change\n");
+
+    let unrelated = check_semantic_legacy(repo.path(), QualityMode::Changed).unwrap();
+    assert!(unrelated.ok, "{:#?}", unrelated.findings);
+
+    repo.write_file(
+        "scripts/new.test.js",
+        &semantic_repository_quality_fixture_source("newQualityConfig"),
+    );
+
+    let changed = check_semantic_legacy(repo.path(), QualityMode::Changed).unwrap();
+    assert!(!changed.ok);
+    assert!(changed
+        .findings
+        .iter()
+        .any(|finding| finding.kind == "inline-legacy-fixture"));
+}
+
+#[test]
+fn repository_quality_changed_includes_semantic_changed_findings() {
+    let repo = semantic_repo("semantic-quality-gate");
+    repo.commit_all("baseline");
+    repo.write_file(
+        "scripts/new.test.js",
+        &semantic_repository_quality_fixture_source("newQualityConfig"),
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(!report.ok);
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "semantic-inline-legacy-fixture"
+            && violation.path == "scripts/new.test.js"
+    }));
+}
+
+#[test]
+fn changed_check_allows_shared_fixture_factory_objects() {
+    let repo = semantic_repo("semantic-shared-factory");
+    repo.commit_all("baseline");
+    repo.write_file(
+        "scripts/test-support.js",
+        &[
+            "function verificationContract() {",
+            "  return {",
+            "    schema: \"naome.verification.v1\",",
+            "    version: 1,",
+            "    status: \"ready\",",
+            "    checks: [],",
+            "    changeTypes: [],",
+            "    releaseGates: []",
+            "  };",
+            "}",
+            "",
+        ]
+        .join("\n"),
+    );
+
+    let report = check_semantic_legacy(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(report.ok, "{:#?}", report.findings);
+}
+
+#[test]
+fn changed_check_allows_shared_support_fixture_modules() {
+    let repo = semantic_repo("semantic-shared-support");
+    repo.commit_all("baseline");
+    repo.write_file(
+        "tests/repo_support/verification_values.rs",
+        &[
+            "pub fn completed_task_state() -> serde_json::Value {",
+            "    serde_json::json!({",
+            "        \"schema\": \"naome.task-state.v1\",",
+            "        \"version\": 1,",
+            "        \"status\": \"complete\",",
+            "        \"activeTask\": {",
+            "            \"id\": \"readme-task\",",
+            "            \"requiredCheckIds\": [\"diff-check\"],",
+            "            \"proofResults\": []",
+            "        }",
+            "    })",
+            "}",
+            "",
+        ]
+        .join("\n"),
+    );
+
+    let report = check_semantic_legacy(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(report.ok, "{:#?}", report.findings);
+}
+
+#[test]
+fn semantic_route_returns_complete_agent_cleanup_task() {
+    let repo = semantic_repo("semantic-route");
+    repo.write_file(
+        "scripts/a.test.js",
+        &semantic_repository_quality_fixture_source("qualityConfig"),
+    );
+    repo.write_file(
+        "scripts/b.test.js",
+        &semantic_repository_quality_fixture_source("repositoryQualityConfig"),
+    );
+    repo.commit_all("baseline");
+    let report = check_semantic_legacy(repo.path(), QualityMode::DeepReport).unwrap();
+    let finding_id = report.findings[0].id.clone();
+
+    let finding = semantic_route_for_finding(&report, &finding_id).unwrap();
+
+    assert_eq!(finding.id, finding_id);
+    assert!(!finding.cleanup_route.target_suggestion.is_empty());
+    assert!(finding
+        .cleanup_route
+        .required_checks
+        .contains(&"naome semantic check --changed".to_string()));
+}
+
+fn semantic_repo(name: &str) -> TestRepo {
+    let repo = TestRepo::new(name);
+    repo.init_git();
+    repo.write_file("README.md", "# Semantic fixture\n");
+    repo.write_naome_json("repository-quality.json", repository_quality_config_value());
+    repo
+}