but-worktrees-crate

but-worktrees-database
Stubbed CLI

Author: Caleb-T-Owens

Cargo.lock

@@ -0,0 +1,2 @@
+-- Drop worktrees table
+DROP TABLE worktrees;

crates/but-db/migrations/2025-10-13-092749_worktrees/down.sql

@@ -0,0 +1,9 @@
+-- Create worktrees table
+CREATE TABLE `worktrees`(
+	`id` TEXT NOT NULL PRIMARY KEY,
+	`base` TEXT NOT NULL,
+	`path` TEXT NOT NULL,
+	`source` TEXT NOT NULL
+);
+
+CREATE INDEX index_worktrees_on_path ON worktrees (path);

crates/but-db/migrations/2025-10-13-092749_worktrees/up.sql

@@ -19,6 +19,8 @@ mod file_write_locks;
 pub use file_write_locks::FileWriteLock;
 mod workspace_rules;
 pub use workspace_rules::WorkspaceRule;
+mod worktrees;
+pub use worktrees::{Worktree, WorktreeSource};
 
 use diesel_migrations::{EmbeddedMigrations, MigrationHarness, embed_migrations};
 pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations");

crates/but-db/src/lib.rs

@@ -86,3 +86,12 @@ diesel::table! {
         approved -> Nullable<Bool>,
     }
 }
+
+diesel::table! {
+    worktrees (id) {
+        id -> Text,
+        base -> Text,
+        path -> Text,
+        source -> Text,
+    }
+}

crates/but-db/src/schema.rs

@@ -0,0 +1,62 @@
+use diesel::{ExpressionMethods, Identifiable, OptionalExtension as _, QueryDsl, RunQueryDsl};
+
+use crate::DbHandle;
+use crate::schema::worktrees::dsl::worktrees;
+
+use diesel::prelude::{Insertable, Queryable, Selectable};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum WorktreeSource {
+    Branch(String),
+}
+
+#[derive(
+    Debug, Clone, PartialEq, Serialize, Deserialize, Queryable, Selectable, Insertable, Identifiable,
+)]
+#[diesel(table_name = crate::schema::worktrees)]
+#[diesel(check_for_backend(diesel::sqlite::Sqlite))]
+pub struct Worktree {
+    pub id: String,
+    pub base: String,
+    pub path: String,
+    pub source: String,
+}
+
+impl DbHandle {
+    pub fn worktrees(&mut self) -> WorktreesHandle<'_> {
+        WorktreesHandle { db: self }
+    }
+}
+
+pub struct WorktreesHandle<'a> {
+    db: &'a mut DbHandle,
+}
+
+impl WorktreesHandle<'_> {
+    pub fn insert(&mut self, worktree: Worktree) -> Result<(), diesel::result::Error> {
+        diesel::insert_into(worktrees)
+            .values(worktree)
+            .execute(&mut self.db.conn)?;
+        Ok(())
+    }
+
+    pub fn get(&mut self, id: &str) -> Result<Option<Worktree>, diesel::result::Error> {
+        let worktree = worktrees
+            .filter(crate::schema::worktrees::id.eq(id))
+            .first::<Worktree>(&mut self.db.conn)
+            .optional()?;
+        Ok(worktree)
+    }
+
+    pub fn delete(&mut self, id: &str) -> Result<(), diesel::result::Error> {
+        diesel::delete(worktrees.filter(crate::schema::worktrees::id.eq(id)))
+            .execute(&mut self.db.conn)?;
+        Ok(())
+    }
+
+    pub fn list(&mut self) -> Result<Vec<Worktree>, diesel::result::Error> {
+        let worktree_list = worktrees.load::<Worktree>(&mut self.db.conn)?;
+        Ok(worktree_list)
+    }
+}

crates/but-db/src/worktrees.rs

@@ -0,0 +1,26 @@
+[package]
+name = "but-worktrees"
+version = "0.0.0"
+edition = "2024"
+authors = ["GitButler <[email protected]>"]
+publish = false
+rust-version = "1.89"
+[lib]
+doctest = false
+
+[dependencies]
+anyhow.workspace = true
+but-db.workspace = true
+gix.workspace = true
+gitbutler-command-context.workspace = true
+gitbutler-project.workspace = true
+gitbutler-stack.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+uuid.workspace = true
+
+[dev-dependencies]
+gix-testtools.workspace = true
+gitbutler-testsupport.workspace = true
+gitbutler-oxidize.workspace = true
+insta.workspace = true

crates/but-worktrees/Cargo.toml

@@ -0,0 +1,71 @@
+//! Database operations for worktrees.
+
+use anyhow::Result;
+use gitbutler_command_context::CommandContext;
+use uuid::Uuid;
+
+use crate::{Worktree, WorktreeSource};
+
+/// Save a new worktree to the database.
+pub fn save_worktree(ctx: &mut CommandContext, worktree: Worktree) -> Result<()> {
+    ctx.db()?.worktrees().insert(worktree.try_into()?)?;
+    Ok(())
+}
+
+/// Retrieve a worktree by its ID.
+pub fn get_worktree(ctx: &mut CommandContext, id: Uuid) -> Result<Option<Worktree>> {
+    let worktree = ctx.db()?.worktrees().get(&id.to_string())?;
+    match worktree {
+        Some(w) => Ok(Some(w.try_into()?)),
+        None => Ok(None),
+    }
+}
+
+/// Delete a worktree from the database.
+pub fn delete_worktree(ctx: &mut CommandContext, id: Uuid) -> Result<()> {
+    ctx.db()?.worktrees().delete(&id.to_string())?;
+    Ok(())
+}
+
+/// List all worktrees in the database.
+pub fn list_worktrees(ctx: &mut CommandContext) -> Result<Vec<Worktree>> {
+    let worktrees = ctx.db()?.worktrees().list()?;
+    worktrees
+        .into_iter()
+        .map(|w| w.try_into())
+        .collect::<Result<_, _>>()
+}
+
+impl TryFrom<but_db::Worktree> for Worktree {
+    type Error = anyhow::Error;
+
+    fn try_from(value: but_db::Worktree) -> Result<Self, Self::Error> {
+        let source: WorktreeSource = serde_json::from_str(&value.source)?;
+        let base = gix::ObjectId::from_hex(value.base.as_bytes())?;
+        let path = std::path::PathBuf::from(value.path);
+
+        Ok(Worktree {
+            id: Uuid::parse_str(&value.id)?,
+            base,
+            path,
+            source,
+        })
+    }
+}
+
+impl TryFrom<Worktree> for but_db::Worktree {
+    type Error = anyhow::Error;
+
+    fn try_from(value: Worktree) -> Result<Self, Self::Error> {
+        let source = serde_json::to_string(&value.source)?;
+        let base = value.base.to_hex().to_string();
+        let path = value.path.to_string_lossy().to_string();
+
+        Ok(but_db::Worktree {
+            id: value.id.to_string(),
+            base,
+            path,
+            source,
+        })
+    }
+}

crates/but-worktrees/src/db.rs

@@ -0,0 +1,30 @@
+//! Worktree management types and database operations.
+
+use std::path::PathBuf;
+
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+/// Database operations for worktrees.
+pub mod db;
+
+/// The source from which a worktree was created.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type", content = "data", rename_all = "camelCase")]
+pub enum WorktreeSource {
+    /// The worktree was created from a branch reference.
+    Branch(String),
+}
+
+/// A worktree entry representing a Git worktree.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Worktree {
+    /// Unique identifier for this worktree.
+    pub id: Uuid,
+    /// The base commit (ObjectId) from which this worktree was created.
+    pub base: gix::ObjectId,
+    /// The filesystem path to the worktree.
+    pub path: PathBuf,
+    /// The source from which this worktree was created.
+    pub source: WorktreeSource,
+}

crates/but-worktrees/src/lib.rs

@@ -0,0 +1,36 @@
+mod util {
+    use gitbutler_command_context::CommandContext;
+    use gitbutler_stack::VirtualBranchesHandle;
+    use gix_testtools::tempfile::TempDir;
+
+    pub fn test_ctx(name: &str) -> anyhow::Result<TestContext> {
+        let (ctx, tmpdir) = gitbutler_testsupport::writable::fixture("example.sh", name)?;
+        let handle = VirtualBranchesHandle::new(ctx.project().gb_dir());
+
+        Ok(TestContext {
+            ctx,
+            handle,
+            tmpdir,
+        })
+    }
+
+    #[allow(unused)]
+    pub struct TestContext {
+        pub ctx: CommandContext,
+        pub handle: VirtualBranchesHandle,
+        pub tmpdir: TempDir,
+    }
+}
+
+mod example_scenario {
+    use super::*;
+    use util::test_ctx;
+
+    #[test]
+    fn test_example_scenario() -> anyhow::Result<()> {
+        let test_ctx = test_ctx("example-scenario")?;
+        let stacks = test_ctx.handle.list_stacks_in_workspace()?;
+        assert!(!stacks.is_empty());
+        Ok(())
+    }
+}