jettypod 4.4.118 → 4.4.121

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

@@ -0,0 +1,458 @@
+//! Git operations — shells out to the git CLI.
+//!
+//! Decision D1: We use `std::process::Command` to call `git` rather than
+//! libgit2/git2-rs, because git2 has incomplete worktree support and
+//! the CLI gives us exact parity with the Node.js implementation.
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use crate::error::{GitError, Result};
+
+// ---------------------------------------------------------------------------
+// Low-level git command helpers
+// ---------------------------------------------------------------------------
+
+/// Run a git command in `cwd`, returning trimmed stdout on success.
+/// Pipes both stdout and stderr to avoid stealing the terminal.
+pub fn run(cwd: &Path, args: &[&str]) -> Result<String> {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(cwd)
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .output()
+        .map_err(|e| GitError::NotAvailable(format!("{e}")))?;
+
+    if output.status.success() {
+        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+    } else {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        Err(GitError::CommandFailed {
+            args: args.join(" "),
+            stderr,
+        }
+        .into())
+    }
+}
+
+/// Run a git command that may legitimately fail (e.g. branch already exists).
+/// Returns Ok(Some(stdout)) on success, Ok(None) on non-zero exit.
+pub fn try_run(cwd: &Path, args: &[&str]) -> Result<Option<String>> {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(cwd)
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .output()
+        .map_err(|e| GitError::NotAvailable(format!("{e}")))?;
+
+    if output.status.success() {
+        Ok(Some(String::from_utf8_lossy(&output.stdout).trim().to_string()))
+    } else {
+        Ok(None)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Queries
+// ---------------------------------------------------------------------------
+
+/// Check if git is installed.
+pub fn is_installed() -> bool {
+    Command::new("git")
+        .arg("--version")
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+/// Check if `cwd` is inside a git repository.
+pub fn is_repo(cwd: &Path) -> bool {
+    try_run(cwd, &["rev-parse", "--git-dir"])
+        .ok()
+        .flatten()
+        .is_some()
+}
+
+/// Get the current branch name, or `None` if in detached HEAD state.
+pub fn current_branch(cwd: &Path) -> Result<Option<String>> {
+    let branch = run(cwd, &["rev-parse", "--abbrev-ref", "HEAD"])?;
+    if branch == "HEAD" {
+        Ok(None) // detached HEAD
+    } else {
+        Ok(Some(branch))
+    }
+}
+
+/// Get `--show-toplevel` for `cwd`.
+pub fn toplevel(cwd: &Path) -> Result<PathBuf> {
+    let s = run(cwd, &["rev-parse", "--show-toplevel"])?;
+    Ok(PathBuf::from(s))
+}
+
+/// Get `git status --porcelain` output. Empty string means clean.
+pub fn status_porcelain(cwd: &Path) -> Result<String> {
+    run(cwd, &["status", "--porcelain"])
+}
+
+/// List changed files between two refs.
+pub fn diff_names(cwd: &Path, from: &str, to: &str) -> Result<Vec<String>> {
+    let output = run(cwd, &["diff", "--name-only", from, to])?;
+    Ok(output.lines().map(|s| s.to_string()).collect())
+}
+
+// ---------------------------------------------------------------------------
+// Git root detection (safe, cached-friendly)
+// ---------------------------------------------------------------------------
+
+/// Find the **main** repository root (never a worktree).
+///
+/// Uses `--git-common-dir` to find the shared `.git` directory, resolves to
+/// an absolute path, then runs safety checks:
+/// 1. `.jettypod` directory must exist in the root
+/// 2. `--show-toplevel` must match the computed root
+/// 3. Path must not contain `.jettypod-work`
+pub fn find_main_repo_root(cwd: &Path) -> Result<PathBuf> {
+    let git_common = run(cwd, &["rev-parse", "--git-common-dir"])?;
+
+    let abs_git_dir = if Path::new(&git_common).is_absolute() {
+        PathBuf::from(&git_common)
+    } else {
+        cwd.join(&git_common)
+    };
+
+    // The main repo root is the parent of the .git directory
+    let git_root = abs_git_dir
+        .parent()
+        .ok_or_else(|| GitError::Other("cannot determine parent of .git dir".into()))?;
+
+    // Canonicalize to handle /var ↔ /private/var on macOS
+    let git_root = git_root
+        .canonicalize()
+        .map_err(|e| GitError::Other(format!("canonicalize git root: {e}")))?;
+
+    // Safety check 1: .jettypod must exist
+    let jettypod_dir = git_root.join(".jettypod");
+    if !jettypod_dir.exists() {
+        return Err(GitError::NotARepo(format!(
+            "SAFETY: .jettypod not found in {} — may be a worktree",
+            git_root.display()
+        ))
+        .into());
+    }
+
+    // Safety check 2: --show-toplevel must match
+    let top = toplevel(&git_root)?;
+    let top_canon = top
+        .canonicalize()
+        .map_err(|e| GitError::Other(format!("canonicalize toplevel: {e}")))?;
+    if top_canon != git_root {
+        return Err(GitError::NotARepo(format!(
+            "SAFETY: computed root {} != toplevel {}",
+            git_root.display(),
+            top_canon.display()
+        ))
+        .into());
+    }
+
+    // Safety check 3: must not be inside a worktree path
+    let root_str = git_root.to_string_lossy();
+    if root_str.contains(".jettypod-work") {
+        return Err(GitError::NotARepo(
+            "SAFETY: computed root is inside .jettypod-work".into(),
+        )
+        .into());
+    }
+
+    Ok(git_root)
+}
+
+// ---------------------------------------------------------------------------
+// Branch helpers
+// ---------------------------------------------------------------------------
+
+/// Validate a branch name against git naming rules.
+pub fn validate_branch_name(name: &str) -> Result<()> {
+    if name.is_empty() {
+        return Err(GitError::InvalidBranch("branch name must be non-empty".into()).into());
+    }
+    if name.contains(' ') {
+        return Err(GitError::InvalidBranch("branch name cannot contain spaces".into()).into());
+    }
+    if name.starts_with('-') || name.starts_with('.') {
+        return Err(GitError::InvalidBranch("branch name cannot start with - or .".into()).into());
+    }
+    if name.chars().any(|c| "~^:\\?*[".contains(c)) {
+        return Err(
+            GitError::InvalidBranch("branch name contains invalid characters".into()).into(),
+        );
+    }
+    Ok(())
+}
+
+/// Convert text to a git-safe slug: lowercase, hyphens, alphanumeric only.
+pub fn slugify(text: &str) -> String {
+    text.to_lowercase()
+        .split_whitespace()
+        .collect::<Vec<_>>()
+        .join("-")
+        .chars()
+        .filter(|c| c.is_ascii_alphanumeric() || *c == '-')
+        .collect()
+}
+
+/// Create a branch name from work item id + title.
+/// Returns `feature/work-{id}-{slug}`.
+pub fn branch_name_for(id: i64, title: &str) -> String {
+    format!("feature/work-{}-{}", id, slugify(title))
+}
+
+/// Create or checkout a branch.
+pub fn create_or_checkout_branch(cwd: &Path, name: &str) -> Result<()> {
+    validate_branch_name(name)?;
+
+    // Try creating new branch
+    if try_run(cwd, &["checkout", "-b", name])?.is_some() {
+        return Ok(());
+    }
+
+    // Branch exists — checkout
+    run(cwd, &["checkout", name])?;
+    Ok(())
+}
+
+/// Delete a branch (force).
+pub fn delete_branch(cwd: &Path, name: &str) -> Result<()> {
+    run(cwd, &["branch", "-D", name])?;
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Worktree git commands (low-level)
+// ---------------------------------------------------------------------------
+
+/// Create a git worktree at `path` on a new branch from `base_branch`.
+pub fn worktree_add(
+    repo_root: &Path,
+    branch: &str,
+    path: &Path,
+    base_branch: &str,
+) -> Result<()> {
+    let path_str = path.to_string_lossy();
+    run(
+        repo_root,
+        &["worktree", "add", "-b", branch, &path_str, base_branch],
+    )?;
+    Ok(())
+}
+
+/// Remove a git worktree. Returns Ok(()) even if the directory is already gone.
+pub fn worktree_remove(repo_root: &Path, path: &Path) -> Result<()> {
+    let path_str = path.to_string_lossy();
+
+    // Stage 1: standard remove
+    if try_run(repo_root, &["worktree", "remove", &path_str])?.is_some() {
+        return Ok(());
+    }
+
+    // Stage 2: forced remove
+    if try_run(repo_root, &["worktree", "remove", "--force", &path_str])?.is_some() {
+        return Ok(());
+    }
+
+    // Stage 3: directory removal + prune
+    if path.exists() {
+        std::fs::remove_dir_all(path)?;
+    }
+    let _ = try_run(repo_root, &["worktree", "prune"]);
+
+    Ok(())
+}
+
+/// Prune stale worktree metadata.
+pub fn worktree_prune(repo_root: &Path) -> Result<()> {
+    run(repo_root, &["worktree", "prune"])?;
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Merge helpers
+// ---------------------------------------------------------------------------
+
+/// Push the current branch to origin with upstream tracking.
+pub fn push_with_upstream(cwd: &Path, branch: &str) -> Result<()> {
+    run(cwd, &["push", "-u", "origin", branch])?;
+    Ok(())
+}
+
+/// Fetch from origin.
+pub fn fetch_origin(cwd: &Path) -> Result<()> {
+    run(cwd, &["fetch", "origin"])?;
+    Ok(())
+}
+
+/// Pull the given branch from origin.
+pub fn pull_origin(cwd: &Path, branch: &str) -> Result<()> {
+    run(cwd, &["pull", "origin", branch])?;
+    Ok(())
+}
+
+/// Merge `branch` with `--no-ff` into the current branch.
+/// Returns Ok(()) on success, or an error with conflict details.
+pub fn merge_no_ff(cwd: &Path, branch: &str) -> Result<()> {
+    run(cwd, &["merge", "--no-ff", branch])?;
+    Ok(())
+}
+
+/// Abort an in-progress merge.
+pub fn merge_abort(cwd: &Path) -> Result<()> {
+    let _ = try_run(cwd, &["merge", "--abort"]);
+    Ok(())
+}
+
+/// Checkout a branch.
+pub fn checkout(cwd: &Path, branch: &str) -> Result<()> {
+    run(cwd, &["checkout", branch])?;
+    Ok(())
+}
+
+/// Stage all changes and commit with message.
+pub fn add_and_commit(cwd: &Path, message: &str) -> Result<()> {
+    run(cwd, &["add", "."])?;
+    run(cwd, &["commit", "-m", message])?;
+    Ok(())
+}
+
+/// Push the current branch to origin.
+pub fn push_origin(cwd: &Path, branch: &str) -> Result<()> {
+    run(cwd, &["push", "origin", branch])?;
+    Ok(())
+}
+
+/// List untracked files (respecting .gitignore).
+pub fn untracked_files(cwd: &Path) -> Result<Vec<String>> {
+    let output = run(cwd, &["ls-files", "--others", "--exclude-standard"])?;
+    if output.is_empty() {
+        Ok(Vec::new())
+    } else {
+        Ok(output.lines().map(|s| s.to_string()).collect())
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    fn init_repo() -> TempDir {
+        let dir = TempDir::new().unwrap();
+        run(dir.path(), &["init"]).unwrap();
+        run(dir.path(), &["config", "user.email", "test@test.com"]).unwrap();
+        run(dir.path(), &["config", "user.name", "Test"]).unwrap();
+        // Create initial commit so branches work
+        std::fs::write(dir.path().join("README.md"), "init").unwrap();
+        run(dir.path(), &["add", "."]).unwrap();
+        run(dir.path(), &["commit", "-m", "init"]).unwrap();
+        dir
+    }
+
+    #[test]
+    fn is_installed_returns_true() {
+        assert!(is_installed());
+    }
+
+    #[test]
+    fn is_repo_works() {
+        let dir = init_repo();
+        assert!(is_repo(dir.path()));
+
+        let tmp = TempDir::new().unwrap();
+        assert!(!is_repo(tmp.path()));
+    }
+
+    #[test]
+    fn current_branch_on_main() {
+        let dir = init_repo();
+        let branch = current_branch(dir.path()).unwrap();
+        // Could be "main" or "master" depending on git config
+        assert!(branch.is_some());
+    }
+
+    #[test]
+    fn slugify_works() {
+        assert_eq!(slugify("Hello World"), "hello-world");
+        assert_eq!(slugify("Port work CRUD!"), "port-work-crud");
+        assert_eq!(slugify("Add feature #42"), "add-feature-42");
+        assert_eq!(slugify("  spaces  everywhere  "), "spaces-everywhere");
+    }
+
+    #[test]
+    fn branch_name_for_works() {
+        assert_eq!(
+            branch_name_for(1199, "Port work item CRUD"),
+            "feature/work-1199-port-work-item-crud"
+        );
+    }
+
+    #[test]
+    fn validate_branch_name_catches_invalid() {
+        assert!(validate_branch_name("valid-name").is_ok());
+        assert!(validate_branch_name("feature/ok").is_ok());
+        assert!(validate_branch_name("").is_err());
+        assert!(validate_branch_name("has space").is_err());
+        assert!(validate_branch_name("-leading").is_err());
+        assert!(validate_branch_name(".leading").is_err());
+        assert!(validate_branch_name("bad~char").is_err());
+        assert!(validate_branch_name("bad[char").is_err());
+    }
+
+    #[test]
+    fn create_or_checkout_branch_works() {
+        let dir = init_repo();
+        create_or_checkout_branch(dir.path(), "test-branch").unwrap();
+        let branch = current_branch(dir.path()).unwrap().unwrap();
+        assert_eq!(branch, "test-branch");
+
+        // Switch back, then checkout existing branch
+        run(dir.path(), &["checkout", "master"]).ok();
+        run(dir.path(), &["checkout", "main"]).ok();
+        create_or_checkout_branch(dir.path(), "test-branch").unwrap();
+        let branch = current_branch(dir.path()).unwrap().unwrap();
+        assert_eq!(branch, "test-branch");
+    }
+
+    #[test]
+    fn status_porcelain_on_clean_repo() {
+        let dir = init_repo();
+        let status = status_porcelain(dir.path()).unwrap();
+        assert!(status.is_empty());
+    }
+
+    #[test]
+    fn worktree_add_and_remove() {
+        let dir = init_repo();
+        let wt_path = dir.path().join("wt-test");
+        let default_branch = current_branch(dir.path()).unwrap().unwrap();
+
+        worktree_add(dir.path(), "wt-branch", &wt_path, &default_branch).unwrap();
+        assert!(wt_path.exists());
+
+        worktree_remove(dir.path(), &wt_path).unwrap();
+        assert!(!wt_path.exists());
+    }
+
+    #[test]
+    fn untracked_files_lists_new_files() {
+        let dir = init_repo();
+        std::fs::write(dir.path().join("new.txt"), "hello").unwrap();
+        let files = untracked_files(dir.path()).unwrap();
+        assert!(files.contains(&"new.txt".to_string()));
+    }
+}

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

@@ -0,0 +1,20 @@
+//! JettyPod core business logic.
+//!
+//! This crate contains all data operations previously handled by the
+//! Node.js sidecar: database access, work item management, git operations,
+//! configuration, auth, sessions, WebSocket broadcasting, and skills sync.
+//!
+//! Used by both the Tauri desktop app and the standalone CLI.
+
+pub mod auth;
+pub mod config;
+pub mod db;
+pub mod error;
+pub mod git;
+pub mod sessions;
+pub mod skills;
+pub mod work;
+pub mod worktree;
+pub mod ws;
+
+pub use error::{CoreError, Result};