void_core/workspace/

workspaces.rs

//! Workspace management — create, list, remove, and prune linked workspaces.
//!
//! Layout:
//! - Main workspace: `root/.void/` (workspace_dir == void_dir)
//! - Linked workspace: `<path>/.void` is a *file* containing `voidDir=<abs path>\nworktree=<name>`
//!   Per-workspace state lives in `<void_dir>/worktrees/<name>/` (HEAD, index, staged, stash, merge state)

use std::fs;
use std::path::{Path, PathBuf};

use camino::Utf8PathBuf;

use crate::refs;
use crate::{Result, VoidError};

const WORKTREES_DIR: &str = "worktrees";

/// Information about a workspace.
#[derive(Debug, Clone)]
pub struct WorkspaceInfo {
    /// Workspace name ("main" for the primary workspace)
    pub name: String,
    /// Branch currently checked out (None if detached HEAD)
    pub branch: Option<String>,
    /// Working tree root path
    pub path: PathBuf,
    /// True for the primary workspace
    pub is_main: bool,
    /// True if the working tree path no longer exists
    pub is_stale: bool,
}

/// List all workspaces (main + linked).
pub fn list_workspaces(void_dir: &Path, root: &Path) -> Result<Vec<WorkspaceInfo>> {
    let mut workspaces = Vec::new();

    // Main workspace
    let void_dir_utf8 = utf8(void_dir)?;
    let main_branch = read_branch_from_head(&void_dir_utf8);
    workspaces.push(WorkspaceInfo {
        name: "main".to_string(),
        branch: main_branch,
        path: root.to_path_buf(),
        is_main: true,
        is_stale: false,
    });

    // Linked workspaces
    let worktrees_dir = void_dir.join(WORKTREES_DIR);
    if worktrees_dir.is_dir() {
        for entry in fs::read_dir(&worktrees_dir)? {
            let entry = entry?;
            let meta = entry.metadata()?;
            if !meta.is_dir() {
                continue;
            }
            let name = entry.file_name().to_string_lossy().to_string();
            let ws_state_dir = entry.path();

            // Read path file to find working tree root
            let path_file = ws_state_dir.join("path");
            let work_tree_path = match fs::read_to_string(&path_file) {
                Ok(p) => PathBuf::from(p.trim()),
                Err(_) => continue, // Skip broken entries
            };

            let is_stale = !work_tree_path.exists();

            let ws_dir_utf8 = utf8(&ws_state_dir).ok();
            let branch = ws_dir_utf8.and_then(|d| read_branch_from_head(&d));

            workspaces.push(WorkspaceInfo {
                name,
                branch,
                path: work_tree_path,
                is_main: false,
                is_stale,
            });
        }
    }

    Ok(workspaces)
}

/// Create a linked workspace.
///
/// Creates:
/// 1. `<void_dir>/worktrees/<name>/` with HEAD and path files
/// 2. `<work_tree_path>/.void` file pointing back to the main void dir
///
/// Returns the per-workspace state directory (`<void_dir>/worktrees/<name>/`).
pub fn create_workspace(
    void_dir: &Path,
    name: &str,
    branch: &str,
    target_cid: Option<&void_crypto::CommitCid>,
    work_tree_path: &Path,
) -> Result<PathBuf> {
    // Validate name
    if name.is_empty()
        || name == "main"
        || name.contains('/')
        || name.contains('\\')
        || name.contains('\0')
    {
        return Err(VoidError::InvalidPattern(format!(
            "invalid workspace name: '{}'",
            name
        )));
    }

    let ws_state_dir = void_dir.join(WORKTREES_DIR).join(name);
    if ws_state_dir.exists() {
        return Err(VoidError::InvalidPattern(format!(
            "workspace '{}' already exists",
            name
        )));
    }

    // Check branch isn't already checked out in another workspace
    if let Some(ws) = find_workspace_for_branch(void_dir, void_dir, branch, Some(name))? {
        return Err(VoidError::InvalidPattern(format!(
            "branch '{}' is already checked out in workspace '{}'",
            branch, ws
        )));
    }

    // Create per-workspace state directory
    fs::create_dir_all(&ws_state_dir)?;

    // Write HEAD (symbolic ref to the branch)
    let ws_dir_utf8 = utf8(&ws_state_dir)?;
    refs::write_head(
        &ws_dir_utf8,
        &refs::HeadRef::Symbolic(branch.to_string()),
    )?;

    // Create the working tree directory first so we can canonicalize it
    fs::create_dir_all(work_tree_path)?;

    // Write path file (canonicalized so symlinks like /tmp → /private/tmp resolve)
    let abs_path = fs::canonicalize(work_tree_path).unwrap_or_else(|_| work_tree_path.to_path_buf());
    fs::write(ws_state_dir.join("path"), abs_path.to_string_lossy().as_bytes())?;

    // Write .void file in the working tree (pointer back to main void dir)
    let abs_void_dir =
        fs::canonicalize(void_dir).unwrap_or_else(|_| void_dir.to_path_buf());
    let void_file_content = format!(
        "voidDir={}\nworktree={}\n",
        abs_void_dir.display(),
        name
    );
    fs::write(work_tree_path.join(".void"), void_file_content)?;

    // Write branch ref if target_cid is provided
    if let Some(cid) = target_cid {
        let void_dir_utf8 = utf8(void_dir)?;
        // Only write if branch doesn't already exist
        let branch_path = void_dir.join("refs").join("heads").join(branch);
        if !branch_path.exists() {
            refs::write_branch(&void_dir_utf8, branch, cid)?;
        }
    }

    // Create index and staged directories in workspace state dir
    fs::create_dir_all(ws_state_dir.join("index"))?;
    fs::create_dir_all(ws_state_dir.join("staged"))?;

    Ok(ws_state_dir)
}

/// Remove a linked workspace.
pub fn remove_workspace(void_dir: &Path, name: &str) -> Result<()> {
    if name == "main" {
        return Err(VoidError::InvalidPattern(
            "cannot remove the main workspace".to_string(),
        ));
    }

    let ws_state_dir = void_dir.join(WORKTREES_DIR).join(name);
    if !ws_state_dir.exists() {
        return Err(VoidError::NotFound(format!("workspace '{}' not found", name)));
    }

    // Read path to optionally clean up .void file in working tree
    let path_file = ws_state_dir.join("path");
    if let Ok(work_tree) = fs::read_to_string(&path_file) {
        let wt_path = PathBuf::from(work_tree.trim());
        let void_file = wt_path.join(".void");
        if void_file.is_file() {
            let _ = fs::remove_file(&void_file);
        }
    }

    // Remove per-workspace state directory
    fs::remove_dir_all(&ws_state_dir)?;

    Ok(())
}

/// Prune stale workspace entries (where the working tree no longer exists).
///
/// Returns the names of pruned workspaces.
pub fn prune_workspaces(void_dir: &Path) -> Result<Vec<String>> {
    let worktrees_dir = void_dir.join(WORKTREES_DIR);
    if !worktrees_dir.is_dir() {
        return Ok(Vec::new());
    }

    let mut pruned = Vec::new();

    for entry in fs::read_dir(&worktrees_dir)? {
        let entry = entry?;
        if !entry.metadata()?.is_dir() {
            continue;
        }
        let name = entry.file_name().to_string_lossy().to_string();
        let path_file = entry.path().join("path");

        let is_stale = match fs::read_to_string(&path_file) {
            Ok(p) => !PathBuf::from(p.trim()).exists(),
            Err(_) => true, // Can't read path file → stale
        };

        if is_stale {
            fs::remove_dir_all(entry.path())?;
            pruned.push(name);
        }
    }

    Ok(pruned)
}

/// Check if a branch is checked out in any workspace.
///
/// Returns the name of the workspace that has the branch checked out, or None.
/// `exclude` allows skipping a specific workspace (useful when the caller is that workspace).
pub fn find_workspace_for_branch(
    void_dir: &Path,
    main_void_dir: &Path,
    branch: &str,
    exclude: Option<&str>,
) -> Result<Option<String>> {
    // read_head strips the `ref: refs/heads/` prefix, so compare against
    // the bare branch name.
    let target_branch = branch
        .strip_prefix("refs/heads/")
        .unwrap_or(branch);

    // Check main workspace
    if exclude.map_or(true, |e| e != "main") {
        let main_utf8 = utf8(main_void_dir)?;
        if let Some(refs::HeadRef::Symbolic(ref r)) = refs::read_head(&main_utf8)? {
            if *r == target_branch {
                return Ok(Some("main".to_string()));
            }
        }
    }

    // Check linked workspaces
    let worktrees_dir = void_dir.join(WORKTREES_DIR);
    if worktrees_dir.is_dir() {
        for entry in fs::read_dir(&worktrees_dir)? {
            let entry = entry?;
            if !entry.metadata()?.is_dir() {
                continue;
            }
            let name = entry.file_name().to_string_lossy().to_string();
            if exclude.map_or(false, |e| e == name) {
                continue;
            }

            let ws_dir = entry.path();
            if let Ok(ws_utf8) = utf8(&ws_dir) {
                if let Ok(Some(refs::HeadRef::Symbolic(ref r))) = refs::read_head(&ws_utf8) {
                    if *r == target_branch {
                        return Ok(Some(name));
                    }
                }
            }
        }
    }

    Ok(None)
}

/// Parse a `.void` file (from a linked workspace) and return `(void_dir, worktree_name)`.
pub fn parse_void_file(void_file_path: &Path) -> Result<(PathBuf, String)> {
    let content = fs::read_to_string(void_file_path)?;
    let mut void_dir = None;
    let mut worktree = None;

    for line in content.lines() {
        let line = line.trim();
        if let Some(val) = line.strip_prefix("voidDir=") {
            void_dir = Some(PathBuf::from(val));
        } else if let Some(val) = line.strip_prefix("worktree=") {
            worktree = Some(val.to_string());
        }
    }

    match (void_dir, worktree) {
        (Some(vd), Some(wt)) => Ok((vd, wt)),
        _ => Err(VoidError::InvalidPattern(
            "invalid .void file format".to_string(),
        )),
    }
}

// ============================================================================
// Helpers
// ============================================================================

fn utf8(path: &Path) -> Result<Utf8PathBuf> {
    Utf8PathBuf::try_from(path.to_path_buf())
        .map_err(|e| VoidError::Io(std::io::Error::new(std::io::ErrorKind::InvalidData, e)))
}

fn read_branch_from_head(dir: &Utf8PathBuf) -> Option<String> {
    match refs::read_head(dir) {
        Ok(Some(refs::HeadRef::Symbolic(r))) => {
            Some(r.strip_prefix("refs/heads/").unwrap_or(&r).to_string())
        }
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    fn setup_void_dir() -> (TempDir, PathBuf) {
        let temp = TempDir::new().unwrap();
        let root = temp.path().to_path_buf();
        let void_dir = root.join(".void");
        fs::create_dir_all(&void_dir).unwrap();
        // Write a HEAD file for main workspace
        let void_utf8 = utf8(&void_dir).unwrap();
        refs::write_head(
            &void_utf8,
            &refs::HeadRef::Symbolic("trunk".to_string()),
        )
        .unwrap();
        (temp, void_dir)
    }

    #[test]
    fn list_workspaces_shows_main() {
        let (temp, void_dir) = setup_void_dir();
        let root = temp.path().to_path_buf();

        let ws = list_workspaces(&void_dir, &root).unwrap();
        assert_eq!(ws.len(), 1);
        assert!(ws[0].is_main);
        assert_eq!(ws[0].name, "main");
        assert_eq!(ws[0].branch, Some("trunk".to_string()));
    }

    #[test]
    fn create_and_list_workspace() {
        let (temp, void_dir) = setup_void_dir();
        let root = temp.path().to_path_buf();
        let ws_path = temp.path().join("test-ws");

        create_workspace(&void_dir, "test-ws", "feature", None, &ws_path).unwrap();

        // Verify directory structure
        assert!(void_dir.join("worktrees/test-ws").exists());
        assert!(void_dir.join("worktrees/test-ws/HEAD").exists());
        assert!(void_dir.join("worktrees/test-ws/path").exists());
        assert!(ws_path.join(".void").is_file());

        // List should show both
        let ws = list_workspaces(&void_dir, &root).unwrap();
        assert_eq!(ws.len(), 2);
        let linked = ws.iter().find(|w| w.name == "test-ws").unwrap();
        assert!(!linked.is_main);
        assert_eq!(linked.branch, Some("feature".to_string()));
        assert!(!linked.is_stale);
    }

    #[test]
    fn create_duplicate_workspace_fails() {
        let (temp, void_dir) = setup_void_dir();
        let ws_path = temp.path().join("test-ws");

        create_workspace(&void_dir, "test-ws", "feature", None, &ws_path).unwrap();
        let result = create_workspace(&void_dir, "test-ws", "other", None, &ws_path);
        assert!(result.is_err());
    }

    #[test]
    fn create_workspace_with_locked_branch_fails() {
        let (temp, void_dir) = setup_void_dir();

        // trunk is checked out in main — can't create a workspace for it
        let ws_path = temp.path().join("trunk-ws");
        let result = create_workspace(&void_dir, "trunk-ws", "trunk", None, &ws_path);
        assert!(result.is_err());
        let err_msg = format!("{}", result.unwrap_err());
        assert!(err_msg.contains("already checked out"));
    }

    #[test]
    fn remove_workspace_cleans_up() {
        let (temp, void_dir) = setup_void_dir();
        let ws_path = temp.path().join("test-ws");

        create_workspace(&void_dir, "test-ws", "feature", None, &ws_path).unwrap();
        assert!(void_dir.join("worktrees/test-ws").exists());

        remove_workspace(&void_dir, "test-ws").unwrap();
        assert!(!void_dir.join("worktrees/test-ws").exists());
        // .void file in working tree should be removed
        assert!(!ws_path.join(".void").exists());
    }

    #[test]
    fn remove_main_workspace_fails() {
        let (_temp, void_dir) = setup_void_dir();
        let result = remove_workspace(&void_dir, "main");
        assert!(result.is_err());
    }

    #[test]
    fn prune_removes_stale_workspaces() {
        let (temp, void_dir) = setup_void_dir();
        let ws_path = temp.path().join("test-ws");

        create_workspace(&void_dir, "test-ws", "feature", None, &ws_path).unwrap();

        // Delete the working tree to make it stale
        fs::remove_dir_all(&ws_path).unwrap();

        let pruned = prune_workspaces(&void_dir).unwrap();
        assert_eq!(pruned, vec!["test-ws"]);
        assert!(!void_dir.join("worktrees/test-ws").exists());
    }

    #[test]
    fn prune_keeps_valid_workspaces() {
        let (temp, void_dir) = setup_void_dir();
        let ws_path = temp.path().join("test-ws");

        create_workspace(&void_dir, "test-ws", "feature", None, &ws_path).unwrap();

        let pruned = prune_workspaces(&void_dir).unwrap();
        assert!(pruned.is_empty());
        assert!(void_dir.join("worktrees/test-ws").exists());
    }

    #[test]
    fn find_workspace_for_branch_finds_main() {
        let (_temp, void_dir) = setup_void_dir();

        let ws = find_workspace_for_branch(&void_dir, &void_dir, "trunk", None).unwrap();
        assert_eq!(ws, Some("main".to_string()));
    }

    #[test]
    fn find_workspace_for_branch_finds_linked() {
        let (temp, void_dir) = setup_void_dir();
        let ws_path = temp.path().join("feat-ws");

        create_workspace(&void_dir, "feat-ws", "feature", None, &ws_path).unwrap();

        let ws = find_workspace_for_branch(&void_dir, &void_dir, "feature", None).unwrap();
        assert_eq!(ws, Some("feat-ws".to_string()));
    }

    #[test]
    fn find_workspace_for_branch_with_exclude() {
        let (_temp, void_dir) = setup_void_dir();

        // Exclude main — trunk should not be found
        let ws =
            find_workspace_for_branch(&void_dir, &void_dir, "trunk", Some("main")).unwrap();
        assert_eq!(ws, None);
    }

    #[test]
    fn find_workspace_for_nonexistent_branch() {
        let (_temp, void_dir) = setup_void_dir();

        let ws =
            find_workspace_for_branch(&void_dir, &void_dir, "nonexistent", None).unwrap();
        assert_eq!(ws, None);
    }

    #[test]
    fn parse_void_file_roundtrip() {
        let (temp, void_dir) = setup_void_dir();
        let ws_path = temp.path().join("test-ws");

        create_workspace(&void_dir, "test-ws", "feature", None, &ws_path).unwrap();

        let (parsed_void_dir, parsed_name) =
            parse_void_file(&ws_path.join(".void")).unwrap();
        assert_eq!(parsed_name, "test-ws");
        assert_eq!(
            fs::canonicalize(&parsed_void_dir).unwrap(),
            fs::canonicalize(&void_dir).unwrap()
        );
    }

    #[test]
    fn invalid_workspace_names() {
        let (temp, void_dir) = setup_void_dir();
        let ws_path = temp.path().join("ws");

        assert!(create_workspace(&void_dir, "", "branch", None, &ws_path).is_err());
        assert!(create_workspace(&void_dir, "main", "branch", None, &ws_path).is_err());
        assert!(create_workspace(&void_dir, "a/b", "branch", None, &ws_path).is_err());
    }

    #[test]
    fn workspace_dir_equals_void_dir_for_main() {
        // Verify the backwards-compatible invariant: for the main workspace,
        // workspace_dir == void_dir
        let dir = tempfile::tempdir().unwrap();
        let void_dir = dir.path().join(".void");
        std::fs::create_dir_all(void_dir.join("objects")).unwrap();
        let vault = std::sync::Arc::new(
            crate::crypto::KeyVault::new([0u8; 32]).unwrap(),
        );
        let ctx = crate::VoidContext::headless(&void_dir, vault, 0).unwrap();
        assert_eq!(ctx.paths.workspace_dir, ctx.paths.void_dir);
    }
}