Workspace rules: add model, service & integration

- Add new rule definition and service files for workspace rules
- Integrate rulesService into +layout.svelte for Svelte context
- Update ReduxTag enum to include WorkspaceRules
- Exclude backendService implementation from this commit

Author: estib-vega

apps/desktop/src/lib/rules/rule.ts

@@ -0,0 +1,108 @@
+import type { BrandedId } from '@gitbutler/shared/utils/branding';
+
+export type WorkspaceRuleId = BrandedId<'WorkspaceRule'>;
+/**
+ * A workspace rule.
+ * @remarks
+ * A rule is evaluated in the app and determines what happens to files or changes based on triggers, filters, and actions.
+ */
+export interface WorkspaceRule {
+	/** A UUID unique identifier for the rule. */
+	id: WorkspaceRuleId;
+	/** The time when the rule was created, represented as a Unix timestamp in milliseconds. */
+	createdAt: string; // ISO string or Date, depending on backend serialization
+	/** Whether the rule is currently enabled or not. */
+	enabled: boolean;
+	/** The trigger of the rule is what causes it to be evaluated in the app. */
+	trigger: Trigger;
+	/** These filters determine what files or changes the rule applies to. Multiple filters are combined with OR logic. */
+	filters: Filter[];
+	/** The action determines what happens to the files or changes that matched the filters. */
+	action: Action;
+}
+
+/**
+ * Represents the kinds of events in the app that can cause a rule to be evaluated.
+ */
+export type Trigger =
+	/** When a file is added, removed or modified in the Git worktree. */
+	'fileSytemChange';
+
+/**
+ * A filter is a condition that determines what files or changes the rule applies to.
+ * Multiple conditions in a filter are combined with AND logic.
+ */
+export type Filter =
+	| { type: 'pathMatchesRegex'; subject: string[] } // regex patterns as strings
+	| { type: 'contentMatchesRegex'; subject: string[] } // regex patterns as strings
+	| { type: 'fileChangeType'; subject: TreeStatus }
+	| { type: 'semanticType'; subject: SemanticType };
+
+/**
+ * Represents the type of change that occurred in the Git worktree.
+ * Matches the TreeStatus of the TreeChange.
+ */
+export type TreeStatus = 'addition' | 'deletion' | 'modification' | 'rename';
+
+/**
+ * Represents a semantic type of change that was inferred for the change.
+ * Typically this means a heuristic or an LLM determined that a change represents a refactor, a new feature, a bug fix, or documentation update.
+ */
+export type SemanticType =
+	| { type: 'refactor' }
+	| { type: 'newFeature' }
+	| { type: 'bugFix' }
+	| { type: 'documentation' }
+	| { type: 'userDefined'; subject: string };
+
+/**
+ * Represents an action that can be taken based on the rule evaluation.
+ * An action can be either explicit (user defined) or implicit (determined by heuristics or AI).
+ */
+export type Action =
+	| { type: 'explicit'; subject: Operation }
+	| { type: 'implicit'; subject: ImplicitOperation };
+
+/**
+ * Represents the operation that a user can configure to be performed in an explicit action.
+ */
+export type Operation =
+	| { type: 'assign'; stackId: string }
+	| { type: 'amend'; commitId: string }
+	| { type: 'newCommit'; branchName: string };
+
+/**
+ * Represents the implicit operation that is determined by heuristics or AI.
+ */
+export type ImplicitOperation =
+	| { type: 'assignToAppropriateBranch' }
+	| { type: 'absorbIntoDependentCommit' }
+	| { type: 'llmPrompt'; subject: string };
+
+/**
+ * A request to create a new workspace rule.
+ */
+export interface CreateRuleRequest {
+	/** The trigger that causes the rule to be evaluated. */
+	trigger: Trigger;
+	/** The filters that determine what files or changes the rule applies to. Cannot be empty. */
+	filters: Filter[];
+	/** The action that determines what happens to the files or changes that matched the filters. */
+	action: Action;
+}
+
+/**
+ * A request to update an existing workspace rule.
+ */
+export interface UpdateRuleRequest {
+	/** The ID of the rule to update. */
+	id: WorkspaceRuleId;
+	/** The new enabled state of the rule. If not provided, the existing state is retained. */
+	enabled: boolean | null;
+	/** The new trigger for the rule. If not provided, the existing trigger is retained. */
+	trigger: Trigger | null;
+	/** The new filters for the rule. If not provided, the existing filters are retained. */
+	filters: Filter[] | null;
+	/** The new action for the rule. If not provided, the existing action is retained. */
+	action: Action | null;
+}

apps/desktop/src/lib/rules/rulesService.svelte.ts

@@ -0,0 +1,82 @@
+import { invalidatesItem, invalidatesList, providesItems, ReduxTag } from '$lib/state/tags';
+import { createEntityAdapter, type EntityState } from '@reduxjs/toolkit';
+import type {
+	CreateRuleRequest,
+	UpdateRuleRequest,
+	WorkspaceRule,
+	WorkspaceRuleId
+} from '$lib/rules/rule';
+import type { BackendApi } from '$lib/state/clientState.svelte';
+
+export default class RulesService {
+	private api: ReturnType<typeof injectEndpoints>;
+
+	constructor(backendApi: BackendApi) {
+		this.api = injectEndpoints(backendApi);
+	}
+
+	get createWorkspaceRule() {
+		return this.api.endpoints.createWorkspaceRule.useMutation;
+	}
+
+	get deleteWorkspaceRule() {
+		return this.api.endpoints.deleteWorkspaceRule.useMutation;
+	}
+
+	get updateWorkspaceRule() {
+		return this.api.endpoints.updateWorkspaceRule.useMutation;
+	}
+
+	get listWorkspaceRules() {
+		return this.api.endpoints.listWorkspaceRules.useQuery;
+	}
+}
+
+function injectEndpoints(api: BackendApi) {
+	return api.injectEndpoints({
+		endpoints: (build) => ({
+			createWorkspaceRule: build.mutation<
+				WorkspaceRule,
+				{ projectId: string; request: CreateRuleRequest }
+			>({
+				extraOptions: { command: 'create_workspace_rule' },
+				query: (args) => args,
+				invalidatesTags: () => [invalidatesList(ReduxTag.WorkspaceRules)]
+			}),
+			deleteWorkspaceRule: build.mutation<void, { projectId: string; ruleId: WorkspaceRuleId }>({
+				extraOptions: { command: 'delete_workspace_rule' },
+				query: (args) => args,
+				invalidatesTags: () => [invalidatesList(ReduxTag.WorkspaceRules)]
+			}),
+			updateWorkspaceRule: build.mutation<
+				WorkspaceRule,
+				{ projectId: string; request: UpdateRuleRequest }
+			>({
+				extraOptions: { command: 'update_workspace_rule' },
+				query: (args) => args,
+				invalidatesTags: (result) =>
+					result
+						? [
+								invalidatesItem(ReduxTag.WorkspaceRules, result.id),
+								invalidatesList(ReduxTag.WorkspaceRules)
+							]
+						: []
+			}),
+			listWorkspaceRules: build.query<
+				EntityState<WorkspaceRule, WorkspaceRuleId>,
+				{ projectId: string }
+			>({
+				extraOptions: { command: 'list_workspace_rules' },
+				query: (args) => args,
+				providesTags: (result) => providesItems(ReduxTag.WorkspaceRules, result?.ids ?? []),
+				transformResponse: (response: WorkspaceRule[]) => {
+					return workspaceRulesAdapter.addMany(workspaceRulesAdapter.getInitialState(), response);
+				}
+			})
+		})
+	});
+}
+
+const workspaceRulesAdapter = createEntityAdapter<WorkspaceRule, WorkspaceRuleId>({
+	selectId: (rule) => rule.id
+});

apps/desktop/src/lib/state/tags.ts

@@ -20,7 +20,8 @@ export enum ReduxTag {
 	UpstreamIntegrationStatus = 'UpstreamIntegrationStatus',
 	BranchListing = 'BranchListing',
 	BranchDetails = 'BranchDetails',
-	SnapshotDiff = 'SnapshotDiff'
+	SnapshotDiff = 'SnapshotDiff',
+	WorkspaceRules = 'WorkspaceRules'
 }
 
 type Tag<T extends string | number> = {

apps/desktop/src/routes/+layout.svelte

@@ -50,6 +50,7 @@
 	import { ProjectsService } from '$lib/project/projectsService';
 	import { PromptService } from '$lib/prompt/promptService';
 	import { RemotesService } from '$lib/remotes/remotesService';
+	import RulesService from '$lib/rules/rulesService.svelte';
 	import { setSecretsService } from '$lib/secrets/secretsService';
 	import { IdSelection } from '$lib/selection/idSelection.svelte';
 	import { UncommittedService } from '$lib/selection/uncommittedService.svelte';
@@ -156,6 +157,7 @@
 		forgeFactory,
 		uiState
 	);
+	const rulesService = new RulesService(clientState['backendApi']);
 	const actionService = new ActionService(clientState['backendApi']);
 	const oplogService = new OplogService(clientState['backendApi']);
 	const baseBranchService = new BaseBranchService(clientState.backendApi);
@@ -251,6 +253,7 @@
 	setContext(AppSettings, data.appSettings);
 	setContext(EventContext, data.eventContext);
 	setContext(StackService, stackService);
+	setContext(RulesService, rulesService);
 	setContext(ActionService, actionService);
 	setContext(OplogService, oplogService);
 	setContext(BaseBranchService, baseBranchService);