Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
cli: add `ai-memory rename-project` for renaming a wiki project
AkitaOnRails949382527f17
diff --git a/crates/ai-memory-cli/src/cli.rs b/crates/ai-memory-cli/src/cli.rsindex f90f9d00..f90cba99 100644--- a/crates/ai-memory-cli/src/cli.rs+++ b/crates/ai-memory-cli/src/cli.rs@@ -89,6 +89,11 @@ pub enum Command {/// observations, handoffs, embeddings, on-disk wiki files)./// This is irreversible — requires `--confirm`.PurgeProject(PurgeProjectArgs),+ /// Rename a project within its workspace. No files move on disk —+ /// the wiki is flat and pages are differentiated by project_id only.+ /// Useful after renaming the project's directory on disk so the hook+ /// router keeps writing into the same logical project.+ RenameProject(RenameProjectArgs),}/// Arguments for `reorg`.@@ -115,6 +120,24 @@ pub struct PurgeProjectArgs {pub confirm: bool,}+/// Arguments for `rename-project`.+#[derive(Debug, Args)]+pub struct RenameProjectArgs {+ /// Workspace name. Defaults to "default".+ #[arg(long, default_value = "default")]+ pub workspace: String,+ /// Current project name. When omitted, auto-derives from the+ /// basename of the current git repo root (or CWD) — handy when+ /// running `ai-memory rename-project --to new-name` from a dir+ /// that was JUST renamed (the basename will be the new name, so+ /// you'll want to pass --from explicitly in that workflow).+ #[arg(long)]+ pub from: Option<String>,+ /// New project name. Must be non-empty and contain no slashes.+ #[arg(long)]+ pub to: String,+}+/// Arguments for `install-instructions`.#[derive(Debug, Args)]pub struct InstallInstructionsArgs {diff --git a/crates/ai-memory-cli/src/commands/mod.rs b/crates/ai-memory-cli/src/commands/mod.rsindex a1a60809..b320b8cc 100644--- a/crates/ai-memory-cli/src/commands/mod.rs+++ b/crates/ai-memory-cli/src/commands/mod.rs@@ -16,6 +16,7 @@ pub mod install_mcp;pub mod lint;pub mod llm_test;pub mod purge_project;+pub mod rename_project;pub mod render_shared;pub mod reorg;pub mod reset;diff --git a/crates/ai-memory-cli/src/commands/rename_project.rs b/crates/ai-memory-cli/src/commands/rename_project.rsnew file mode 100644index 00000000..5cfd1b5f--- /dev/null+++ b/crates/ai-memory-cli/src/commands/rename_project.rs@@ -0,0 +1,33 @@+//! `ai-memory rename-project` — thin HTTP client for project rename.++use anyhow::Result;++use crate::cli::RenameProjectArgs;+use crate::config::Config;+use crate::http_client::{ServerEndpoint, post_json};++/// Run the `rename-project` subcommand.+///+/// Resolves the current project name (auto-derived from the git repo root+/// when `--from` is omitted), sends the rename request to the server, then+/// prints a human-readable confirmation line.+///+/// # Errors+/// Returns an error when the server is unreachable or returns a non-2xx+/// response (e.g. 404 workspace/project not found, 422 name taken or invalid).+pub async fn run(_config: &Config, args: RenameProjectArgs) -> Result<()> {+ let endpoint = ServerEndpoint::from_env();+ let from = super::resolve_project_name(args.from.as_deref())?;+ let body = serde_json::json!({+ "workspace": args.workspace,+ "from": from,+ "to": args.to,+ });+ let summary: serde_json::Value = post_json(&endpoint, "/admin/rename-project", &body).await?;+ let pages = summary["pages"].as_u64().unwrap_or(0);+ println!(+ "Renamed {}/{} → {}/{} ({} pages now under the new name).",+ args.workspace, from, args.workspace, args.to, pages+ );+ Ok(())+}diff --git a/crates/ai-memory-cli/src/main.rs b/crates/ai-memory-cli/src/main.rsindex 08a095aa..542d1e3a 100644--- a/crates/ai-memory-cli/src/main.rs+++ b/crates/ai-memory-cli/src/main.rs@@ -61,5 +61,6 @@ async fn main() -> Result<()> {Command::InstallInstructions(args) => commands::install_instructions::run(&config, args),Command::Reorg(args) => commands::reorg::run(&config, args).await,Command::PurgeProject(args) => commands::purge_project::run(&config, args).await,+ Command::RenameProject(args) => commands::rename_project::run(&config, args).await,}}diff --git a/crates/ai-memory-mcp/src/admin.rs b/crates/ai-memory-mcp/src/admin.rsindex ec7c0b18..34986a14 100644--- a/crates/ai-memory-mcp/src/admin.rs+++ b/crates/ai-memory-mcp/src/admin.rs@@ -1,15 +1,17 @@//! Admin HTTP routes — state-touching operations invoked by the CLI//! over plain HTTP (not MCP). Currently exposes://!-//! - `POST /admin/bootstrap` — ingest a pre-collected source bundle+//! - `POST /admin/bootstrap` — ingest a pre-collected source bundle//! into seed wiki pages via the configured LLM provider.-//! - `GET /admin/status` — lifetime counts + server data-dir info.-//! - `GET /admin/search?q=` — FTS5 hits against the wiki index.-//! - `POST /admin/reorg` — retro-fit sessions to per-cwd projects.-//! - `POST /admin/lint` — run the M8 lint pass.-//! - `POST /admin/forget-sweep` — run the M8 retention sweep.-//! - `POST /admin/embed` — backfill embeddings for latest pages.-//! - `POST /admin/commit` — stage + commit the wiki tree via git.+//! - `GET /admin/status` — lifetime counts + server data-dir info.+//! - `GET /admin/search?q=` — FTS5 hits against the wiki index.+//! - `POST /admin/reorg` — retro-fit sessions to per-cwd projects.+//! - `POST /admin/lint` — run the M8 lint pass.+//! - `POST /admin/forget-sweep` — run the M8 retention sweep.+//! - `POST /admin/embed` — backfill embeddings for latest pages.+//! - `POST /admin/commit` — stage + commit the wiki tree via git.+//! - `POST /admin/purge-project` — delete a project and all its data.+//! - `POST /admin/rename-project` — rename a project (column-only; no files move).//!//! The CLI is responsible for filesystem access (collecting sources from//! the project repo, rendering output for humans); the server is@@ -97,6 +99,7 @@ fn default_max_input_tokens() -> usize {/// - `POST /admin/embed`/// - `POST /admin/commit`/// - `POST /admin/purge-project`+/// - `POST /admin/rename-project`pub fn admin_router(state: AdminState) -> Router {Router::new().route("/admin/bootstrap", post(handle_bootstrap))@@ -108,6 +111,7 @@ pub fn admin_router(state: AdminState) -> Router {.route("/admin/embed", post(handle_embed)).route("/admin/commit", post(handle_commit)).route("/admin/purge-project", post(handle_purge_project))+ .route("/admin/rename-project", post(handle_rename_project)).with_state(Arc::new(state))}@@ -989,3 +993,131 @@ async fn handle_purge_project(Json(serde_json::to_value(&report).unwrap_or_else(|_| serde_json::json!({}))),)}++// ---------------------------------------------------------------------+// rename-project+// ---------------------------------------------------------------------++/// JSON request body for `POST /admin/rename-project`.+#[derive(Deserialize)]+struct RenameProjectRequest {+ /// Workspace name (must exist; we don't auto-create on rename).+ workspace: String,+ /// Current project name.+ from: String,+ /// New project name. Must be non-empty, no slashes.+ to: String,+}++/// Wire-format summary returned by `POST /admin/rename-project`.+#[derive(Debug, Serialize)]+pub struct RenameProjectSummary {+ /// Workspace name.+ pub workspace: String,+ /// Previous project name.+ pub from: String,+ /// New project name.+ pub to: String,+ /// Number of `is_latest=1` pages now under the renamed project.+ /// No files move — this is purely an informational count.+ pub pages: u64,+}++async fn handle_rename_project(+ State(state): State<Arc<AdminState>>,+ Json(req): Json<RenameProjectRequest>,+) -> impl IntoResponse {+ // Step 1: look up workspace; 404 if absent.+ let ws_id = match state.reader.find_workspace(req.workspace.clone()).await {+ Ok(Some(id)) => id,+ Ok(None) => {+ return (+ StatusCode::NOT_FOUND,+ Json(serde_json::json!({+ "error": format!("workspace '{}' not found", req.workspace)+ })),+ );+ }+ Err(e) => {+ return (+ StatusCode::INTERNAL_SERVER_ERROR,+ Json(serde_json::json!({ "error": e.to_string() })),+ );+ }+ };++ // Step 2: look up the source project; 404 if absent.+ let proj_id = match state.reader.find_project(ws_id, req.from.clone()).await {+ Ok(Some(id)) => id,+ Ok(None) => {+ return (+ StatusCode::NOT_FOUND,+ Json(serde_json::json!({+ "error": format!(+ "project '{}' not found in workspace '{}'",+ req.from, req.workspace+ )+ })),+ );+ }+ Err(e) => {+ return (+ StatusCode::INTERNAL_SERVER_ERROR,+ Json(serde_json::json!({ "error": e.to_string() })),+ );+ }+ };++ // Step 3: execute the rename. The writer validates the name and+ // returns ProjectNameTaken / InvalidProjectName on conflicts.+ if let Err(e) = state+ .writer+ .rename_project(ws_id, proj_id, req.to.clone())+ .await+ {+ let status = match &e {+ StoreError::ProjectNameTaken(_) | StoreError::InvalidProjectName(_) => {+ StatusCode::UNPROCESSABLE_ENTITY+ }+ _ => StatusCode::INTERNAL_SERVER_ERROR,+ };+ return (status, Json(serde_json::json!({ "error": e.to_string() })));+ }++ // Step 4: count is_latest pages that now belong to the renamed project.+ // COUNT(*) always produces a row, so no optional() needed. We pass the+ // 16-byte project id as a plain &[u8] slice to avoid importing rusqlite+ // (not a direct dependency of this crate).+ let pid_bytes = *proj_id.as_bytes();+ let pages = match state+ .reader+ .with_conn(move |conn| {+ let n: i64 = conn.query_row(+ "SELECT COUNT(*) FROM pages WHERE project_id = ?1 AND is_latest = 1",+ [&pid_bytes[..]],+ |row| row.get(0),+ )?;+ Ok(u64::try_from(n).unwrap_or(0))+ })+ .await+ {+ Ok(n) => n,+ Err(e) => {+ return (+ StatusCode::INTERNAL_SERVER_ERROR,+ Json(serde_json::json!({ "error": e.to_string() })),+ );+ }+ };++ let summary = RenameProjectSummary {+ workspace: req.workspace,+ from: req.from,+ to: req.to,+ pages,+ };+ (+ StatusCode::OK,+ Json(serde_json::to_value(&summary).unwrap_or_else(|_| serde_json::json!({}))),+ )+}diff --git a/crates/ai-memory-mcp/tests/admin_rename.rs b/crates/ai-memory-mcp/tests/admin_rename.rsnew file mode 100644index 00000000..eac88766--- /dev/null+++ b/crates/ai-memory-mcp/tests/admin_rename.rs@@ -0,0 +1,339 @@+//! Integration tests for `POST /admin/rename-project`.+//!+//! Follows the same pattern as `admin_purge.rs`: build a real+//! [`AdminState`] over a tmpdir-backed store + wiki, drive the router+//! with `tower::ServiceExt::oneshot`.++use ai_memory_core::{PagePath, Tier};+use ai_memory_mcp::{AdminState, admin_router};+use ai_memory_store::{DecayParams, Store};+use ai_memory_wiki::{Wiki, WritePageRequest};+use axum::body::Body;+use axum::http::{Request, StatusCode};+use serde_json::json;+use tempfile::TempDir;+use tower::ServiceExt;++// ---------------------------------------------------------------------------+// Helpers+// ---------------------------------------------------------------------------++async fn make_state(tmp: &TempDir) -> (AdminState, Store) {+ let store = Store::open(tmp.path()).unwrap();+ let wiki = Wiki::new(tmp.path(), store.writer.clone()).unwrap();+ let db_path = store.db_path().to_path_buf();+ let state = AdminState {+ writer: store.writer.clone(),+ reader: store.reader.clone(),+ wiki,+ llm: None,+ embedder: None,+ decay_params: DecayParams::default(),+ data_dir: tmp.path().to_path_buf(),+ db_path,+ bind: "127.0.0.1:0".to_string(),+ };+ (state, store)+}++async fn body_json(resp: axum::response::Response) -> serde_json::Value {+ let bytes = axum::body::to_bytes(resp.into_body(), usize::MAX)+ .await+ .unwrap();+ serde_json::from_slice(&bytes).unwrap_or(serde_json::Value::Null)+}++async fn post(state: AdminState, uri: &str, body: serde_json::Value) -> axum::response::Response {+ let router = admin_router(state);+ let req = Request::builder()+ .method("POST")+ .uri(uri)+ .header("content-type", "application/json")+ .body(Body::from(serde_json::to_vec(&body).unwrap()))+ .unwrap();+ router.oneshot(req).await.unwrap()+}++/// Seed `default/old-name` with one page. Returns the page path.+async fn seed_page(store: &Store, wiki: &Wiki, project: &str) -> String {+ let ws = store+ .writer+ .get_or_create_workspace("default")+ .await+ .unwrap();+ let proj = store+ .writer+ .get_or_create_project(ws, project, None)+ .await+ .unwrap();+ let path = format!("notes/{project}.md");+ wiki.write_page(WritePageRequest {+ workspace_id: ws,+ project_id: proj,+ path: PagePath::new(path.clone()).unwrap(),+ frontmatter: serde_json::json!({"title": project}),+ body: format!("Content for {project}."),+ tier: Tier::Semantic,+ pinned: false,+ title: Some(project.into()),+ })+ .await+ .unwrap();+ path+}++// ---------------------------------------------------------------------------+// Tests+// ---------------------------------------------------------------------------++/// Happy path: seed `default/old-name`, rename to `new-name`, assert 200+/// and that `pages=1`.+#[tokio::test]+async fn rename_project_happy_path() {+ let tmp = TempDir::new().unwrap();+ let (state, store) = make_state(&tmp).await;++ seed_page(&store, &state.wiki, "old-name").await;++ let resp = post(+ state,+ "/admin/rename-project",+ json!({ "workspace": "default", "from": "old-name", "to": "new-name" }),+ )+ .await;+ assert_eq!(resp.status(), StatusCode::OK, "rename must succeed");++ let body = body_json(resp).await;+ assert_eq!(+ body["from"].as_str().unwrap_or(""),+ "old-name",+ "from field: {body}"+ );+ assert_eq!(+ body["to"].as_str().unwrap_or(""),+ "new-name",+ "to field: {body}"+ );+ assert_eq!(+ body["pages"].as_u64().unwrap_or(0),+ 1,+ "one page under new name: {body}"+ );++ // Verify the project row was actually renamed in the DB.+ let ws = store+ .reader+ .find_workspace("default".to_string())+ .await+ .unwrap()+ .expect("workspace must exist");+ let old_id = store+ .reader+ .find_project(ws, "old-name".to_string())+ .await+ .unwrap();+ assert!(+ old_id.is_none(),+ "old project name must no longer be findable"+ );+ let new_id = store+ .reader+ .find_project(ws, "new-name".to_string())+ .await+ .unwrap();+ assert!(new_id.is_some(), "new project name must be findable");+}++/// Conflict: renaming `default/keep` to `default/doomed` when `doomed`+/// already exists must return 422.+#[tokio::test]+async fn rename_project_conflict_returns_422() {+ let tmp = TempDir::new().unwrap();+ let (state, store) = make_state(&tmp).await;++ seed_page(&store, &state.wiki, "keep").await;+ seed_page(&store, &state.wiki, "doomed").await;++ let resp = post(+ state,+ "/admin/rename-project",+ json!({ "workspace": "default", "from": "keep", "to": "doomed" }),+ )+ .await;+ assert_eq!(+ resp.status(),+ StatusCode::UNPROCESSABLE_ENTITY,+ "name conflict must be 422"+ );++ let body = body_json(resp).await;+ assert!(+ body["error"].as_str().unwrap_or("").contains("doomed"),+ "error must mention the taken name: {body}"+ );+}++/// Source project missing: must return 404.+#[tokio::test]+async fn rename_project_source_missing_returns_404() {+ let tmp = TempDir::new().unwrap();+ let (state, store) = make_state(&tmp).await;++ store+ .writer+ .get_or_create_workspace("default")+ .await+ .unwrap();++ let resp = post(+ state,+ "/admin/rename-project",+ json!({ "workspace": "default", "from": "nonexistent", "to": "anything" }),+ )+ .await;+ assert_eq!(+ resp.status(),+ StatusCode::NOT_FOUND,+ "missing source project must be 404"+ );++ let body = body_json(resp).await;+ assert!(+ body["error"].as_str().unwrap_or("").contains("not found"),+ "error must say 'not found': {body}"+ );+}++/// Workspace missing: must return 404.+#[tokio::test]+async fn rename_project_workspace_missing_returns_404() {+ let tmp = TempDir::new().unwrap();+ let (state, _store) = make_state(&tmp).await;++ let resp = post(+ state,+ "/admin/rename-project",+ json!({ "workspace": "ghost", "from": "any", "to": "other" }),+ )+ .await;+ assert_eq!(+ resp.status(),+ StatusCode::NOT_FOUND,+ "missing workspace must be 404"+ );+}++/// Invalid destination name: empty string must return 422.+#[tokio::test]+async fn rename_project_empty_to_returns_422() {+ let tmp = TempDir::new().unwrap();+ let (state, store) = make_state(&tmp).await;++ seed_page(&store, &state.wiki, "src").await;++ let resp = post(+ state,+ "/admin/rename-project",+ json!({ "workspace": "default", "from": "src", "to": "" }),+ )+ .await;+ assert_eq!(+ resp.status(),+ StatusCode::UNPROCESSABLE_ENTITY,+ "empty name must be 422"+ );+}++/// Invalid destination name: name containing a slash must return 422.+#[tokio::test]+async fn rename_project_slash_in_name_returns_422() {+ let tmp = TempDir::new().unwrap();+ let (state, store) = make_state(&tmp).await;++ seed_page(&store, &state.wiki, "src").await;++ let resp = post(+ state,+ "/admin/rename-project",+ json!({ "workspace": "default", "from": "src", "to": "has/slash" }),+ )+ .await;+ assert_eq!(+ resp.status(),+ StatusCode::UNPROCESSABLE_ENTITY,+ "slash in name must be 422"+ );+}++/// Invalid destination name: all-whitespace must return 422.+#[tokio::test]+async fn rename_project_whitespace_name_returns_422() {+ let tmp = TempDir::new().unwrap();+ let (state, store) = make_state(&tmp).await;++ seed_page(&store, &state.wiki, "src").await;++ let resp = post(+ state,+ "/admin/rename-project",+ json!({ "workspace": "default", "from": "src", "to": " " }),+ )+ .await;+ assert_eq!(+ resp.status(),+ StatusCode::UNPROCESSABLE_ENTITY,+ "whitespace-only name must be 422"+ );+}++/// Data integrity: page seeded before rename is still found via search+/// after rename. The `project_id` foreign key is unchanged; only the+/// name column on the project row changes.+#[tokio::test]+async fn rename_project_pages_still_searchable() {+ let tmp = TempDir::new().unwrap();+ let (state, store) = make_state(&tmp).await;++ seed_page(&store, &state.wiki, "before-rename").await;++ // Build a second AdminState that shares the same writer + reader so+ // the single-writer invariant is preserved. We need two states because+ // axum's `oneshot` consumes the router.+ let state2 = AdminState {+ writer: store.writer.clone(),+ reader: store.reader.clone(),+ wiki: state.wiki.clone(),+ llm: None,+ embedder: None,+ decay_params: DecayParams::default(),+ data_dir: tmp.path().to_path_buf(),+ db_path: store.db_path().to_path_buf(),+ bind: "127.0.0.1:0".to_string(),+ };++ let rename_resp = post(+ state,+ "/admin/rename-project",+ json!({ "workspace": "default", "from": "before-rename", "to": "after-rename" }),+ )+ .await;+ assert_eq!(rename_resp.status(), StatusCode::OK);++ // Search for the page's distinctive content via the shared-state router.+ let router = admin_router(state2);+ // Use percent-encoded double-quotes so FTS5 treats the hyphenated+ // string as a phrase rather than a subtraction expression.+ let search_req = Request::builder()+ .method("GET")+ .uri("/admin/search?q=%22before-rename%22")+ .body(Body::empty())+ .unwrap();+ let search_resp = router.oneshot(search_req).await.unwrap();+ assert_eq!(search_resp.status(), StatusCode::OK);++ let hits = body_json(search_resp).await;+ assert!(+ hits.as_array().is_some_and(|a| !a.is_empty()),+ "page must still be searchable after rename: {hits}"+ );+}diff --git a/crates/ai-memory-store/src/error.rs b/crates/ai-memory-store/src/error.rsindex fb3d7154..7862541c 100644--- a/crates/ai-memory-store/src/error.rs+++ b/crates/ai-memory-store/src/error.rs@@ -38,4 +38,13 @@ pub enum StoreError {/// Re-export of [`MemoryError`] for cross-crate propagation.#[error(transparent)]Memory(#[from] MemoryError),++ /// A project rename was rejected because the destination name is already+ /// in use by another project in the same workspace.+ #[error("project name '{0}' is already taken in this workspace")]+ ProjectNameTaken(String),++ /// The supplied project name failed validation (empty, slash, etc.).+ #[error("invalid project name: {0}")]+ InvalidProjectName(String),}diff --git a/crates/ai-memory-store/src/ops.rs b/crates/ai-memory-store/src/ops.rsindex 9f52703c..571f0e56 100644--- a/crates/ai-memory-store/src/ops.rs+++ b/crates/ai-memory-store/src/ops.rs@@ -644,6 +644,54 @@ pub fn reorg_sessions(})}+/// Rename a project within its workspace.+///+/// Only the `name` column is updated — all pages, sessions, observations,+/// and handoffs remain associated with the same `project_id`. No files+/// move on disk (the wiki is flat: every page from every project lives+/// under `wiki/`; only the `project_id` foreign key distinguishes them).+///+/// # Errors+/// - [`StoreError::InvalidProjectName`] when `new_name` is empty,+/// contains a `/` character, or is all whitespace.+/// - [`StoreError::ProjectNameTaken`] when a project with `new_name`+/// already exists in the same workspace.+/// - [`StoreError::Sqlite`] on any other SQL failure.+pub fn rename_project(+ conn: &mut Connection,+ workspace_id: &WorkspaceId,+ project_id: &ProjectId,+ new_name: &str,+) -> StoreResult<()> {+ let trimmed = new_name.trim();+ if trimmed.is_empty() {+ return Err(StoreError::InvalidProjectName(+ "project name must not be empty or all whitespace".into(),+ ));+ }+ if trimmed.contains('/') {+ return Err(StoreError::InvalidProjectName(+ "project name must not contain '/' (it appears in URL paths)".into(),+ ));+ }++ let rows = conn.execute(+ "UPDATE projects SET name = ?1 WHERE id = ?2 AND workspace_id = ?3",+ params![trimmed, project_id.as_bytes(), workspace_id.as_bytes()],+ );++ match rows {+ Ok(_) => Ok(()),+ Err(rusqlite::Error::SqliteFailure(err, _))+ if err.extended_code == rusqlite::ffi::SQLITE_CONSTRAINT_UNIQUE+ || err.code == rusqlite::ErrorCode::ConstraintViolation =>+ {+ Err(StoreError::ProjectNameTaken(trimmed.to_string()))+ }+ Err(e) => Err(StoreError::Sqlite(e)),+ }+}+/// Delete a project and all its data inside one transaction.////// Execution order:diff --git a/crates/ai-memory-store/src/writer.rs b/crates/ai-memory-store/src/writer.rsindex edf49bb4..5593bc3e 100644--- a/crates/ai-memory-store/src/writer.rs+++ b/crates/ai-memory-store/src/writer.rs@@ -100,6 +100,15 @@ pub(crate) enum WriteCmd {label: String,reply: oneshot::Sender<StoreResult<PurgeSummary>>,},+ /// Rename a project's `name` column without moving any files (the wiki+ /// is flat on disk). Fails with [`crate::error::StoreError::ProjectNameTaken`]+ /// when `new_name` is already used in the same workspace.+ RenameProject {+ workspace_id: WorkspaceId,+ project_id: ProjectId,+ new_name: String,+ reply: oneshot::Sender<StoreResult<()>>,+ },Shutdown,}@@ -340,6 +349,30 @@ impl WriterHandle {rx.await.map_err(|_| StoreError::WriterClosed)?}+ /// Rename a project within its workspace (column-only; no file moves).+ ///+ /// # Errors+ /// Returns [`crate::error::StoreError::WriterClosed`] if the actor has+ /// shut down, [`crate::error::StoreError::ProjectNameTaken`] if+ /// `new_name` is already in use in the same workspace, or+ /// [`crate::error::StoreError::InvalidProjectName`] for invalid names.+ pub async fn rename_project(+ &self,+ workspace_id: WorkspaceId,+ project_id: ProjectId,+ new_name: impl Into<String>,+ ) -> StoreResult<()> {+ let (tx, rx) = oneshot::channel();+ self.send(WriteCmd::RenameProject {+ workspace_id,+ project_id,+ new_name: new_name.into(),+ reply: tx,+ })+ .await?;+ rx.await.map_err(|_| StoreError::WriterClosed)?+ }+/// Retro-fit sessions and their observations to per-cwd projects and/// graveyard any mash-up pages. The `plan` slice contains/// `(session_id, new_project_id)` pairs. Everything runs in one@@ -524,6 +557,15 @@ fn worker_loop(mut conn: Connection, mut rx: mpsc::Receiver<WriteCmd>) {let result = ops::purge_project(&mut conn, &workspace_id, &project_id, &label);send_or_warn(reply, result, "purge_project");}+ WriteCmd::RenameProject {+ workspace_id,+ project_id,+ new_name,+ reply,+ } => {+ let result = ops::rename_project(&mut conn, &workspace_id, &project_id, &new_name);+ send_or_warn(reply, result, "rename_project");+ }}}tracing::debug!("writer thread exiting cleanly");