Merge pull request #10619 from gitbutlerapp/but-worktrees

`but worktree new`

Author: Caleb-T-Owens

Cargo.lock

@@ -76,6 +76,7 @@ but-core = { path = "crates/but-core" }
 but-workspace = { path = "crates/but-workspace" }
 but-hunk-assignment = { path = "crates/but-hunk-assignment" }
 but-hunk-dependency = { path = "crates/but-hunk-dependency" }
+but-worktrees = { path = "crates/but-worktrees" }
 but-db = { path = "crates/but-db" }
 but-path = { path = "crates/but-path" }
 but-graph = { path = "crates/but-graph" }

Cargo.toml

@@ -27,6 +27,7 @@ gitbutler-user.workspace = true
 gitbutler-project.workspace = true
 gitbutler-secret.workspace = true
 but-workspace.workspace = true
+but-worktrees.workspace = true
 but-core.workspace = true
 but-hunk-assignment.workspace = true
 but-action.workspace = true

crates/but-api/Cargo.toml

@@ -20,4 +20,5 @@ pub mod stack;
 pub mod users;
 pub mod virtual_branches;
 pub mod workspace;
+pub mod worktree;
 pub mod zip;

crates/but-api/src/commands/mod.rs

@@ -0,0 +1,19 @@
+use crate::error::Error;
+use but_api_macros::api_cmd;
+use but_settings::AppSettings;
+use but_worktrees::new::NewWorktreeOutcome;
+use gitbutler_command_context::CommandContext;
+use gitbutler_project::ProjectId;
+use tracing::instrument;
+
+#[api_cmd]
+#[cfg_attr(feature = "tauri", tauri::command(async))]
+#[instrument(err(Debug))]
+pub fn worktree_new(project_id: ProjectId, reference: String) -> Result<NewWorktreeOutcome, Error> {
+    let project = gitbutler_project::get(project_id)?;
+    let guard = project.exclusive_worktree_access();
+    let mut ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+
+    but_worktrees::new::worktree_new(&mut ctx, guard.read_permission(), &reference)
+        .map_err(Into::into)
+}

crates/but-api/src/commands/worktree.rs

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

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

@@ -0,0 +1,7 @@
+-- Create worktrees table
+CREATE TABLE `worktrees`(
+	`path` TEXT NOT NULL PRIMARY KEY,
+	`reference` TEXT NOT NULL,
+	`base` TEXT NOT NULL,
+	`source` TEXT NOT NULL
+);

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;
 
 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 (path) {
+        path -> Text,
+        reference -> Text,
+        base -> Text,
+        source -> Text,
+    }
+}

crates/but-db/src/schema.rs

@@ -0,0 +1,58 @@
+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, Queryable, Selectable, Insertable, Identifiable,
+)]
+#[diesel(table_name = crate::schema::worktrees)]
+#[diesel(check_for_backend(diesel::sqlite::Sqlite))]
+#[diesel(primary_key(path))]
+pub struct Worktree {
+    pub path: String,
+    pub reference: String,
+    pub base: 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, path: &str) -> Result<Option<Worktree>, diesel::result::Error> {
+        let worktree = worktrees
+            .filter(crate::schema::worktrees::path.eq(path))
+            .first::<Worktree>(&mut self.db.conn)
+            .optional()?;
+        Ok(worktree)
+    }
+
+    pub fn delete(&mut self, path: &str) -> Result<(), diesel::result::Error> {
+        diesel::delete(worktrees.filter(crate::schema::worktrees::path.eq(path)))
+            .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)
+    }
+}