feat: add interactive conventional commit workflow with jj-lib backend

Replace CLI executor with jj-lib integration, implement full interactive
commit workflow via prompts, and add mock infrastructure for testing.
Add CLI integration tests and error handling tests.

src/jj/lib_executor.rs

@@ -0,0 +1,288 @@
+//! jj-lib implementation of JjExecutor
+//!
+//! This implementation uses jj-lib 0.39.0 directly for repository detection
+//! and commit description, replacing the earlier shell-out approach.
+
+use std::path::{Path, PathBuf};
+
+use jj_lib::{
+    config::StackedConfig,
+    ref_name::WorkspaceName,
+    repo::{Repo, StoreFactories},
+    settings::UserSettings,
+    workspace::{Workspace, default_working_copy_factories},
+};
+
+use crate::error::Error;
+use crate::jj::JjExecutor;
+
+/// JjLib provides jj repository operations via jj-lib 0.39.0
+#[derive(Debug)]
+pub struct JjLib {
+    working_dir: PathBuf,
+}
+
+impl JjLib {
+    /// Create a new JjLib instance using the current working directory
+    pub fn new() -> Result<Self, Error> {
+        let working_dir = std::env::current_dir()?;
+        Ok(Self { working_dir })
+    }
+
+    /// Create a new JjLib instance with a specific working directory
+    pub fn with_working_dir(path: impl AsRef<Path>) -> Self {
+        Self {
+            working_dir: path.as_ref().to_path_buf(),
+        }
+    }
+
+    fn load_settings() -> Result<UserSettings, Error> {
+        let config = StackedConfig::with_defaults();
+        UserSettings::from_config(config).map_err(|_| Error::FailedReadingConfig)
+    }
+}
+
+#[async_trait::async_trait(?Send)]
+impl JjExecutor for JjLib {
+    async fn is_repository(&self) -> Result<bool, Error> {
+        let settings = Self::load_settings()?;
+        let store_factories = StoreFactories::default();
+        let wc_factories = default_working_copy_factories();
+        Ok(Workspace::load(
+            &settings,
+            &self.working_dir,
+            &store_factories,
+            &wc_factories,
+        )
+        .is_ok())
+    }
+
+    async fn describe(&self, message: &str) -> Result<(), Error> {
+        let settings = Self::load_settings()?;
+        let store_factories = StoreFactories::default();
+        let wc_factories = default_working_copy_factories();
+
+        let workspace = Workspace::load(
+            &settings,
+            &self.working_dir,
+            &store_factories,
+            &wc_factories,
+        )
+        .map_err(|_| Error::NotARepository)?;
+
+        let repo =
+            workspace
+                .repo_loader()
+                .load_at_head()
+                .await
+                .map_err(|e| Error::JjOperation {
+                    context: e.to_string(),
+                })?;
+
+        let mut tx = repo.start_transaction();
+
+        let wc_commit_id = tx
+            .repo()
+            .view()
+            .get_wc_commit_id(WorkspaceName::DEFAULT)
+            .ok_or_else(|| Error::JjOperation {
+                context: "No working copy commit found".to_string(),
+            })?
+            .clone();
+
+        let wc_commit =
+            tx.repo()
+                .store()
+                .get_commit(&wc_commit_id)
+                .map_err(|e| Error::JjOperation {
+                    context: e.to_string(),
+                })?;
+
+        tx.repo_mut()
+            .rewrite_commit(&wc_commit)
+            .set_description(message)
+            .write()
+            .await
+            .map_err(|e| Error::JjOperation {
+                context: e.to_string(),
+            })?;
+
+        tx.repo_mut()
+            .rebase_descendants()
+            .await
+            .map_err(|e| Error::JjOperation {
+                context: format!("{e:?}"),
+            })?;
+
+        tx.commit("jj-cz: update commit description")
+            .await
+            .map_err(|e| Error::JjOperation {
+                context: e.to_string(),
+            })?;
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::process::Command;
+
+    /// Initialize a jj repository in the given directory using `jj git init`
+    fn init_jj_repo(dir: &Path) -> std::io::Result<()> {
+        let output = Command::new("jj")
+            .args(["git", "init"])
+            .current_dir(dir)
+            .output()?;
+
+        if !output.status.success() {
+            return Err(std::io::Error::other(format!(
+                "jj git init failed: {}",
+                String::from_utf8_lossy(&output.stderr)
+            )));
+        }
+        Ok(())
+    }
+
+    /// Get the current commit description from a jj repository
+    fn get_commit_description(dir: &Path) -> std::io::Result<String> {
+        let output = Command::new("jj")
+            .args(["log", "-r", "@", "--no-graph", "-T", "description"])
+            .current_dir(dir)
+            .output()?;
+
+        if !output.status.success() {
+            return Err(std::io::Error::other(format!(
+                "jj log failed: {}",
+                String::from_utf8_lossy(&output.stderr)
+            )));
+        }
+        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+    }
+
+    #[tokio::test]
+    async fn is_repository_returns_true_inside_jj_repo() {
+        let temp_dir = assert_fs::TempDir::new().unwrap();
+        init_jj_repo(temp_dir.path()).expect("Failed to init jj repo");
+
+        let executor = JjLib::with_working_dir(temp_dir.path());
+        let result = executor.is_repository().await;
+
+        assert!(result.is_ok());
+        assert!(result.unwrap());
+    }
+
+    #[tokio::test]
+    async fn is_repository_returns_false_outside_jj_repo() {
+        let temp_dir = assert_fs::TempDir::new().unwrap();
+
+        let executor = JjLib::with_working_dir(temp_dir.path());
+        let result = executor.is_repository().await;
+
+        assert!(result.is_ok());
+        assert!(!result.unwrap());
+    }
+
+    #[tokio::test]
+    async fn describe_updates_commit_description() {
+        let temp_dir = assert_fs::TempDir::new().unwrap();
+        init_jj_repo(temp_dir.path()).expect("Failed to init jj repo");
+
+        let test_message = "test: initial commit";
+        let executor = JjLib::with_working_dir(temp_dir.path());
+
+        let result = executor.describe(test_message).await;
+        assert!(result.is_ok(), "describe failed: {result:?}");
+
+        let actual = get_commit_description(temp_dir.path()).expect("Failed to get description");
+        assert_eq!(actual, test_message);
+    }
+
+    #[tokio::test]
+    async fn describe_handles_special_characters() {
+        let temp_dir = assert_fs::TempDir::new().unwrap();
+        init_jj_repo(temp_dir.path()).expect("Failed to init jj repo");
+
+        let test_message = "feat: add feature with special chars !@#$%^&*()";
+        let executor = JjLib::with_working_dir(temp_dir.path());
+
+        let result = executor.describe(test_message).await;
+        assert!(result.is_ok());
+
+        let actual = get_commit_description(temp_dir.path()).expect("Failed to get description");
+        assert_eq!(actual, test_message);
+    }
+
+    #[tokio::test]
+    async fn describe_handles_unicode() {
+        let temp_dir = assert_fs::TempDir::new().unwrap();
+        init_jj_repo(temp_dir.path()).expect("Failed to init jj repo");
+
+        let test_message = "docs: add unicode support 🎉 🚀";
+        let executor = JjLib::with_working_dir(temp_dir.path());
+
+        let result = executor.describe(test_message).await;
+        assert!(result.is_ok());
+
+        let actual = get_commit_description(temp_dir.path()).expect("Failed to get description");
+        assert_eq!(actual, test_message);
+    }
+
+    #[tokio::test]
+    async fn describe_handles_multiline_message() {
+        let temp_dir = assert_fs::TempDir::new().unwrap();
+        init_jj_repo(temp_dir.path()).expect("Failed to init jj repo");
+
+        let test_message = "feat: add feature\n\nThis is a multiline\ndescription";
+        let executor = JjLib::with_working_dir(temp_dir.path());
+
+        let result = executor.describe(test_message).await;
+        assert!(result.is_ok());
+
+        let actual = get_commit_description(temp_dir.path()).expect("Failed to get description");
+        assert_eq!(actual, test_message);
+    }
+
+    #[tokio::test]
+    async fn describe_fails_outside_repo() {
+        let temp_dir = assert_fs::TempDir::new().unwrap();
+
+        let executor = JjLib::with_working_dir(temp_dir.path());
+        let result = executor.describe("test: should fail").await;
+
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), Error::NotARepository));
+    }
+
+    #[tokio::test]
+    async fn describe_can_be_called_multiple_times() {
+        let temp_dir = assert_fs::TempDir::new().unwrap();
+        init_jj_repo(temp_dir.path()).expect("Failed to init jj repo");
+
+        let executor = JjLib::with_working_dir(temp_dir.path());
+
+        executor
+            .describe("feat: first commit")
+            .await
+            .expect("First describe failed");
+        let desc1 =
+            get_commit_description(temp_dir.path()).expect("Failed to get first description");
+        assert_eq!(desc1, "feat: first commit");
+
+        executor
+            .describe("feat: updated commit")
+            .await
+            .expect("Second describe failed");
+        let desc2 =
+            get_commit_description(temp_dir.path()).expect("Failed to get second description");
+        assert_eq!(desc2, "feat: updated commit");
+    }
+
+    #[test]
+    fn jj_lib_implements_jj_executor_trait() {
+        let lib = JjLib::with_working_dir(std::path::Path::new("."));
+        fn accepts_executor(_: impl JjExecutor) {}
+        accepts_executor(lib);
+    }
+}