jettypod 4.4.118 → 4.4.121

package/crates/jettypod-core/src/sessions.rs

@@ -0,0 +1,625 @@
+//! Session management.
+//!
+//! Tracks active Claude Code sessions, their associated work items,
+//! and provides session lifecycle operations.
+//!
+//! Three subsystems:
+//! 1. **Claude sessions** (DB) — track which Claude sessions are active, their content
+//! 2. **Session files** (filesystem) — `.claude/session.md` for mode/context resumption
+//! 3. **Current work** — derive active work item from git branch name
+
+use std::path::{Path, PathBuf};
+
+use rusqlite::params;
+
+use crate::db::Database;
+use crate::error::{CoreError, Result, WorkError};
+use crate::git;
+
+// ---------------------------------------------------------------------------
+// Claude Sessions (DB-backed)
+// ---------------------------------------------------------------------------
+
+/// A Claude Code session record.
+#[derive(Debug, Clone)]
+pub struct ClaudeSession {
+    pub id: i64,
+    pub work_item_id: Option<i64>,
+    pub title: String,
+    pub session_title: Option<String>,
+    pub status: SessionStatus,
+    pub started_at: String,
+    pub completed_at: Option<String>,
+    pub content: Option<String>,
+}
+
+/// Session lifecycle status.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SessionStatus {
+    Active,
+    Completed,
+    Error,
+    Orphaned,
+}
+
+impl SessionStatus {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Active => "active",
+            Self::Completed => "completed",
+            Self::Error => "error",
+            Self::Orphaned => "orphaned",
+        }
+    }
+}
+
+impl std::fmt::Display for SessionStatus {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+impl std::str::FromStr for SessionStatus {
+    type Err = CoreError;
+    fn from_str(s: &str) -> Result<Self> {
+        match s {
+            "active" => Ok(Self::Active),
+            "completed" => Ok(Self::Completed),
+            "error" => Ok(Self::Error),
+            "orphaned" => Ok(Self::Orphaned),
+            _ => Err(WorkError::InvalidState(format!("invalid session status: {s}")).into()),
+        }
+    }
+}
+
+fn row_to_session(row: &rusqlite::Row) -> rusqlite::Result<ClaudeSession> {
+    let status_str: String = row.get("status")?;
+    Ok(ClaudeSession {
+        id: row.get("id")?,
+        work_item_id: row.get("work_item_id")?,
+        title: row.get("title")?,
+        session_title: row.get("session_title")?,
+        status: status_str.parse().unwrap_or(SessionStatus::Active),
+        started_at: row.get("started_at")?,
+        completed_at: row.get("completed_at")?,
+        content: row.get("content").ok(),
+    })
+}
+
+/// Create a new session (unlinked to a work item).
+pub fn create_session(db: &Database, title: &str, session_title: Option<&str>) -> Result<i64> {
+    db.conn().execute(
+        "INSERT INTO claude_sessions (title, session_title, status, started_at) \
+         VALUES (?, ?, 'active', datetime('now'))",
+        params![title, session_title],
+    )?;
+    Ok(db.conn().last_insert_rowid())
+}
+
+/// Get a session by id.
+pub fn get_session(db: &Database, id: i64) -> Result<Option<ClaudeSession>> {
+    let mut stmt = db.conn().prepare(
+        "SELECT id, work_item_id, title, session_title, status, started_at, completed_at, content \
+         FROM claude_sessions WHERE id = ?",
+    )?;
+    let mut rows = stmt.query_map(params![id], row_to_session)?;
+    match rows.next() {
+        Some(Ok(s)) => Ok(Some(s)),
+        Some(Err(e)) => Err(e.into()),
+        None => Ok(None),
+    }
+}
+
+/// Close a session (set status = completed).
+pub fn close_session(db: &Database, id: i64) -> Result<bool> {
+    let changed = db.conn().execute(
+        "UPDATE claude_sessions SET status = 'completed', completed_at = datetime('now') WHERE id = ?",
+        params![id],
+    )?;
+    Ok(changed > 0)
+}
+
+/// Close all active sessions for a work item.
+pub fn close_sessions_for_work_item(db: &Database, work_item_id: i64) -> Result<bool> {
+    let changed = db.conn().execute(
+        "UPDATE claude_sessions SET status = 'completed', completed_at = datetime('now') \
+         WHERE work_item_id = ? AND status = 'active'",
+        params![work_item_id],
+    )?;
+    Ok(changed > 0)
+}
+
+/// Link a session to a work item.
+pub fn link_session_to_work_item(
+    db: &Database,
+    session_id: i64,
+    work_item_id: i64,
+    title: &str,
+) -> Result<bool> {
+    let changed = db.conn().execute(
+        "UPDATE claude_sessions SET work_item_id = ?, title = ? \
+         WHERE id = ? AND work_item_id IS NULL",
+        params![work_item_id, title, session_id],
+    )?;
+    Ok(changed > 0)
+}
+
+/// Get active sessions for a work item.
+pub fn get_active_sessions_for_work_item(
+    db: &Database,
+    work_item_id: i64,
+) -> Result<Vec<ClaudeSession>> {
+    let mut stmt = db.conn().prepare(
+        "SELECT id, work_item_id, title, session_title, status, started_at, completed_at, content \
+         FROM claude_sessions WHERE work_item_id = ? AND status = 'active'",
+    )?;
+    let rows = stmt.query_map(params![work_item_id], row_to_session)?;
+    rows.map(|r| r.map_err(CoreError::from)).collect()
+}
+
+/// Get or create a session for a work item.
+/// Returns `(session, created)` — `created` is true if a new session was made.
+pub fn get_or_create_session(
+    db: &Database,
+    work_item_id: i64,
+    title: &str,
+) -> Result<(ClaudeSession, bool)> {
+    let existing = get_active_sessions_for_work_item(db, work_item_id)?;
+    if let Some(session) = existing.into_iter().next() {
+        return Ok((session, false));
+    }
+
+    db.conn().execute(
+        "INSERT INTO claude_sessions (work_item_id, title, status, started_at) \
+         VALUES (?, ?, 'active', datetime('now'))",
+        params![work_item_id, title],
+    )?;
+    let id = db.conn().last_insert_rowid();
+    let session = get_session(db, id)?.unwrap();
+    Ok((session, true))
+}
+
+/// Count active sessions.
+pub fn count_active_sessions(db: &Database) -> Result<i64> {
+    let count: i64 = db.conn().query_row(
+        "SELECT COUNT(*) FROM claude_sessions WHERE status = 'active'",
+        [],
+        |row| row.get(0),
+    )?;
+    Ok(count)
+}
+
+/// Get all active sessions ordered by most recent activity.
+pub fn get_all_active_sessions(db: &Database) -> Result<Vec<ClaudeSession>> {
+    let mut stmt = db.conn().prepare(
+        "SELECT id, work_item_id, title, session_title, status, started_at, completed_at, content \
+         FROM claude_sessions WHERE status = 'active' \
+         ORDER BY COALESCE(completed_at, started_at) DESC",
+    )?;
+    let rows = stmt.query_map([], row_to_session)?;
+    rows.map(|r| r.map_err(CoreError::from)).collect()
+}
+
+/// Update session content.
+pub fn set_session_content(db: &Database, id: i64, content: &str) -> Result<()> {
+    db.conn().execute(
+        "UPDATE claude_sessions SET content = ? WHERE id = ?",
+        params![content, id],
+    )?;
+    Ok(())
+}
+
+/// Clean up stale sessions older than `retention_days`.
+/// Removes orphaned sessions and old completed/error sessions.
+pub fn cleanup_stale_sessions(db: &Database, retention_days: i64) -> Result<usize> {
+    let days_str = retention_days.to_string();
+    let deleted = db.conn().execute(
+        "DELETE FROM claude_sessions \
+         WHERE status = 'orphaned' \
+            OR (status = 'completed' AND completed_at < datetime('now', '-' || ? || ' days')) \
+            OR (status = 'error' AND completed_at < datetime('now', '-' || ? || ' days'))",
+        params![days_str, days_str],
+    )?;
+    Ok(deleted)
+}
+
+// ---------------------------------------------------------------------------
+// Worktree Sessions (DB-backed)
+// ---------------------------------------------------------------------------
+
+/// A worktree session record.
+#[derive(Debug, Clone)]
+pub struct WorktreeSession {
+    pub id: i64,
+    pub worktree_path: String,
+    pub work_item_id: i64,
+    pub branch_name: String,
+    pub last_activity: String,
+}
+
+fn row_to_worktree_session(row: &rusqlite::Row) -> rusqlite::Result<WorktreeSession> {
+    Ok(WorktreeSession {
+        id: row.get("id")?,
+        worktree_path: row.get("worktree_path")?,
+        work_item_id: row.get("work_item_id")?,
+        branch_name: row.get("branch_name")?,
+        last_activity: row.get("last_activity")?,
+    })
+}
+
+/// Create or update a worktree session.
+pub fn upsert_worktree_session(
+    db: &Database,
+    worktree_path: &str,
+    work_item_id: i64,
+    branch_name: &str,
+) -> Result<()> {
+    db.conn().execute(
+        "INSERT INTO worktree_sessions (worktree_path, work_item_id, branch_name) \
+         VALUES (?, ?, ?) \
+         ON CONFLICT(worktree_path) DO UPDATE SET \
+           work_item_id = excluded.work_item_id, \
+           branch_name = excluded.branch_name, \
+           last_activity = CURRENT_TIMESTAMP",
+        params![worktree_path, work_item_id, branch_name],
+    )?;
+    Ok(())
+}
+
+/// Get a worktree session by path.
+pub fn get_worktree_session(db: &Database, worktree_path: &str) -> Result<Option<WorktreeSession>> {
+    let mut stmt = db.conn().prepare(
+        "SELECT * FROM worktree_sessions WHERE worktree_path = ?",
+    )?;
+    let mut rows = stmt.query_map(params![worktree_path], row_to_worktree_session)?;
+    match rows.next() {
+        Some(Ok(ws)) => Ok(Some(ws)),
+        Some(Err(e)) => Err(e.into()),
+        None => Ok(None),
+    }
+}
+
+/// Remove a worktree session.
+pub fn remove_worktree_session(db: &Database, worktree_path: &str) -> Result<()> {
+    db.conn().execute(
+        "DELETE FROM worktree_sessions WHERE worktree_path = ?",
+        params![worktree_path],
+    )?;
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Session file (filesystem)
+// ---------------------------------------------------------------------------
+
+/// Map a mode name to its corresponding skill name.
+pub fn mode_to_skill_name(mode: &str) -> String {
+    match mode {
+        "speed" => "speed-mode".to_string(),
+        "stable" => "stable-mode".to_string(),
+        "production" => "production-mode".to_string(),
+        other => format!("{other}-mode"),
+    }
+}
+
+/// Get the path to the session file: `<cwd>/.claude/session.md`.
+pub fn session_file_path(cwd: &Path) -> PathBuf {
+    cwd.join(".claude").join("session.md")
+}
+
+/// Write a session file for mode/context resumption in a worktree.
+///
+/// The session file is `.claude/session.md` (gitignored) and tells Claude Code
+/// which skill to resume when reopening the worktree.
+pub fn write_session_file(
+    cwd: &Path,
+    work_item_id: i64,
+    title: &str,
+    item_type: &str,
+    status: &str,
+    mode: &str,
+    epic_id: Option<i64>,
+    epic_title: Option<&str>,
+) -> Result<()> {
+    let path = session_file_path(cwd);
+
+    // Ensure .claude directory exists
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+
+    let skill_name = mode_to_skill_name(mode);
+
+    let mut content = String::new();
+    content.push_str("# Current Work Session\n\n");
+    content.push_str("## Work Context\n\n");
+    content.push_str(&format!(
+        "Working on: [#{}] {} ({})\n",
+        work_item_id, title, item_type
+    ));
+
+    if let (Some(eid), Some(etitle)) = (epic_id, epic_title) {
+        content.push_str(&format!("Epic: [#{}] {}\n", eid, etitle));
+    }
+
+    content.push_str(&format!("Mode: {}\n", mode));
+    content.push_str(&format!("Status: {}\n", status));
+    content.push_str("\n## IMMEDIATE ACTION REQUIRED\n\n");
+    content.push_str(&format!(
+        "You are resuming work on a {} in {} mode.\n\n",
+        item_type, mode
+    ));
+    content.push_str(&format!(
+        "**Invoke the {} skill now to continue the workflow.**\n",
+        skill_name
+    ));
+
+    std::fs::write(&path, content)?;
+    Ok(())
+}
+
+/// Clear the session file.
+pub fn clear_session_file(cwd: &Path) -> Result<()> {
+    let path = session_file_path(cwd);
+    if path.exists() {
+        std::fs::remove_file(&path)?;
+    }
+    Ok(())
+}
+
+/// Read the session file content.
+pub fn read_session_file(cwd: &Path) -> Result<Option<String>> {
+    let path = session_file_path(cwd);
+    if path.exists() {
+        Ok(Some(std::fs::read_to_string(&path)?))
+    } else {
+        Ok(None)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Current work (from git branch)
+// ---------------------------------------------------------------------------
+
+/// Extract a work item ID from a branch name.
+///
+/// Matches patterns like `feature/work-123-title` or `123-title`.
+pub fn extract_work_item_id_from_branch(branch: &str) -> Option<i64> {
+    // Try feature/work-{id}-... pattern
+    if let Some(rest) = branch.strip_prefix("feature/work-") {
+        if let Some(id_str) = rest.split('-').next() {
+            if let Ok(id) = id_str.parse::<i64>() {
+                return Some(id);
+            }
+        }
+    }
+
+    // Try bare {id}-... pattern
+    if let Some(id_str) = branch.split('-').next() {
+        if let Ok(id) = id_str.parse::<i64>() {
+            return Some(id);
+        }
+    }
+
+    None
+}
+
+/// Get the current work item by inspecting the git branch name.
+/// Returns `None` if not in a git repo, on a non-work branch, or item not found.
+pub fn get_current_work_from_branch(db: &Database, cwd: &Path) -> Result<Option<i64>> {
+    let branch = match git::current_branch(cwd) {
+        Ok(Some(b)) => b,
+        _ => return Ok(None),
+    };
+
+    match extract_work_item_id_from_branch(&branch) {
+        Some(id) => {
+            // Verify the work item exists and is in_progress
+            let exists: bool = db
+                .conn()
+                .query_row(
+                    "SELECT COUNT(*) > 0 FROM work_items WHERE id = ? AND status = 'in_progress'",
+                    params![id],
+                    |row| row.get(0),
+                )
+                .unwrap_or(false);
+
+            if exists {
+                Ok(Some(id))
+            } else {
+                Ok(None)
+            }
+        }
+        None => Ok(None),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::db::Database;
+    use tempfile::TempDir;
+
+    fn setup_db() -> (TempDir, Database) {
+        let dir = TempDir::new().unwrap();
+        let db_path = dir.path().join("work.db");
+        let db = Database::open_path_unchecked(&db_path).unwrap();
+        (dir, db)
+    }
+
+    #[test]
+    fn create_and_get_session() {
+        let (_dir, db) = setup_db();
+
+        let id = create_session(&db, "Test session", Some("My Title")).unwrap();
+        assert!(id > 0);
+
+        let session = get_session(&db, id).unwrap().unwrap();
+        assert_eq!(session.title, "Test session");
+        assert_eq!(session.session_title.as_deref(), Some("My Title"));
+        assert_eq!(session.status, SessionStatus::Active);
+        assert!(session.work_item_id.is_none());
+    }
+
+    #[test]
+    fn close_session_works() {
+        let (_dir, db) = setup_db();
+
+        let id = create_session(&db, "Test", None).unwrap();
+        assert!(close_session(&db, id).unwrap());
+
+        let session = get_session(&db, id).unwrap().unwrap();
+        assert_eq!(session.status, SessionStatus::Completed);
+        assert!(session.completed_at.is_some());
+    }
+
+    #[test]
+    fn link_session_to_work_item_works() {
+        let (_dir, db) = setup_db();
+
+        // Create a work item
+        db.conn()
+            .execute(
+                "INSERT INTO work_items (id, type, title, status) VALUES (1, 'chore', 'My chore', 'in_progress')",
+                [],
+            )
+            .unwrap();
+
+        let id = create_session(&db, "Unlinked", None).unwrap();
+        assert!(link_session_to_work_item(&db, id, 1, "Linked title").unwrap());
+
+        let session = get_session(&db, id).unwrap().unwrap();
+        assert_eq!(session.work_item_id, Some(1));
+        assert_eq!(session.title, "Linked title");
+    }
+
+    #[test]
+    fn get_or_create_session_reuses_existing() {
+        let (_dir, db) = setup_db();
+
+        db.conn()
+            .execute(
+                "INSERT INTO work_items (id, type, title, status) VALUES (1, 'chore', 'Chore', 'in_progress')",
+                [],
+            )
+            .unwrap();
+
+        let (s1, created1) = get_or_create_session(&db, 1, "Chore").unwrap();
+        assert!(created1);
+
+        let (s2, created2) = get_or_create_session(&db, 1, "Chore").unwrap();
+        assert!(!created2);
+        assert_eq!(s1.id, s2.id);
+    }
+
+    #[test]
+    fn count_and_get_all_active() {
+        let (_dir, db) = setup_db();
+
+        create_session(&db, "Session 1", None).unwrap();
+        create_session(&db, "Session 2", None).unwrap();
+        let id3 = create_session(&db, "Session 3", None).unwrap();
+        close_session(&db, id3).unwrap();
+
+        assert_eq!(count_active_sessions(&db).unwrap(), 2);
+        assert_eq!(get_all_active_sessions(&db).unwrap().len(), 2);
+    }
+
+    #[test]
+    fn session_content_roundtrip() {
+        let (_dir, db) = setup_db();
+
+        let id = create_session(&db, "Test", None).unwrap();
+        set_session_content(&db, id, "hello world").unwrap();
+
+        let session = get_session(&db, id).unwrap().unwrap();
+        assert_eq!(session.content.as_deref(), Some("hello world"));
+    }
+
+    #[test]
+    fn extract_work_item_id_from_branch_works() {
+        assert_eq!(
+            extract_work_item_id_from_branch("feature/work-1199-port-crud"),
+            Some(1199)
+        );
+        assert_eq!(
+            extract_work_item_id_from_branch("42-some-title"),
+            Some(42)
+        );
+        assert_eq!(extract_work_item_id_from_branch("main"), None);
+        assert_eq!(extract_work_item_id_from_branch("develop"), None);
+    }
+
+    #[test]
+    fn mode_to_skill_name_works() {
+        assert_eq!(mode_to_skill_name("speed"), "speed-mode");
+        assert_eq!(mode_to_skill_name("stable"), "stable-mode");
+        assert_eq!(mode_to_skill_name("production"), "production-mode");
+        assert_eq!(mode_to_skill_name("custom"), "custom-mode");
+    }
+
+    #[test]
+    fn session_file_write_and_read() {
+        let dir = TempDir::new().unwrap();
+
+        write_session_file(
+            dir.path(),
+            42,
+            "My chore",
+            "chore",
+            "in_progress",
+            "speed",
+            Some(10),
+            Some("Epic title"),
+        )
+        .unwrap();
+
+        let content = read_session_file(dir.path()).unwrap().unwrap();
+        assert!(content.contains("[#42] My chore"));
+        assert!(content.contains("Mode: speed"));
+        assert!(content.contains("Epic: [#10] Epic title"));
+        assert!(content.contains("speed-mode"));
+    }
+
+    #[test]
+    fn session_file_clear() {
+        let dir = TempDir::new().unwrap();
+
+        write_session_file(dir.path(), 1, "Test", "chore", "in_progress", "speed", None, None)
+            .unwrap();
+        assert!(read_session_file(dir.path()).unwrap().is_some());
+
+        clear_session_file(dir.path()).unwrap();
+        assert!(read_session_file(dir.path()).unwrap().is_none());
+    }
+
+    #[test]
+    fn worktree_session_upsert_and_get() {
+        let (_dir, db) = setup_db();
+
+        db.conn()
+            .execute(
+                "INSERT INTO work_items (id, type, title, status) VALUES (1, 'chore', 'Chore', 'in_progress')",
+                [],
+            )
+            .unwrap();
+
+        upsert_worktree_session(&db, "/tmp/wt-1", 1, "feature/work-1-chore").unwrap();
+
+        let ws = get_worktree_session(&db, "/tmp/wt-1").unwrap().unwrap();
+        assert_eq!(ws.work_item_id, 1);
+        assert_eq!(ws.branch_name, "feature/work-1-chore");
+
+        // Upsert again should update
+        upsert_worktree_session(&db, "/tmp/wt-1", 1, "feature/work-1-updated").unwrap();
+        let ws = get_worktree_session(&db, "/tmp/wt-1").unwrap().unwrap();
+        assert_eq!(ws.branch_name, "feature/work-1-updated");
+
+        remove_worktree_session(&db, "/tmp/wt-1").unwrap();
+        assert!(get_worktree_session(&db, "/tmp/wt-1").unwrap().is_none());
+    }
+}