Method vault_delete

atomic-repository/src/repository/vault.rs:368–431

Delete a vault entry by path. Also updates the manifest.

(&self, path: &str)

    /// Delete a vault entry by path. Also updates the manifest.
    pub fn vault_delete(&self, path: &str) -> Result<bool, RepositoryError> {
        let mut txn = self
            .pristine
            .write_txn()
            .map_err(|e| RepositoryError::Database(e.to_string()))?;
        use atomic_core::pristine::{EmbeddingsMutTxnT, KgMutTxnT, VaultMutTxnT, VaultTxnT};

        let previous_entry = txn
            .get_vault_entry(path)
            .map_err(|e| RepositoryError::Database(e.to_string()))?;
        let now = chrono::Utc::now().to_rfc3339();
        let cascade_updates = if let Some(previous_entry) = previous_entry.as_ref() {
            unlink_goal_from_intent_entries(&mut txn, path, previous_entry, &now)?
        } else {
            Vec::new()
        };
        let entry_type = previous_entry
            .as_ref()
            .map(|entry| entry.entry_type)
            .unwrap_or_else(|| infer_entry_type(path));

        txn.init_kg()
            .map_err(|e| RepositoryError::Database(e.to_string()))?;

        let existed = txn
            .del_vault_entry(path)
            .map_err(|e| RepositoryError::Database(e.to_string()))?;

        // KG and embeddings are derived from the Vault entry. Clean both even
        // if the source entry is already missing so a retry repairs stale data.
        let node_id = super::vault_triples::entry_subject(path, entry_type);
        // Remove projected child nodes (tasks, acceptance criteria, scope,
        // constraints) before the subject so an intent deletion does not orphan
        // them or their SATISFIES/TOUCHES edges. No-op for non-intent subjects.
        super::vault_triples::delete_intent_child_nodes(&mut txn, &node_id)?;
        txn.del_kg_node(&node_id)
            .map_err(|e| RepositoryError::Database(e.to_string()))?;
        txn.del_embeddings(path)
            .map_err(|e| RepositoryError::Database(e.to_string()))?;

        if existed {
            let mut manifest = txn
                .get_vault_manifest()
                .map_err(|e| RepositoryError::Database(e.to_string()))?;
            update_manifest_for_delete(&mut manifest, path, previous_entry.as_ref(), &now);
            apply_cascaded_intent_manifest_updates(&mut manifest, &cascade_updates, &now);
            txn.put_vault_manifest(&manifest)
                .map_err(|e| RepositoryError::Database(e.to_string()))?;
        }

        txn.commit()
            .map_err(|e| RepositoryError::Database(e.to_string()))?;
        for update in cascade_updates {
            self.vault_auto_index(&update.path);
            if let Err(error) = self.vault_materialize(&update.path) {
                log::warn!(
                    "Failed to materialize Intent '{}' after Goal deletion: {}",
                    update.path,