Merge pull request #9439 from gitbutlerapp/workspace-rules

Playing with a Workspace Rules idea

Author: krlvi

Cargo.lock

@@ -76,6 +76,7 @@ but-hunk-assignment = { path = "crates/but-hunk-assignment" }
 but-hunk-dependency = { path = "crates/but-hunk-dependency" }
 but-db = { path = "crates/but-db" }
 but-graph = { path = "crates/but-graph" }
+but-rules = { path = "crates/but-rules" }
 but-action = { path = "crates/but-action" }
 but-status = { path = "crates/but-status" }
 but-tools = { path = "crates/but-tools" }

Cargo.toml

@@ -0,0 +1,2 @@
+-- This file should undo anything in `up.sql`
+DROP TABLE IF EXISTS `workspace_rules`;

crates/but-db/migrations/2025-07-17-150441_workspace_rules/down.sql

@@ -0,0 +1,9 @@
+-- Your SQL goes here
+CREATE TABLE `workspace_rules`(
+	`id` TEXT NOT NULL PRIMARY KEY,
+	`created_at` TIMESTAMP NOT NULL,
+	`enabled` BOOL NOT NULL,
+	`trigger` TEXT NOT NULL,
+	`filters` TEXT NOT NULL,
+	`action` TEXT NOT NULL
+);

crates/but-db/migrations/2025-07-17-150441_workspace_rules/up.sql

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

crates/but-db/src/lib.rs

@@ -51,3 +51,14 @@ diesel::table! {
         owner -> Text,
     }
 }
+
+diesel::table! {
+    workspace_rules (id) {
+        id -> Text,
+        created_at -> Timestamp,
+        enabled -> Bool,
+        trigger -> Text,
+        filters -> Text,
+        action -> Text,
+    }
+}

crates/but-db/src/schema.rs

@@ -0,0 +1,68 @@
+use diesel::{ExpressionMethods, OptionalExtension, QueryDsl, RunQueryDsl};
+
+use crate::DbHandle;
+use crate::schema::workspace_rules::dsl::workspace_rules;
+
+use diesel::prelude::{Insertable, Queryable, Selectable};
+use serde::{Deserialize, Serialize};
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Queryable, Selectable, Insertable)]
+#[diesel(table_name = crate::schema::workspace_rules)]
+#[diesel(check_for_backend(diesel::sqlite::Sqlite))]
+pub struct WorkspaceRule {
+    pub id: String,
+    pub created_at: chrono::NaiveDateTime,
+    pub enabled: bool,
+    pub trigger: String,
+    pub filters: String,
+    pub action: String,
+}
+
+impl DbHandle {
+    pub fn workspace_rules(&mut self) -> WorkspaceRulesHandle {
+        WorkspaceRulesHandle { db: self }
+    }
+}
+
+pub struct WorkspaceRulesHandle<'a> {
+    db: &'a mut DbHandle,
+}
+
+impl WorkspaceRulesHandle<'_> {
+    pub fn insert(&mut self, rule: WorkspaceRule) -> Result<(), diesel::result::Error> {
+        diesel::insert_into(workspace_rules)
+            .values(rule)
+            .execute(&mut self.db.conn)?;
+        Ok(())
+    }
+
+    pub fn update(&mut self, id: &str, rule: WorkspaceRule) -> Result<(), diesel::result::Error> {
+        diesel::update(workspace_rules.filter(crate::schema::workspace_rules::id.eq(id)))
+            .set((
+                crate::schema::workspace_rules::enabled.eq(rule.enabled),
+                crate::schema::workspace_rules::trigger.eq(rule.trigger),
+                crate::schema::workspace_rules::filters.eq(rule.filters),
+                crate::schema::workspace_rules::action.eq(rule.action),
+            ))
+            .execute(&mut self.db.conn)?;
+        Ok(())
+    }
+
+    pub fn delete(&mut self, id: &str) -> Result<(), diesel::result::Error> {
+        diesel::delete(workspace_rules.filter(crate::schema::workspace_rules::id.eq(id)))
+            .execute(&mut self.db.conn)?;
+        Ok(())
+    }
+
+    pub fn list(&mut self) -> Result<Vec<WorkspaceRule>, diesel::result::Error> {
+        let rules = workspace_rules.load::<WorkspaceRule>(&mut self.db.conn)?;
+        Ok(rules)
+    }
+
+    pub fn get(&mut self, id: &str) -> Result<Option<WorkspaceRule>, diesel::result::Error> {
+        let rule = workspace_rules
+            .filter(crate::schema::workspace_rules::id.eq(id))
+            .first::<WorkspaceRule>(&mut self.db.conn)
+            .optional()?;
+        Ok(rule)
+    }
+}

crates/but-db/src/workspace_rules.rs

@@ -0,0 +1,22 @@
+[package]
+name = "but-rules"
+version = "0.0.0"
+edition = "2024"
+authors = ["GitButler <[email protected]>"]
+publish = false
+
+
+[lib]
+doctest = false
+
+[dependencies]
+anyhow = "1.0.98"
+itertools.workspace = true
+serde.workspace = true
+regex = "1.11.1"
+chrono = { version = "0.4.41", features = [] }
+serde_regex = "1.1.0"
+serde_json = "1.0.138"
+gitbutler-command-context.workspace = true
+but-db.workspace = true
+uuid.workspace = true

crates/but-rules/Cargo.toml

@@ -0,0 +1,41 @@
+use anyhow::Result;
+use gitbutler_command_context::CommandContext;
+
+impl TryFrom<but_db::WorkspaceRule> for crate::WorkspaceRule {
+    type Error = anyhow::Error;
+    fn try_from(value: but_db::WorkspaceRule) -> Result<Self, Self::Error> {
+        Ok(crate::WorkspaceRule {
+            id: value.id,
+            created_at: value.created_at,
+            enabled: value.enabled,
+            trigger: serde_json::from_str(&value.trigger)?,
+            filters: serde_json::from_str(&value.filters)?,
+            action: serde_json::from_str(&value.action)?,
+        })
+    }
+}
+
+impl TryFrom<crate::WorkspaceRule> for but_db::WorkspaceRule {
+    type Error = anyhow::Error;
+    fn try_from(value: crate::WorkspaceRule) -> Result<Self, Self::Error> {
+        Ok(but_db::WorkspaceRule {
+            id: value.id,
+            created_at: value.created_at,
+            enabled: value.enabled,
+            trigger: serde_json::to_string(&value.trigger)?,
+            filters: serde_json::to_string(&value.filters)?,
+            action: serde_json::to_string(&value.action)?,
+        })
+    }
+}
+
+pub fn workspace_rules(ctx: &mut CommandContext) -> Result<Vec<crate::WorkspaceRule>> {
+    let rules = ctx
+        .db()?
+        .workspace_rules()
+        .list()?
+        .into_iter()
+        .map(|r| r.try_into())
+        .collect::<Result<Vec<crate::WorkspaceRule>>>()?;
+    Ok(rules)
+}