Skip to content

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

Rust
5.4 KB
Raw Blame
//! Checkout-local rename for managed workstreams.

use ai_memory_core::{RenameManagedWorkstreamRequest, RenamedManagedWorkstream};
use ai_memory_workstream::inspect_repository;
use anyhow::{Context as _, Result, bail};

use crate::cli::RenameWorkstreamArgs;
use crate::config::Config;
use crate::http_client::{ServerEndpoint, post_json};

/// Retitle one workstream selectable from this checkout.
pub async fn run(config: &Config, args: RenameWorkstreamArgs) -> Result<()> {
    super::refuse_empty_explicit(args.workspace.as_deref(), "--workspace")?;
    super::refuse_empty_explicit(args.project.as_deref(), "--project")?;
    super::refuse_empty_explicit(args.from.as_deref(), "--from")?;
    if args.to.trim().is_empty() {
        bail!("--to was passed empty; specify the new workstream name");
    }

    // clap's `conflicts_with` rejects passing both, but not passing neither:
    // the pair is optional on either side, so an empty invocation reaches here
    // with nothing to address.
    if args.from.is_none() && args.workstream_id.is_none() {
        bail!("pass --from NAME or --workstream-id ID to choose the workstream to rename");
    }
    let cwd = std::env::current_dir().context("getting managed workstream checkout")?;
    let repository = inspect_repository(&cwd)?;
    let (workspace, project) =
        super::resolve_scope(config, args.workspace.as_deref(), args.project.as_deref())?;
    let endpoint = ServerEndpoint::from_config_resolving_auth(config).await;
    let renamed: RenamedManagedWorkstream = post_json(
        &endpoint,
        "/workstream/rename",
        &RenameManagedWorkstreamRequest {
            workspace,
            project,
            repo_fingerprint: repository.repo_fingerprint,
            worktree_fingerprint: repository.worktree_fingerprint,
            from: args.from,
            workstream_id: args.workstream_id,
            to: args.to,
        },
    )
    .await?;
    if args.json {
        println!("{}", serde_json::to_string_pretty(&renamed)?);
        return Ok(());
    }
    print!("{}", render_human(&renamed));
    Ok(())
}

fn render_human(renamed: &RenamedManagedWorkstream) -> String {
    if renamed.from == renamed.to {
        // A repeated rename is not a failure, but reporting it as a change
        // would be a lie: nothing was written.
        return format!("Workstream '{}' already has that name.\n", renamed.to);
    }
    format!(
        "Renamed workstream '{}' to '{}'.\n    id: {}\n",
        renamed.from, renamed.to, renamed.workstream_id
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use ai_memory_core::WorkstreamId;

    fn renamed(from: &str, to: &str) -> RenamedManagedWorkstream {
        RenamedManagedWorkstream {
            workstream_id: WorkstreamId::new(),
            from: from.to_owned(),
            to: to.to_owned(),
        }
    }

    #[test]
    fn human_output_reports_both_names_and_the_stable_id() {
        let renamed = renamed("typo-nmae", "refactor-db");
        let rendered = render_human(&renamed);
        assert!(rendered.contains("'typo-nmae' to 'refactor-db'"));
        // The id is indented far enough that a continuation line cannot be
        // mistaken for the start of another record, matching `workstreams`.
        assert!(rendered.contains("\n    id: "));
        assert!(rendered.ends_with('\n'));
    }

    #[test]
    fn renaming_to_the_same_name_does_not_claim_a_change() {
        let rendered = render_human(&renamed("stable", "stable"));
        assert!(rendered.contains("already has that name"));
        assert!(!rendered.contains("Renamed"));
    }

    fn test_args() -> RenameWorkstreamArgs {
        RenameWorkstreamArgs {
            workspace: None,
            project: None,
            from: Some("old".into()),
            workstream_id: None,
            to: "new".into(),
            json: false,
        }
    }

    #[tokio::test]
    async fn an_empty_project_flag_is_refused_before_any_request() {
        let config = Config::default();
        let mut a = test_args();
        a.project = Some("   ".into());
        let error = run(&config, a).await.unwrap_err();
        assert!(
            error.to_string().contains("--project was passed empty"),
            "unexpected error: {error}"
        );
    }

    #[tokio::test]
    async fn an_empty_workspace_flag_is_refused_before_any_request() {
        let config = Config::default();
        let mut a = test_args();
        a.workspace = Some("".into());
        let error = run(&config, a).await.unwrap_err();
        assert!(
            error.to_string().contains("--workspace was passed empty"),
            "unexpected error: {error}"
        );
    }

    #[tokio::test]
    async fn an_empty_from_flag_is_refused_before_any_request() {
        let config = Config::default();
        let mut a = test_args();
        a.from = Some("   ".into());
        let error = run(&config, a).await.unwrap_err();
        assert!(
            error.to_string().contains("--from was passed empty"),
            "unexpected error: {error}"
        );
    }

    #[tokio::test]
    async fn an_empty_to_flag_is_refused_before_any_request() {
        let config = Config::default();
        let mut a = test_args();
        a.to = "   ".into();
        let error = run(&config, a).await.unwrap_err();
        assert!(
            error.to_string().contains("--to was passed empty"),
            "unexpected error: {error}"
        );
    }
}