use crate::config::{load_default_config, save_default_config};
use crate::error::SpriteError;
use crate::models::Agent;
use crate::utils::git::{
self, delete_branch, has_merge_conflicts, has_uncommitted_changes, merge_branch,
remove_worktree,
};
use crate::utils::tmux;
use anyhow::{Context, Result};
use std::io::{self, Write};
use std::path::Path;
pub fn execute(
agent_id: &str,
force: bool,
keep_workspace: bool,
merge_branch: bool,
) -> Result<()> {
git::validate_git_repository().context("Must be run from within a git repository")?;
let mut config =
load_default_config().context("Failed to load configuration. Run 'sprite init' first.")?;
let agent_index = config
.agents
.iter()
.position(|a| a.id == agent_id)
.ok_or_else(|| {
SpriteError::agent(
format!(
"Agent '{}' not found. Use 'sprite agents list' to see available agents.",
agent_id
),
Some(agent_id),
)
})?;
let agent = &config.agents[agent_index];
if !force {
perform_safety_checks(agent)?;
}
check_agent_not_running(agent)?;
if merge_branch {
println!(
"đ Merging agent branch '{}' before removal...",
agent.branch
);
merge_agent_branch(agent)?;
println!("â
Branch merged successfully");
}
let workspace_path = agent.workspace_path();
if workspace_path.exists() {
if !keep_workspace {
println!(
"đī¸ Removing agent workspace at {}...",
workspace_path.display()
);
remove_agent_worktree(workspace_path)?;
println!("â
Workspace removed");
} else {
println!("đ Keeping workspace files as requested");
}
} else {
println!("âšī¸ No workspace found at {}", workspace_path.display());
}
if git::branch_exists(&agent.branch)? {
if !merge_branch {
if !force && !prompt_for_branch_deletion(&agent.branch)? {
println!("đ Keeping git branch '{}' as requested", agent.branch);
} else {
delete_agent_branch(&agent.branch, force)?;
println!("â
Branch '{}' removed", agent.branch);
}
} else {
delete_agent_branch(&agent.branch, false)?;
println!("â
Merged branch '{}' removed", agent.branch);
}
} else {
println!("âšī¸ No git branch '{}' found", agent.branch);
}
config.agents.remove(agent_index);
save_default_config(&config).context("Failed to save updated configuration")?;
println!("â
Agent '{}' removed successfully", agent_id);
if !config.agents.is_empty() {
println!("\nđ Remaining agents:");
for remaining_agent in &config.agents {
let status = if remaining_agent.is_active() {
"đĸ Active"
} else {
"âĒ Inactive"
};
println!(
" {} {} ({})",
remaining_agent.id, remaining_agent.branch, status
);
}
} else {
println!("\nđ No agents remaining. Use 'sprite agents create <ID>' to add new agents.");
}
Ok(())
}
fn perform_safety_checks(agent: &Agent) -> Result<()> {
println!("đ Performing safety checks for agent '{}'...", agent.id);
let workspace_path = agent.workspace_path();
if workspace_path.exists() && has_uncommitted_changes(workspace_path)? {
return Err(SpriteError::agent(
format!(
"Agent '{}' has uncommitted changes in workspace '{}'. \
Commit or stash changes first, or use --force to override.",
agent.id,
workspace_path.display()
),
Some(&agent.id),
)
.into());
}
if git::branch_exists(&agent.branch)? {
let current_branch = git::get_current_branch()?;
if current_branch != agent.branch {
git::switch_branch("main")?;
}
if !git::is_branch_merged(&agent.branch)? {
println!(
"â ī¸ Warning: Branch '{}' may have unmerged changes.",
agent.branch
);
println!(" Consider using --merge-branch to merge before removal.");
if !confirm_proceed_with_unmerged()? {
return Err(SpriteError::agent(
"Agent removal cancelled by user due to unmerged changes".to_string(),
Some(&agent.id),
)
.into());
}
}
if current_branch != agent.branch && current_branch != "main" {
git::switch_branch(¤t_branch)?;
}
}
println!(
"âšī¸ Agent '{}' workspace: {}",
agent.id,
workspace_path.display()
);
println!("âšī¸ Agent '{}' branch: {}", agent.id, agent.branch);
Ok(())
}
fn check_agent_not_running(agent: &Agent) -> Result<()> {
let sessions = tmux::list_sessions().context("Failed to list tmux sessions")?;
for session in sessions {
let panes = tmux::list_panes(&session.name).context("Failed to list tmux panes")?;
for pane in panes {
let pane_cwd = tmux::get_pane_current_path(&session.name, &pane.id).unwrap_or_default();
if let Some(agent_workspace) = agent.worktree_path.as_ref() {
if pane_cwd == agent_workspace.to_string_lossy() {
return Err(SpriteError::agent(
format!(
"Agent '{}' appears to be running in tmux session '{}' pane {}. \
Stop the agent first with 'sprite kill' or detach from the session.",
agent.id, session.name, pane.id
),
Some(&agent.id),
)
.into());
}
}
}
}
Ok(())
}
fn remove_agent_worktree(workspace_path: &Path) -> Result<()> {
if !workspace_path.exists() {
println!("âšī¸ Workspace does not exist: {}", workspace_path.display());
return Ok(());
}
remove_worktree(workspace_path).with_context(|| {
format!(
"Failed to remove git worktree at {}",
workspace_path.display()
)
})?;
if workspace_path.exists() {
std::fs::remove_dir_all(workspace_path)
.with_context(|| format!("Failed to remove directory {}", workspace_path.display()))?;
}
Ok(())
}
fn merge_agent_branch(agent: &Agent) -> Result<()> {
if !git::branch_exists(&agent.branch)? {
println!(
"âšī¸ Branch '{}' does not exist, skipping merge",
agent.branch
);
return Ok(());
}
let original_branch = git::get_current_branch()?;
git::switch_branch("main").context("Failed to switch to main branch for merging")?;
merge_branch(&agent.branch).context("Failed to merge agent branch")?;
if has_merge_conflicts()? {
println!("â ī¸ Merge conflicts detected. Please resolve them manually:");
println!(" 1. Run 'git status' to see conflicted files");
println!(" 2. Edit files to resolve conflicts");
println!(" 3. Run 'git add' on resolved files");
println!(" 4. Run 'git commit' to complete the merge");
println!(
" 5. Run 'sprite remove {} --force' to continue removal",
agent.id
);
return Err(SpriteError::git(format!(
"Merge conflicts detected while merging branch '{}'. Resolve conflicts and try again.",
agent.branch
))
.into());
}
if original_branch != agent.branch && original_branch != "main" {
git::switch_branch(&original_branch)?;
}
Ok(())
}
fn delete_agent_branch(branch: &str, force: bool) -> Result<()> {
if !git::branch_exists(branch)? {
return Ok(());
}
if force {
delete_branch(branch, true)?;
} else {
let current_branch = git::get_current_branch()?;
if current_branch != "main" {
git::switch_branch("main")?;
}
if git::is_branch_merged(branch)? {
delete_branch(branch, false)?;
} else {
println!(
"â ī¸ Branch '{}' has unmerged changes. Use --force to delete anyway.",
branch
);
return Err(
SpriteError::git(format!("Branch '{}' has unmerged changes", branch)).into(),
);
}
if current_branch != "main" {
git::switch_branch(¤t_branch)?;
}
}
Ok(())
}
fn confirm_proceed_with_unmerged() -> Result<bool> {
print!("â Branch may have unmerged changes. Proceed anyway? [y/N] ");
io::stdout().flush().context("Failed to flush stdout")?;
let mut input = String::new();
io::stdin()
.read_line(&mut input)
.context("Failed to read user input")?;
let input = input.trim().to_lowercase();
Ok(input == "y" || input == "yes")
}
fn prompt_for_branch_deletion(branch: &str) -> Result<bool> {
print!("â Delete git branch '{}'? [y/N] ", branch);
io::stdout().flush().context("Failed to flush stdout")?;
let mut input = String::new();
io::stdin()
.read_line(&mut input)
.context("Failed to read user input")?;
let input = input.trim().to_lowercase();
Ok(input == "y" || input == "yes")
}
#[cfg(test)]
mod tests {
#[test]
fn test_remove_command_basic() {
}
}