Skip to content

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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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");