diff --git a/README.md b/README.md index 2f026a9a..26c4a1c0 100644 --- a/README.md +++ b/README.md @@ -252,6 +252,8 @@ Atomic's CRDT semantic layer (Trunk → Branch → Leaf) tracks changes at the t Every repository has a **vault** — a versioned knowledge store that persists what your team and your agents learn across sessions. Goals, decisions, architecture context, and working memory all live in `.vault/` as structured markdown with cryptographic provenance. +Vault **writes** — `atomic vault goal start/stop/resume`, `atomic vault materialize`, `atomic vault sync`, `atomic intent new/update/delete/link/attest`, and `atomic memory new/write/attest` — create the vault on first use if it does not exist yet. Reads never mutate the checkout: on a repository without a vault they return empty/not-found, so read-only checkouts keep working. `atomic vault init` is only needed when you want the defaults created and recorded up front, for example after `atomic init --no-vault`. + ```bash # Initialize the vault in your repo atomic vault init diff --git a/atomic-cli/src/commands/intent/attest.rs b/atomic-cli/src/commands/intent/attest.rs index d80311cd..e25c4c02 100644 --- a/atomic-cli/src/commands/intent/attest.rs +++ b/atomic-cli/src/commands/intent/attest.rs @@ -52,7 +52,7 @@ impl Command for IntentAttest { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let inputs = bridge::read_intent(&repo, &self.id)?; diff --git a/atomic-cli/src/commands/intent/delete.rs b/atomic-cli/src/commands/intent/delete.rs index d07e4463..b98ed58d 100644 --- a/atomic-cli/src/commands/intent/delete.rs +++ b/atomic-cli/src/commands/intent/delete.rs @@ -42,7 +42,7 @@ impl Command for IntentDelete { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; if !self.force { // Check that the intent exists before prompting. diff --git a/atomic-cli/src/commands/intent/link.rs b/atomic-cli/src/commands/intent/link.rs index 009a9130..baaf17a1 100644 --- a/atomic-cli/src/commands/intent/link.rs +++ b/atomic-cli/src/commands/intent/link.rs @@ -35,7 +35,7 @@ impl Command for IntentLink { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; repo.vault_intent_link(&self.id, &self.goal) .map_err(CliError::Repository)?; diff --git a/atomic-cli/src/commands/intent/new.rs b/atomic-cli/src/commands/intent/new.rs index 2eccd534..16c4bacc 100644 --- a/atomic-cli/src/commands/intent/new.rs +++ b/atomic-cli/src/commands/intent/new.rs @@ -155,7 +155,7 @@ impl Command for IntentNew { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let (created, kind) = create_intent(&repo, &self.title, &self.kind, self.review.as_deref())?; diff --git a/atomic-cli/src/commands/intent/update.rs b/atomic-cli/src/commands/intent/update.rs index 34cc4c18..702d67dc 100644 --- a/atomic-cli/src/commands/intent/update.rs +++ b/atomic-cli/src/commands/intent/update.rs @@ -153,7 +153,7 @@ impl Command for IntentUpdate { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let content = self.resolve_body()?; if self.status.is_none() diff --git a/atomic-cli/src/commands/intent/validate.rs b/atomic-cli/src/commands/intent/validate.rs index 78e223f3..0cb27418 100644 --- a/atomic-cli/src/commands/intent/validate.rs +++ b/atomic-cli/src/commands/intent/validate.rs @@ -56,7 +56,8 @@ impl Command for IntentValidate { })? } else { let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_intent(&repo, &self.id_or_path)?; match bridge::load_attestation(&repo, &self.id_or_path, &inputs)? { bridge::Attestation::Fresh(node) => *node, diff --git a/atomic-cli/src/commands/intent/verify.rs b/atomic-cli/src/commands/intent/verify.rs index 5be735da..eea408b9 100644 --- a/atomic-cli/src/commands/intent/verify.rs +++ b/atomic-cli/src/commands/intent/verify.rs @@ -81,7 +81,8 @@ impl Command for IntentVerify { impl IntentVerify { async fn execute(&self) -> CliResult<()> { let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_intent(&repo, &self.id)?; let node = match bridge::load_attestation(&repo, &self.id, &inputs)? { diff --git a/atomic-cli/src/commands/memory/attest.rs b/atomic-cli/src/commands/memory/attest.rs index 3e51bb9e..6cac0e4f 100644 --- a/atomic-cli/src/commands/memory/attest.rs +++ b/atomic-cli/src/commands/memory/attest.rs @@ -38,7 +38,7 @@ impl Command for MemoryAttest { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let inputs = bridge::read_memory(&repo, &self.id)?; diff --git a/atomic-cli/src/commands/memory/list.rs b/atomic-cli/src/commands/memory/list.rs index 102b8feb..60cd15ad 100644 --- a/atomic-cli/src/commands/memory/list.rs +++ b/atomic-cli/src/commands/memory/list.rs @@ -422,7 +422,8 @@ impl Command for MemoryList { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let verifier = resolve_verifier(&self.identity)?; diff --git a/atomic-cli/src/commands/memory/new.rs b/atomic-cli/src/commands/memory/new.rs index 1639baec..9f23c726 100644 --- a/atomic-cli/src/commands/memory/new.rs +++ b/atomic-cli/src/commands/memory/new.rs @@ -111,7 +111,7 @@ impl Command for MemoryNew { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let id = self.id.clone().unwrap_or_else(generate_ulid_lowercased); let vault_path = bridge::normalize_memory_path(&id); diff --git a/atomic-cli/src/commands/memory/show.rs b/atomic-cli/src/commands/memory/show.rs index 4f2c92d2..b320794d 100644 --- a/atomic-cli/src/commands/memory/show.rs +++ b/atomic-cli/src/commands/memory/show.rs @@ -85,7 +85,8 @@ impl Command for MemoryShow { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_memory(&repo, &self.id)?; let attestation = bridge::load_attestation(&repo, &self.id, &inputs)?; diff --git a/atomic-cli/src/commands/memory/validate.rs b/atomic-cli/src/commands/memory/validate.rs index 59ad658b..fe761848 100644 --- a/atomic-cli/src/commands/memory/validate.rs +++ b/atomic-cli/src/commands/memory/validate.rs @@ -55,7 +55,8 @@ impl Command for MemoryValidate { })? } else { let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_memory(&repo, &self.id_or_path)?; match bridge::load_attestation(&repo, &self.id_or_path, &inputs)? { bridge::Attestation::Fresh(node) => *node, diff --git a/atomic-cli/src/commands/memory/verify.rs b/atomic-cli/src/commands/memory/verify.rs index a0e9f01c..4f80300c 100644 --- a/atomic-cli/src/commands/memory/verify.rs +++ b/atomic-cli/src/commands/memory/verify.rs @@ -34,7 +34,8 @@ impl Command for MemoryVerify { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_memory(&repo, &self.id)?; let node = match bridge::load_attestation(&repo, &self.id, &inputs)? { diff --git a/atomic-cli/src/commands/memory/write.rs b/atomic-cli/src/commands/memory/write.rs index be0576d8..fae7bc35 100644 --- a/atomic-cli/src/commands/memory/write.rs +++ b/atomic-cli/src/commands/memory/write.rs @@ -45,7 +45,7 @@ impl Command for MemoryWrite { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; // Freeform body from stdin — no lift/gate; this is the raw path. use std::io::Read; diff --git a/atomic-cli/src/commands/mod.rs b/atomic-cli/src/commands/mod.rs index 5d76c4cc..a36f4bac 100644 --- a/atomic-cli/src/commands/mod.rs +++ b/atomic-cli/src/commands/mod.rs @@ -417,6 +417,38 @@ pub(crate) fn open_readonly_repository( Repository::open_readonly_wait(path, std::time::Duration::from_secs(10)) } +/// Open the repository at `root` for a command that writes to the vault, +/// creating the vault when it does not exist yet. +/// +/// Vault *writes* — `goal start/stop/resume`, `materialize`, `sync`, +/// `intent new/update/delete/link/attest`, `memory new/write/attest` — open +/// through this helper so a repository created without a vault +/// (`atomic init --no-vault`, or one that never ran `atomic vault init`) +/// works on first use instead of failing with "Vault not initialized". +/// +/// Read-only commands deliberately do NOT use this helper: they open with +/// [`open_readonly_repository`], so a read never mutates a checkout — an +/// uninitialized vault reads as empty/not-found, and the first write +/// initializes it. +/// +/// The initialization is [`Repository::ensure_vault`], the same idempotent +/// path `atomic vault init` uses. It runs at most once: an existing vault is +/// never re-initialized. +pub fn open_repository_with_vault(root: &Path) -> CliResult { + let repo = Repository::open(root).map_err(CliError::from)?; + ensure_vault_exists(&repo)?; + Ok(repo) +} + +/// One-time implicit vault initialization, announced on stderr so `--json` +/// output stays parseable. +fn ensure_vault_exists(repo: &Repository) -> CliResult<()> { + if repo.ensure_vault().map_err(CliError::from)? { + eprintln!("Initialized vault at {}", repo.vault_dir().display()); + } + Ok(()) +} + /// Open a repository or return a user-friendly error. /// /// This is a convenience wrapper around [`open_repository`] that provides diff --git a/atomic-cli/src/commands/vault/goal.rs b/atomic-cli/src/commands/vault/goal.rs index c1ca4cbc..15dc1afc 100644 --- a/atomic-cli/src/commands/vault/goal.rs +++ b/atomic-cli/src/commands/vault/goal.rs @@ -180,7 +180,7 @@ impl Command for GoalStart { return Ok(()); } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let result = repo .vault_goal_start(GoalStartOptions { @@ -230,7 +230,7 @@ impl Command for GoalStop { return Ok(()); } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; // Find the goal to stop let goal_name = match &self.goal { @@ -291,7 +291,7 @@ impl Command for GoalResume { return Ok(()); } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let info = repo .vault_goal_resume(&self.goal) @@ -387,7 +387,8 @@ impl Command for GoalList { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let filter = if self.status == "all" { Some("all") @@ -434,7 +435,8 @@ impl Command for GoalShow { return Ok(()); } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let entry = repo .vault_goal_show(&self.goal) diff --git a/atomic-cli/src/commands/vault/list.rs b/atomic-cli/src/commands/vault/list.rs index 9ffabd3d..5fbcbfa3 100644 --- a/atomic-cli/src/commands/vault/list.rs +++ b/atomic-cli/src/commands/vault/list.rs @@ -121,7 +121,8 @@ impl Command for List { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let type_filter = self.r#type.as_deref().and_then(VaultEntryType::parse); let prefix = self.prefix.as_deref().unwrap_or(""); diff --git a/atomic-cli/src/commands/vault/materialize.rs b/atomic-cli/src/commands/vault/materialize.rs index c9540675..0be2a808 100644 --- a/atomic-cli/src/commands/vault/materialize.rs +++ b/atomic-cli/src/commands/vault/materialize.rs @@ -55,7 +55,7 @@ impl Command for Materialize { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; if let Some(ref path) = self.path { repo.vault_materialize(path).map_err(CliError::Repository)?; diff --git a/atomic-cli/src/commands/vault/summaries.rs b/atomic-cli/src/commands/vault/summaries.rs index 805454bd..8dfd1372 100644 --- a/atomic-cli/src/commands/vault/summaries.rs +++ b/atomic-cli/src/commands/vault/summaries.rs @@ -67,7 +67,8 @@ impl Command for Summaries { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let prefix = match &self.goal { Some(name) => format!("goals/{}/", name), diff --git a/atomic-cli/src/commands/vault/sync.rs b/atomic-cli/src/commands/vault/sync.rs index 6b87a94d..00525ed3 100644 --- a/atomic-cli/src/commands/vault/sync.rs +++ b/atomic-cli/src/commands/vault/sync.rs @@ -43,7 +43,7 @@ impl Command for Sync { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let updated = repo .vault_record_working_copy() diff --git a/atomic-cli/tests/it/main.rs b/atomic-cli/tests/it/main.rs index d98588ff..28e6aae3 100644 --- a/atomic-cli/tests/it/main.rs +++ b/atomic-cli/tests/it/main.rs @@ -81,6 +81,7 @@ mod session_integration_test; mod shim_census_cb13a_test; mod status_git_cb11a_test; mod unrecord_integration_test; +mod vault_auto_init_test; mod vault_context_integration_test; mod view_confirmation_integration_test; mod working_copy_preservation_test; diff --git a/atomic-cli/tests/it/vault_auto_init_test.rs b/atomic-cli/tests/it/vault_auto_init_test.rs new file mode 100644 index 00000000..3c72f64e --- /dev/null +++ b/atomic-cli/tests/it/vault_auto_init_test.rs @@ -0,0 +1,166 @@ +//! Vault-facing commands initialize the vault on first use. +//! +//! `atomic init --no-vault` is the repository that deliberately carries no +//! vault. The vault families (`atomic vault`, `atomic intent`, `atomic memory`) +//! must create it themselves instead of failing with +//! "Vault not initialized. Run `atomic vault init` first." +#![cfg(not(windows))] + +use std::path::Path; +use std::process::{Command, Output}; + +use tempfile::TempDir; + +const ATOMIC_BIN: &str = env!("CARGO_BIN_EXE_atomic"); + +fn atomic(repo_dir: &Path, home_dir: &Path, args: &[&str]) -> Output { + Command::new(ATOMIC_BIN) + .args(args) + .current_dir(repo_dir) + .env("HOME", home_dir) + .env_remove("ATOMIC_SERVICE") + .env_remove("ATOMIC_RPC") + .output() + .expect("run atomic") +} + +fn success(output: Output) -> String { + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8(output.stdout).unwrap() +} + +/// A repository created without a vault — the state every vault command must +/// recover from. +fn vaultless_repo() -> (TempDir, TempDir) { + let repo = TempDir::new().unwrap(); + let home = TempDir::new().unwrap(); + let init = atomic(repo.path(), home.path(), &["init", "--no-vault"]); + assert!( + init.status.success(), + "init --no-vault failed: {}", + String::from_utf8_lossy(&init.stderr) + ); + assert!(!repo.path().join(".vault").exists()); + (repo, home) +} + +/// Permit reads, deny database writes — the read-only checkout state a +/// CI mount or a `chmod`ed tree presents. +fn make_database_read_only(repo: &Path) { + let db = repo.join(".atomic/atomic.redb"); + let mut permissions = std::fs::metadata(&db).unwrap().permissions(); + permissions.set_readonly(true); + std::fs::set_permissions(&db, permissions).unwrap(); +} + +fn intents_written(repo: &Path) -> bool { + std::fs::read_dir(repo.join(".vault/intents")) + .map(|mut entries| { + entries.any(|entry| { + entry + .map(|e| e.path().join("intent.md").is_file()) + .unwrap_or(false) + }) + }) + .unwrap_or(false) +} + +#[test] +fn intent_new_initializes_the_vault_and_the_next_command_does_not() { + let (repo, home) = vaultless_repo(); + + let created = success(atomic( + repo.path(), + home.path(), + &["intent", "new", "First intent"], + )); + assert!(created.contains("Created intent"), "{created}"); + assert!(repo.path().join(".vault/intents").exists()); + assert!( + intents_written(repo.path()), + "the intent's markdown entry must exist in .vault/intents" + ); + + // Reading the vault afterwards works and never re-initializes it: an + // explicit init reports the vault as already present. + let listed = success(atomic(repo.path(), home.path(), &["intent", "list"])); + assert!(listed.contains("backlog"), "{listed}"); + let init = success(atomic(repo.path(), home.path(), &["vault", "init"])); + assert!(init.contains("already initialized"), "{init}"); +} + +#[test] +fn vault_goal_and_materialize_initialize_before_running() { + let (repo, home) = vaultless_repo(); + + let started = success(atomic( + repo.path(), + home.path(), + &["vault", "goal", "start"], + )); + assert!(started.contains("Started goal"), "{started}"); + + let materialized = success(atomic(repo.path(), home.path(), &["vault", "materialize"])); + assert!(materialized.contains("Materialized"), "{materialized}"); + + assert!(repo.path().join(".vault/goals").exists()); +} + +#[test] +fn reads_do_not_initialize_the_vault() { + let (repo, home) = vaultless_repo(); + + let listed = success(atomic(repo.path(), home.path(), &["vault", "list"])); + assert!(listed.contains("No vault entries found"), "{listed}"); + let intents = success(atomic(repo.path(), home.path(), &["intent", "list"])); + assert!(intents.contains("No intents found"), "{intents}"); + let memories = success(atomic(repo.path(), home.path(), &["memory", "list"])); + assert!(memories.contains("No memories found"), "{memories}"); + + assert!( + !repo.path().join(".vault").exists(), + "a read must never create the vault" + ); +} + +#[test] +fn read_only_checkout_serves_vault_reads() { + let (repo, home) = vaultless_repo(); + make_database_read_only(repo.path()); + + let listed = success(atomic(repo.path(), home.path(), &["vault", "list"])); + assert!(listed.contains("No vault entries found"), "{listed}"); + assert!(!repo.path().join(".vault").exists()); + + let mut permissions = std::fs::metadata(repo.path().join(".atomic/atomic.redb")) + .unwrap() + .permissions(); + permissions.set_readonly(false); + std::fs::set_permissions(repo.path().join(".atomic/atomic.redb"), permissions).unwrap(); +} + +#[test] +fn memory_new_initializes_the_vault_and_persists_the_memory() { + let (repo, home) = vaultless_repo(); + + let created = success(atomic( + repo.path(), + home.path(), + &[ + "memory", + "new", + "--kind", + "lesson", + "--text", + "Boring designs outlive clever ones.", + ], + )); + assert!(created.contains("Created memory"), "{created}"); + + let listed = success(atomic(repo.path(), home.path(), &["memory", "list"])); + assert!(listed.contains("lesson"), "{listed}"); +} diff --git a/atomic-repository/src/repository/vault.rs b/atomic-repository/src/repository/vault.rs index 73180722..f952e147 100644 --- a/atomic-repository/src/repository/vault.rs +++ b/atomic-repository/src/repository/vault.rs @@ -25,6 +25,28 @@ impl Repository { .map_err(|e| RepositoryError::Database(e.to_string())) } + /// Ensure the vault exists, initializing it on first use. + /// + /// Vault *write* paths call this so a repository created without a vault + /// (`atomic init --no-vault`) still supports vault and intent/memory + /// writes without a manual `atomic vault init`. Read paths never call it: + /// reads must not mutate a checkout, so an uninitialized vault reads as + /// empty/not-found. + /// + /// Initialization is the same idempotent path as + /// [`init_vault`](Self::init_vault): an existing `.vault/` working copy is + /// hydrated from disk and default content is installed only where nothing + /// exists yet. + /// + /// Returns `true` when this call created the vault. + pub fn ensure_vault(&self) -> Result { + if self.has_vault()? { + return Ok(false); + } + self.init_vault()?; + Ok(true) + } + /// Initialize the vault in this repository. /// /// Creates the vault tables in the pristine database and the @@ -1607,6 +1629,21 @@ mod tests { assert!(repo.vault_dir().join("scratch").exists()); } + #[test] + fn test_ensure_vault_initializes_once() { + let dir = tempdir().unwrap(); + let repo = Repository::init(dir.path()).unwrap(); + assert!(!repo.has_vault().unwrap()); + + assert!(repo.ensure_vault().unwrap()); + assert!(repo.has_vault().unwrap()); + assert!(repo.vault_dir().join("memory").exists()); + + // Second call is the no-op path: an initialized vault is never reset. + assert!(!repo.ensure_vault().unwrap()); + assert!(repo.has_vault().unwrap()); + } + #[test] fn test_init_vault_idempotent() { let dir = tempdir().unwrap(); diff --git a/libatomic/src/daemon/services_agent.rs b/libatomic/src/daemon/services_agent.rs index d22d8a3f..9e23300a 100644 --- a/libatomic/src/daemon/services_agent.rs +++ b/libatomic/src/daemon/services_agent.rs @@ -33,7 +33,7 @@ use tonic::{Request, Response, Status}; use super::convert::*; use super::journal_sink::DirectJournalSink; -use super::state::{domain_status, repository_error, DaemonState}; +use super::state::{domain_status, repository_error, DaemonState, RepoHandle}; // --------------------------------------------------------------------------- // VaultService @@ -1196,6 +1196,18 @@ pub(crate) fn response_meta(meta: &Option) -> Option }) } +/// Open the request's repository with its vault guaranteed to exist. +/// +/// Vault-write handlers use this; read handlers open +/// `repository_readonly` directly, so a routed read never initializes the +/// vault or touches a read-only checkout. An existing vault is never +/// re-initialized. +fn vault_repository(handle: &RepoHandle) -> Result { + let repo = handle.repository()?; + repo.ensure_vault().map_err(repository_error)?; + Ok(repo) +} + #[tonic::async_trait] impl vault_service_server::VaultService for VaultImpl { async fn create_vault_entity( @@ -1232,7 +1244,7 @@ impl vault_service_server::VaultService for VaultImpl { let result = tokio::task::spawn_blocking({ let handle = handle_for_task; move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let created = repo .vault_intent_create(IntentCreateOptions { title: title.clone(), @@ -1305,7 +1317,7 @@ impl vault_service_server::VaultService for VaultImpl { let result = tokio::task::spawn_blocking({ let handle = handle_for_task; move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; repo.vault_goal_start(atomic_repository::GoalStartOptions { name: (!title.is_empty()).then_some(title.clone()), developer, @@ -1362,7 +1374,7 @@ impl vault_service_server::VaultService for VaultImpl { let id = id.clone(); let body = body_for_store; move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let mut frontmatter = Map::new(); frontmatter.insert("uid".into(), Value::String(id)); frontmatter.insert("memoryKind".into(), Value::String(memory_kind)); @@ -1449,7 +1461,7 @@ impl vault_service_server::VaultService for VaultImpl { let id = request.id.clone(); let response = tokio::task::spawn_blocking(move || match kind { Kind::Intent => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let mut options = IntentUpdateOptions::default(); match update { UpdateKind::Status(status) => { @@ -1516,7 +1528,7 @@ impl vault_service_server::VaultService for VaultImpl { } Kind::Memory => match update { UpdateKind::Body(body) => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let vault_path = format!("memory/{id}.md"); let entry = repo .vault_retrieve(&vault_path) @@ -1560,7 +1572,7 @@ impl vault_service_server::VaultService for VaultImpl { // `atomic memory write` — the raw store + materialize // (create-or-replace at the named vault path), with the // content hash riding the response. - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let hash = repo .vault_store( &memory_write.path, @@ -1592,7 +1604,7 @@ impl vault_service_server::VaultService for VaultImpl { // `vault goal stop` — the goal to stop (empty = the most // recent active goal) + the promote/discard options. UpdateKind::GoalStop(goal_stop) => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let goal_name = match &goal_stop.goal { Some(name) => name.clone(), None => repo @@ -1640,7 +1652,7 @@ impl vault_service_server::VaultService for VaultImpl { } // `vault goal resume`. UpdateKind::GoalResume(goal_resume) => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let info = repo .vault_goal_resume(&goal_resume.goal) .map_err(repository_error)?; @@ -2379,7 +2391,7 @@ impl vault_service_server::VaultService for VaultImpl { let response = tokio::task::spawn_blocking({ let handle = handle_for_task; move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let synced = repo.vault_record_working_copy().map_err(repository_error)?; Ok::<_, Status>(SyncVaultResponse { entities_synced: synced.len() as u32, @@ -2555,7 +2567,7 @@ impl vault_service_server::VaultService for VaultImpl { let meta = request.meta.clone(); let path = request.path.clone().filter(|path| !path.is_empty()); let (count, materialized_path) = tokio::task::spawn_blocking(move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; match path { Some(path) => { repo.vault_materialize(&path).map_err(repository_error)?; @@ -2594,7 +2606,7 @@ impl vault_service_server::VaultService for VaultImpl { // domain's (vault_intent_delete); the normalized id + removed // file ride the response so the client prints the local report. Kind::Intent => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let result = repo.vault_intent_delete(&id).map_err(repository_error)?; Ok::<_, Status>((result.id, result.intent_file)) } @@ -2641,7 +2653,7 @@ impl vault_service_server::VaultService for VaultImpl { let intent_id = source.id.clone(); let goal_name = target.id.clone(); tokio::task::spawn_blocking(move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; repo.vault_intent_link(&intent_id, &goal_name) .map_err(repository_error)?; Ok::<_, Status>(())