relinking workflow

tests/test_registry_service.py

@@ -372,6 +372,114 @@ def test_reject_candidate_feature_and_evidence_excludes_only_those_leaves(tmp_pa
     assert len(approved_capability.evidence) == len(capability.evidence) - 1
 
 
+def test_relink_candidate_capability_to_another_ability_before_approval(tmp_path):
+    source = tmp_path / "repo"
+    source.mkdir()
+    (source / "README.md").write_text("# Relink Capability\n", encoding="utf-8")
+    (source / "app.py").write_text(
+        "from fastapi import FastAPI\n"
+        "app = FastAPI()\n"
+        '@app.get("/health")\n'
+        "def health():\n"
+        "    return {}\n",
+        encoding="utf-8",
+    )
+
+    service = make_service(tmp_path)
+    repository = service.register_repository(name="Relink Capability", url=str(source))
+    summary = service.analyze_repository(repository.id)
+    graph = service.candidate_graph(repository.id, summary.analysis_run.id)
+    capability = graph.abilities[0].capabilities[0]
+    with service.store.connect() as connection:
+        cursor = connection.execute(
+            """
+            INSERT INTO candidate_abilities
+              (repository_id, analysis_run_id, name, description, confidence)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            (
+                repository.id,
+                summary.analysis_run.id,
+                "Operations Visibility",
+                "Curator-created target ability.",
+                0.72,
+            ),
+        )
+        target_ability_id = int(cursor.lastrowid)
+
+    relinked_graph = service.relink_candidate_capability(
+        repository.id,
+        summary.analysis_run.id,
+        capability.id,
+        target_ability_id=target_ability_id,
+        notes="Move interface under the operational ability.",
+    )
+    ability_map = service.approve_candidate_graph(repository.id, summary.analysis_run.id)
+
+    target_candidate = [
+        ability for ability in relinked_graph.abilities if ability.id == target_ability_id
+    ][0]
+    assert target_candidate.capabilities[0].id == capability.id
+    approved_target = [
+        ability for ability in ability_map.abilities if ability.name == "Operations Visibility"
+    ][0]
+    assert approved_target.capabilities[0].name == capability.name
+
+
+def test_relink_candidate_feature_and_evidence_to_another_capability(tmp_path):
+    source = tmp_path / "repo"
+    source.mkdir()
+    (source / "README.md").write_text("# Relink Leaves\n", encoding="utf-8")
+    (source / "requirements.txt").write_text("fastapi\n", encoding="utf-8")
+    (source / "tests").mkdir()
+    (source / "tests" / "test_health.py").write_text(
+        "def test_health(): pass\n",
+        encoding="utf-8",
+    )
+    (source / "app.py").write_text(
+        "from fastapi import FastAPI\n"
+        "app = FastAPI()\n"
+        '@app.get("/health")\n'
+        "def health():\n"
+        "    return {}\n",
+        encoding="utf-8",
+    )
+
+    service = make_service(tmp_path)
+    repository = service.register_repository(name="Relink Leaves", url=str(source))
+    summary = service.analyze_repository(repository.id)
+    graph = service.candidate_graph(repository.id, summary.analysis_run.id)
+    source_capability = graph.abilities[0].capabilities[0]
+    target_capability = graph.abilities[0].capabilities[1]
+    feature = source_capability.features[0]
+    evidence = source_capability.evidence[0]
+
+    service.relink_candidate_feature(
+        repository.id,
+        summary.analysis_run.id,
+        feature.id,
+        target_capability_id=target_capability.id,
+    )
+    service.relink_candidate_evidence(
+        repository.id,
+        summary.analysis_run.id,
+        evidence.id,
+        target_capability_id=target_capability.id,
+    )
+    ability_map = service.approve_candidate_graph(repository.id, summary.analysis_run.id)
+
+    approved_capabilities = {
+        capability.name: capability for capability in ability_map.abilities[0].capabilities
+    }
+    assert approved_capabilities[source_capability.name].features == []
+    assert feature.name in {
+        item.name for item in approved_capabilities[target_capability.name].features
+    }
+    assert evidence.reference in {
+        item.reference for item in approved_capabilities[target_capability.name].evidence
+    }
+
+
 def test_analyze_repository_failure_is_recorded(tmp_path):
     service = make_service(tmp_path)
     repository = service.register_repository(

tests/test_web_api.py

@@ -371,3 +371,75 @@ def test_api_rejects_candidate_capability_feature_and_evidence(tmp_path):
         )
     finally:
         app.dependency_overrides.clear()
+
+
+def test_api_relinks_candidate_feature_and_evidence(tmp_path):
+    source = tmp_path / "repo"
+    source.mkdir()
+    (source / "README.md").write_text("# API Relink Leaves\n", encoding="utf-8")
+    (source / "requirements.txt").write_text("fastapi\n", encoding="utf-8")
+    (source / "tests").mkdir()
+    (source / "tests" / "test_status.py").write_text(
+        "def test_status(): pass\n",
+        encoding="utf-8",
+    )
+    (source / "app.py").write_text(
+        "from fastapi import FastAPI\n"
+        "app = FastAPI()\n"
+        '@app.get("/status")\n'
+        "def status():\n"
+        "    return {}\n",
+        encoding="utf-8",
+    )
+
+    def override_settings():
+        return Settings(
+            database_path=str(tmp_path / "api-relink.sqlite3"),
+            checkout_root=str(tmp_path / "api-relink-checkouts"),
+        )
+
+    app.dependency_overrides[get_settings] = override_settings
+    client = TestClient(app)
+    try:
+        repository_response = client.post(
+            "/repos",
+            json={"name": "API Relink Leaves", "url": str(source)},
+        )
+        repository_id = repository_response.json()["id"]
+        run_response = client.post(f"/repos/{repository_id}/analysis-runs", json={})
+        run_id = run_response.json()["analysis_run"]["id"]
+        graph_response = client.get(
+            f"/repos/{repository_id}/analysis-runs/{run_id}/candidate-graph"
+        )
+        capabilities = graph_response.json()["abilities"][0]["capabilities"]
+        source_capability = capabilities[0]
+        target_capability = capabilities[1]
+        feature_id = source_capability["features"][0]["id"]
+        evidence_id = source_capability["evidence"][0]["id"]
+
+        feature_response = client.post(
+            f"/repos/{repository_id}/analysis-runs/{run_id}"
+            f"/candidate-features/{feature_id}/relink",
+            json={
+                "target_capability_id": target_capability["id"],
+                "notes": "Move feature",
+            },
+        )
+        assert feature_response.status_code == 200
+        relinked_capabilities = feature_response.json()["abilities"][0]["capabilities"]
+        assert relinked_capabilities[0]["features"] == []
+        assert relinked_capabilities[1]["features"][0]["id"] == feature_id
+
+        evidence_response = client.post(
+            f"/repos/{repository_id}/analysis-runs/{run_id}"
+            f"/candidate-evidence/{evidence_id}/relink",
+            json={
+                "target_capability_id": target_capability["id"],
+                "notes": "Move evidence",
+            },
+        )
+        assert evidence_response.status_code == 200
+        relinked_capabilities = evidence_response.json()["abilities"][0]["capabilities"]
+        assert relinked_capabilities[1]["evidence"][0]["id"] == evidence_id
+    finally:
+        app.dependency_overrides.clear()