initial release

terminal workspace manager for AI coding agents.
single rust binary, runs inside your existing terminal.
workspaces, tiled panes, intelligent agent state detection.

https://herdr.dev

1 files changed, 446 insertions, 0 deletions

diff --git a/src/persist.rs b/src/persist.rs
new file mode 100644
index 00000000..31a37576
--- /dev/null
+++ b/src/persist.rs
@@ -0,0 +1,446 @@
+//! Session persistence — save/restore workspaces, layouts, and working directories.
+//!
+//! Stored at `~/.config/herdr/session.json`.
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use ratatui::layout::Direction;
+use serde::{Deserialize, Serialize};
+use tracing::{error, info, warn};
+
+use tokio::sync::mpsc;
+
+use crate::events::AppEvent;
+use crate::layout::{Node, PaneId, TileLayout};
+use crate::pane::{PaneRuntime, PaneState};
+use crate::workspace::Workspace;
+
+/// Current snapshot format version.
+const SNAPSHOT_VERSION: u32 = 1;
+
+/// Serializable snapshot of the entire herdr session.
+#[derive(Serialize, Deserialize)]
+pub struct SessionSnapshot {
+    /// Format version — used to detect incompatible changes.
+    #[serde(default)]
+    pub version: u32,
+    pub workspaces: Vec<WorkspaceSnapshot>,
+    pub active: Option<usize>,
+    pub selected: usize,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct WorkspaceSnapshot {
+    pub name: String,
+    pub layout: LayoutSnapshot,
+    pub panes: HashMap<u32, PaneSnapshot>,
+    pub zoomed: bool,
+    /// Raw pane ID that was focused when saved.
+    #[serde(default)]
+    pub focused: Option<u32>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct PaneSnapshot {
+    pub cwd: PathBuf,
+}
+
+/// Serializable BSP tree.
+#[derive(Serialize, Deserialize)]
+pub enum LayoutSnapshot {
+    Pane(u32),
+    Split {
+        direction: DirectionSnapshot,
+        ratio: f32,
+        first: Box<LayoutSnapshot>,
+        second: Box<LayoutSnapshot>,
+    },
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum DirectionSnapshot {
+    Horizontal,
+    Vertical,
+}
+
+// --- Capture ---
+
+/// Capture the current app state into a serializable snapshot.
+pub fn capture(
+    workspaces: &[Workspace],
+    active: Option<usize>,
+    selected: usize,
+) -> SessionSnapshot {
+    SessionSnapshot {
+        version: SNAPSHOT_VERSION,
+        workspaces: workspaces.iter().map(capture_workspace).collect(),
+        active,
+        selected,
+    }
+}
+
+fn capture_workspace(ws: &Workspace) -> WorkspaceSnapshot {
+    let mut panes = HashMap::new();
+    for id in ws.panes.keys() {
+        let cwd = ws.runtimes.get(id)
+            .and_then(|rt| rt.cwd())
+            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into()));
+        panes.insert(id.raw(), PaneSnapshot { cwd });
+    }
+    WorkspaceSnapshot {
+        name: ws.name.clone(),
+        layout: capture_node(ws.layout.root()),
+        panes,
+        zoomed: ws.zoomed,
+        focused: Some(ws.layout.focused().raw()),
+    }
+}
+
+fn capture_node(node: &Node) -> LayoutSnapshot {
+    match node {
+        Node::Pane(id) => LayoutSnapshot::Pane(id.raw()),
+        Node::Split {
+            direction,
+            ratio,
+            first,
+            second,
+        } => LayoutSnapshot::Split {
+            direction: match direction {
+                Direction::Horizontal => DirectionSnapshot::Horizontal,
+                Direction::Vertical => DirectionSnapshot::Vertical,
+            },
+            ratio: *ratio,
+            first: Box::new(capture_node(first)),
+            second: Box::new(capture_node(second)),
+        },
+    }
+}
+
+// --- Restore ---
+
+/// Restore workspaces from a snapshot. Each pane gets a fresh shell in its saved cwd.
+pub fn restore(
+    snapshot: &SessionSnapshot,
+    rows: u16,
+    cols: u16,
+    events: mpsc::Sender<AppEvent>,
+) -> Vec<Workspace> {
+    snapshot
+        .workspaces
+        .iter()
+        .filter_map(|ws_snap| restore_workspace(ws_snap, rows, cols, events.clone()))
+        .collect()
+}
+
+fn restore_workspace(
+    snap: &WorkspaceSnapshot,
+    rows: u16,
+    cols: u16,
+    events: mpsc::Sender<AppEvent>,
+) -> Option<Workspace> {
+    let (node, id_map) = restore_node_remapped(&snap.layout);
+    let pane_ids = collect_pane_ids(&node);
+
+    // Restore focused pane: map saved raw ID to new ID, fall back to first pane
+    let focus = snap
+        .focused
+        .and_then(|old_raw| id_map.get(&old_raw).copied())
+        .or_else(|| pane_ids.first().copied())
+        .unwrap_or(PaneId::from_raw(0));
+    let layout = TileLayout::from_saved(node, focus);
+
+    let mut panes = HashMap::new();
+    let mut runtimes = HashMap::new();
+    for id in &pane_ids {
+        let old_id = id_map.iter().find(|(_, new)| **new == *id).map(|(old, _)| old);
+        let cwd = old_id
+            .and_then(|old| snap.panes.get(old))
+            .map(|p| p.cwd.clone())
+            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into()));
+
+        match PaneRuntime::spawn(*id, rows, cols, cwd, events.clone()) {
+            Ok(runtime) => {
+                panes.insert(*id, PaneState::new());
+                runtimes.insert(*id, runtime);
+            }
+            Err(e) => {
+                error!(workspace = %snap.name, err = %e, "failed to restore pane");
+                return None;
+            }
+        }
+    }
+
+    Some(Workspace {
+        name: snap.name.clone(),
+        layout,
+        panes,
+        runtimes,
+        zoomed: snap.zoomed,
+        events,
+    })
+}
+
+/// Restore a layout tree, remapping every pane ID to a fresh globally unique one.
+/// Returns the new tree and a map of old_raw_id → new PaneId.
+fn restore_node_remapped(snap: &LayoutSnapshot) -> (Node, HashMap<u32, PaneId>) {
+    let mut id_map = HashMap::new();
+    let node = remap_inner(snap, &mut id_map);
+    (node, id_map)
+}
+
+fn remap_inner(snap: &LayoutSnapshot, id_map: &mut HashMap<u32, PaneId>) -> Node {
+    match snap {
+        LayoutSnapshot::Pane(old_id) => {
+            let new_id = PaneId::alloc();
+            id_map.insert(*old_id, new_id);
+            Node::Pane(new_id)
+        }
+        LayoutSnapshot::Split {
+            direction,
+            ratio,
+            first,
+            second,
+        } => {
+            let first_node = remap_inner(first, id_map);
+            let second_node = remap_inner(second, id_map);
+            let dir = match direction {
+                DirectionSnapshot::Horizontal => Direction::Horizontal,
+                DirectionSnapshot::Vertical => Direction::Vertical,
+            };
+            Node::Split {
+                direction: dir,
+                ratio: *ratio,
+                first: Box::new(first_node),
+                second: Box::new(second_node),
+            }
+        }
+    }
+}
+
+fn collect_pane_ids(node: &Node) -> Vec<PaneId> {
+    let mut ids = Vec::new();
+    collect_ids_inner(node, &mut ids);
+    ids
+}
+
+fn collect_ids_inner(node: &Node, ids: &mut Vec<PaneId>) {
+    match node {
+        Node::Pane(id) => ids.push(*id),
+        Node::Split { first, second, .. } => {
+            collect_ids_inner(first, ids);
+            collect_ids_inner(second, ids);
+        }
+    }
+}
+
+// --- File I/O ---
+
+fn session_path() -> PathBuf {
+    if let Ok(dir) = std::env::var("XDG_CONFIG_HOME") {
+        PathBuf::from(dir).join("herdr/session.json")
+    } else if let Ok(home) = std::env::var("HOME") {
+        PathBuf::from(home).join(".config/herdr/session.json")
+    } else {
+        PathBuf::from("/tmp/herdr/session.json")
+    }
+}
+
+pub fn save(snapshot: &SessionSnapshot) {
+    let path = session_path();
+    if let Some(parent) = path.parent() {
+        if let Err(e) = std::fs::create_dir_all(parent) {
+            error!(err = %e, "failed to create session directory");
+            return;
+        }
+    }
+    let json = match serde_json::to_string_pretty(snapshot) {
+        Ok(j) => j,
+        Err(e) => {
+            error!(err = %e, "failed to serialize session");
+            return;
+        }
+    };
+    // Atomic write: write to temp file, then rename
+    let tmp_path = path.with_extension("json.tmp");
+    if let Err(e) = std::fs::write(&tmp_path, &json) {
+        error!(err = %e, "failed to write session temp file");
+        return;
+    }
+    if let Err(e) = std::fs::rename(&tmp_path, &path) {
+        error!(err = %e, "failed to rename session file");
+        // Clean up temp file
+        let _ = std::fs::remove_file(&tmp_path);
+        return;
+    }
+    info!(workspaces = snapshot.workspaces.len(), "session saved");
+}
+
+pub fn load() -> Option<SessionSnapshot> {
+    let path = session_path();
+    if !path.exists() {
+        return None;
+    }
+    let content = match std::fs::read_to_string(&path) {
+        Ok(c) => c,
+        Err(e) => {
+            warn!(err = %e, "failed to read session file");
+            return None;
+        }
+    };
+    match serde_json::from_str::<SessionSnapshot>(&content) {
+        Ok(snap) => {
+            if snap.version > SNAPSHOT_VERSION {
+                warn!(
+                    file_version = snap.version,
+                    supported = SNAPSHOT_VERSION,
+                    "session file is from a newer herdr version, ignoring"
+                );
+                return None;
+            }
+            Some(snap)
+        }
+        Err(e) => {
+            warn!(err = %e, "failed to parse session file, ignoring");
+            None
+        }
+    }
+}
+
+// --- Tests ---
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn round_trip_empty_session() {
+        let snap = SessionSnapshot {
+            version: 1,
+            workspaces: vec![],
+            active: None,
+            selected: 0,
+        };
+        let json = serde_json::to_string(&snap).unwrap();
+        let restored: SessionSnapshot = serde_json::from_str(&json).unwrap();
+        assert!(restored.workspaces.is_empty());
+        assert_eq!(restored.active, None);
+    }
+
+    #[test]
+    fn round_trip_layout_snapshot() {
+        let layout = LayoutSnapshot::Split {
+            direction: DirectionSnapshot::Horizontal,
+            ratio: 0.6,
+            first: Box::new(LayoutSnapshot::Pane(0)),
+            second: Box::new(LayoutSnapshot::Split {
+                direction: DirectionSnapshot::Vertical,
+                ratio: 0.5,
+                first: Box::new(LayoutSnapshot::Pane(1)),
+                second: Box::new(LayoutSnapshot::Pane(2)),
+            }),
+        };
+        let json = serde_json::to_string(&layout).unwrap();
+        let restored: LayoutSnapshot = serde_json::from_str(&json).unwrap();
+
+        // Verify structure
+        match restored {
+            LayoutSnapshot::Split { ratio, .. } => assert!((ratio - 0.6).abs() < 0.01),
+            _ => panic!("expected split"),
+        }
+    }
+
+    #[test]
+    fn round_trip_full_workspace_snapshot() {
+        let mut panes = HashMap::new();
+        panes.insert(
+            0,
+            PaneSnapshot {
+                cwd: PathBuf::from("/home/can/Projects/herdr"),
+            },
+        );
+        panes.insert(
+            1,
+            PaneSnapshot {
+                cwd: PathBuf::from("/home/can/Projects/website"),
+            },
+        );
+
+        let snap = SessionSnapshot {
+            workspaces: vec![WorkspaceSnapshot {
+                name: "pi-mono".to_string(),
+                layout: LayoutSnapshot::Split {
+                    direction: DirectionSnapshot::Horizontal,
+                    ratio: 0.5,
+                    first: Box::new(LayoutSnapshot::Pane(0)),
+                    second: Box::new(LayoutSnapshot::Pane(1)),
+                },
+                panes,
+                zoomed: false,
+                focused: Some(0),
+            }],
+            active: Some(0),
+            selected: 0,
+            version: 1,
+        };
+
+        let json = serde_json::to_string_pretty(&snap).unwrap();
+        let restored: SessionSnapshot = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(restored.workspaces.len(), 1);
+        assert_eq!(restored.workspaces[0].name, "pi-mono");
+        assert_eq!(restored.workspaces[0].panes.len(), 2);
+        assert_eq!(
+            restored.workspaces[0].panes[&0].cwd,
+            PathBuf::from("/home/can/Projects/herdr")
+        );
+    }
+
+    #[test]
+    fn capture_and_restore_node_round_trip() {
+        // Create a tree: Split(H, 0.5, Pane(0), Split(V, 0.3, Pane(1), Pane(2)))
+        let node = Node::Split {
+            direction: Direction::Horizontal,
+            ratio: 0.5,
+            first: Box::new(Node::Pane(PaneId::from_raw(0))),
+            second: Box::new(Node::Split {
+                direction: Direction::Vertical,
+                ratio: 0.3,
+                first: Box::new(Node::Pane(PaneId::from_raw(1))),
+                second: Box::new(Node::Pane(PaneId::from_raw(2))),
+            }),
+        };
+
+        let snap = capture_node(&node);
+        let (restored, id_map) = restore_node_remapped(&snap);
+
+        assert_eq!(id_map.len(), 3);
+        let ids = collect_pane_ids(&restored);
+        assert_eq!(ids.len(), 3);
+        let unique: std::collections::HashSet<u32> = ids.iter().map(|id| id.raw()).collect();
+        assert_eq!(unique.len(), 3);
+    }
+
+    #[test]
+    fn old_unversioned_snapshot_loads_as_version_0() {
+        // Simulate a snapshot from before versioning was added
+        let json = r#"{"workspaces":[],"active":null,"selected":0}"#;
+        let snap: SessionSnapshot = serde_json::from_str(json).unwrap();
+        assert_eq!(snap.version, 0); // #[serde(default)] gives 0
+    }
+
+    #[test]
+    fn future_version_is_rejected() {
+        let json = r#"{"version":999,"workspaces":[],"active":null,"selected":0}"#;
+        let snap: SessionSnapshot = serde_json::from_str(json).unwrap();
+        assert!(snap.version > SNAPSHOT_VERSION);
+        // load() would reject this — tested via the version check in load()
+    }
+
+    #[test]
+    fn focused_pane_default_is_none() {
+        let json = r#"{"name":"test","layout":{"Pane":0},"panes":{},"zoomed":false}"#;
+        let ws: WorkspaceSnapshot = serde_json::from_str(json).unwrap();
+        assert_eq!(ws.focused, None); // #[serde(default)]
+    }
+}