Creates frontend APIs for accessing, creating and modifying workspace rules

Author: krlvi

Cargo.lock

@@ -19,3 +19,4 @@ 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

@@ -1,3 +1,4 @@
+use gitbutler_command_context::CommandContext;
 use serde::{Deserialize, Serialize};
 
 pub mod db;
@@ -31,7 +32,7 @@ pub enum Trigger {
 /// A filter is a condition that determines what files or changes the rule applies to.
 /// Within a filter, multiple conditions are combined with AND logic (i.e. to match all conditions must be met)
 #[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", tag = "type", content = "subject")]
 pub enum Filter {
     /// Matches the file path (relative to the repository root) against all provided regex patterns.
     #[serde(with = "serde_regex")]
@@ -63,7 +64,7 @@ pub enum TreeStatus {
 /// Represents a semantic type of change that was inferred for the change.
 /// Typically this means a heuristic or an LLM determinded that a change represents a refactor, a new feature, a bug fix, or documentation update.
 #[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", tag = "type", content = "subject")]
 pub enum SemanticType {
     /// A change that is a refactor, meaning it does not change the external behavior of the code but improves its structure.
     Refactor,
@@ -81,7 +82,7 @@ pub enum SemanticType {
 /// An action can be either explicit, meaning the user defined something like "Assign in Lane A" or "Ammend into Commit X"
 /// or it is implicit, meaning the action was determined by heuristics or AI, such as "Assign to appropriate branch" or "Absorb in dependent commit".
 #[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", tag = "type", content = "subject")]
 pub enum Action {
     /// An action that has an explicit operation defined by the user.
     Explicit(Operation),
@@ -91,7 +92,7 @@ pub enum Action {
 
 /// Represents the operation that a user can configure to be performed in an explicit action.
 #[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", tag = "type", content = "subject")]
 pub enum Operation {
     /// Assign the matched changes to a specific stack ID.
     Assign { stack_id: String },
@@ -103,7 +104,7 @@ pub enum Operation {
 
 /// Represents the implicit operation that is determined by heuristics or AI.
 #[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", tag = "type", content = "subject")]
 pub enum ImplicitOperation {
     /// Assign the matched changes to the appropriate branch based on offline heuristics.
     AssignToAppropriateBranch,
@@ -112,3 +113,108 @@ pub enum ImplicitOperation {
     /// Perform an operation based on LLM-driven analysis and tool calling.
     LLMPrompt(String),
 }
+
+/// A request to create a new workspace rule.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateRuleRequest {
+    /// The trigger that causes the rule to be evaluated.
+    pub trigger: Trigger,
+    /// The filters that determine what files or changes the rule applies to. Can not be empty.
+    pub filters: Vec<Filter>,
+    /// The action that determines what happens to the files or changes that matched the filters.
+    pub action: Action,
+}
+
+/// Creates a new workspace rule
+pub fn create_rule(
+    ctx: &mut CommandContext,
+    req: CreateRuleRequest,
+) -> anyhow::Result<WorkspaceRule> {
+    if req.filters.is_empty() {
+        return Err(anyhow::anyhow!("At least one filter is required"));
+    }
+    let rule = WorkspaceRule {
+        id: uuid::Uuid::new_v4().to_string(),
+        created_at: chrono::Local::now().naive_local(),
+        enabled: true,
+        trigger: req.trigger,
+        filters: req.filters,
+        action: req.action,
+    };
+
+    ctx.db()?
+        .workspace_rules()
+        .insert(rule.clone().try_into()?)
+        .map_err(|e| anyhow::anyhow!("Failed to insert workspace rule: {}", e))?;
+    Ok(rule)
+}
+
+/// Deletes an existing workspace rule by its ID.
+pub fn delete_rule(ctx: &mut CommandContext, id: &str) -> anyhow::Result<()> {
+    ctx.db()?
+        .workspace_rules()
+        .delete(id)
+        .map_err(|e| anyhow::anyhow!("Failed to delete workspace rule: {}", e))?;
+    Ok(())
+}
+
+/// A request to update an existing workspace rule.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateRuleRequest {
+    /// The ID of the rule to update.
+    id: String,
+    /// The new enabled state of the rule. If not provided, the existing state is retained.
+    enabled: Option<bool>,
+    /// The new trigger for the rule. If not provided, the existing trigger is retained.
+    trigger: Option<Trigger>,
+    /// The new filters for the rule. If not provided, the existing filters are retained.
+    filters: Option<Vec<Filter>>,
+    /// The new action for the rule. If not provided, the existing action is retained.
+    action: Option<Action>,
+}
+
+/// Updates an existing workspace rule with the provided request data.
+pub fn update_rule(
+    ctx: &mut CommandContext,
+    req: UpdateRuleRequest,
+) -> anyhow::Result<WorkspaceRule> {
+    let mut rule: WorkspaceRule = ctx
+        .db()?
+        .workspace_rules()
+        .get(&req.id)?
+        .ok_or_else(|| anyhow::anyhow!("Rule with ID {} not found", req.id))?
+        .try_into()?;
+
+    if let Some(enabled) = req.enabled {
+        rule.enabled = enabled;
+    }
+    if let Some(trigger) = req.trigger {
+        rule.trigger = trigger;
+    }
+    if let Some(filters) = req.filters {
+        rule.filters = filters;
+    }
+    if let Some(action) = req.action {
+        rule.action = action;
+    }
+
+    ctx.db()?
+        .workspace_rules()
+        .update(&req.id, rule.clone().try_into()?)
+        .map_err(|e| anyhow::anyhow!("Failed to update workspace rule: {}", e))?;
+    Ok(rule)
+}
+
+/// Lists all workspace rules in the database.
+pub fn list_rules(ctx: &mut CommandContext) -> anyhow::Result<Vec<WorkspaceRule>> {
+    let rules = ctx
+        .db()?
+        .workspace_rules()
+        .list()?
+        .into_iter()
+        .map(|r| r.try_into())
+        .collect::<Result<Vec<WorkspaceRule>, _>>()?;
+    Ok(rules)
+}

crates/but-rules/src/lib.rs

@@ -82,6 +82,7 @@ but-graph.workspace = true
 but-hunk-dependency.workspace = true
 but-hunk-assignment.workspace = true
 but-action.workspace = true
+but-rules.workspace = true
 open = "5"
 url = "2.5.4"
 dirs = "6.0.0"

crates/gitbutler-tauri/Cargo.toml

@@ -34,6 +34,7 @@ pub mod open;
 pub mod projects;
 pub mod remotes;
 pub mod repo;
+pub mod rules;
 pub mod secret;
 pub mod undo;
 pub mod users;

crates/gitbutler-tauri/src/lib.rs

@@ -16,8 +16,8 @@ use gitbutler_tauri::csp::csp_with_extras;
 use gitbutler_tauri::settings::SettingsStore;
 use gitbutler_tauri::{
     action, askpass, cli, commands, config, diff, env, forge, github, logs, menu, modes, open,
-    projects, remotes, repo, secret, settings, stack, undo, users, virtual_branches, workspace,
-    zip, App, WindowState,
+    projects, remotes, repo, rules, secret, settings, stack, undo, users, virtual_branches,
+    workspace, zip, App, WindowState,
 };
 use tauri::Emitter;
 use tauri::{generate_context, Manager};
@@ -283,6 +283,10 @@ fn main() {
                     action::freestyle,
                     cli::install_cli,
                     cli::cli_path,
+                    rules::create_workspace_rule,
+                    rules::delete_workspace_rule,
+                    rules::update_workspace_rule,
+                    rules::list_workspace_rules,
                     workspace::stacks,
                     workspace::stack_details,
                     workspace::branch_details,

crates/gitbutler-tauri/src/main.rs

@@ -0,0 +1,58 @@
+use crate::error::Error;
+use but_rules::{
+    create_rule, delete_rule, list_rules, update_rule, CreateRuleRequest, UpdateRuleRequest,
+    WorkspaceRule,
+};
+use but_settings::AppSettingsWithDiskSync;
+use gitbutler_command_context::CommandContext;
+use gitbutler_project as projects;
+use gitbutler_project::ProjectId;
+use tauri::State;
+use tracing::instrument;
+
+#[tauri::command(async)]
+#[instrument(skip(projects, settings), err(Debug))]
+pub fn create_workspace_rule(
+    projects: State<'_, projects::Controller>,
+    settings: State<'_, AppSettingsWithDiskSync>,
+    project_id: ProjectId,
+    request: CreateRuleRequest,
+) -> Result<WorkspaceRule, Error> {
+    let ctx = &mut CommandContext::open(&projects.get(project_id)?, settings.get()?.clone())?;
+    create_rule(ctx, request).map_err(Into::into)
+}
+
+#[tauri::command(async)]
+#[instrument(skip(projects, settings), err(Debug))]
+pub fn delete_workspace_rule(
+    projects: State<'_, projects::Controller>,
+    settings: State<'_, AppSettingsWithDiskSync>,
+    project_id: ProjectId,
+    id: String,
+) -> Result<(), Error> {
+    let ctx = &mut CommandContext::open(&projects.get(project_id)?, settings.get()?.clone())?;
+    delete_rule(ctx, &id).map_err(Into::into)
+}
+
+#[tauri::command(async)]
+#[instrument(skip(projects, settings), err(Debug))]
+pub fn update_workspace_rule(
+    projects: State<'_, projects::Controller>,
+    settings: State<'_, AppSettingsWithDiskSync>,
+    project_id: ProjectId,
+    request: UpdateRuleRequest,
+) -> Result<WorkspaceRule, Error> {
+    let ctx = &mut CommandContext::open(&projects.get(project_id)?, settings.get()?.clone())?;
+    update_rule(ctx, request).map_err(Into::into)
+}
+
+#[tauri::command(async)]
+#[instrument(skip(projects, settings), err(Debug))]
+pub fn list_workspace_rules(
+    projects: State<'_, projects::Controller>,
+    settings: State<'_, AppSettingsWithDiskSync>,
+    project_id: ProjectId,
+) -> Result<Vec<WorkspaceRule>, Error> {
+    let ctx = &mut CommandContext::open(&projects.get(project_id)?, settings.get()?.clone())?;
+    list_rules(ctx).map_err(Into::into)
+}