service logic for facts, chunks, candidates, and current-approved-vs-target comparison

src/repo_registry/storage/sqlite.py

@@ -1512,6 +1512,99 @@ class RegistryStore:
             row_id=evidence_id,
         )
 
+    def replace_approved_from_candidate_graph(
+        self,
+        repository_id: int,
+        graph: CandidateGraph,
+    ) -> None:
+        if graph.repository.id != repository_id:
+            raise NotFoundError(
+                f"candidate graph for repository {graph.repository.id} does not match "
+                f"repository {repository_id}"
+            )
+        with self.connect() as connection:
+            connection.execute(
+                "DELETE FROM approved_abilities WHERE repository_id = ?",
+                (repository_id,),
+            )
+            for ability in graph.abilities:
+                if ability.status not in {"candidate", "approved"}:
+                    continue
+                ability_cursor = connection.execute(
+                    """
+                    INSERT INTO approved_abilities
+                      (repository_id, name, description, confidence)
+                    VALUES (?, ?, ?, ?)
+                    """,
+                    (
+                        repository_id,
+                        ability.name,
+                        ability.description,
+                        ability.confidence,
+                    ),
+                )
+                approved_ability_id = int(ability_cursor.lastrowid)
+                for capability in ability.capabilities:
+                    if capability.status not in {"candidate", "approved"}:
+                        continue
+                    capability_cursor = connection.execute(
+                        """
+                        INSERT INTO approved_capabilities
+                          (repository_id, ability_id, name, description, inputs, outputs,
+                           confidence)
+                        VALUES (?, ?, ?, ?, ?, ?, ?)
+                        """,
+                        (
+                            repository_id,
+                            approved_ability_id,
+                            capability.name,
+                            capability.description,
+                            json.dumps(capability.inputs),
+                            json.dumps(capability.outputs),
+                            capability.confidence,
+                        ),
+                    )
+                    approved_capability_id = int(capability_cursor.lastrowid)
+                    for feature in capability.features:
+                        if feature.status not in {"candidate", "approved"}:
+                            continue
+                        connection.execute(
+                            """
+                            INSERT INTO approved_features
+                              (repository_id, capability_id, name, type, location,
+                               confidence, source_refs)
+                            VALUES (?, ?, ?, ?, ?, ?, ?)
+                            """,
+                            (
+                                repository_id,
+                                approved_capability_id,
+                                feature.name,
+                                feature.type,
+                                feature.location,
+                                feature.confidence,
+                                self._source_refs_to_json(feature.source_refs),
+                            ),
+                        )
+                    for evidence in capability.evidence:
+                        if evidence.status not in {"candidate", "approved"}:
+                            continue
+                        connection.execute(
+                            """
+                            INSERT INTO approved_evidence
+                              (repository_id, capability_id, type, reference, strength,
+                               source_refs)
+                            VALUES (?, ?, ?, ?, ?, ?)
+                            """,
+                            (
+                                repository_id,
+                                approved_capability_id,
+                                evidence.type,
+                                evidence.reference,
+                                evidence.strength,
+                                self._source_refs_to_json(evidence.source_refs),
+                            ),
+                        )
+
     def get_ability_map(self, repository_id: int) -> RepositoryAbilityMap:
         repository = self.get_repository(repository_id)
         with self.connect() as connection: