refactor(workspaces): rename capability layer to operations

Author: urjitc

src/features/workspaces/ai/ai-thread-runtime.ts

@@ -19,7 +19,7 @@ import { createAIThreadResearchTools } from "#/features/workspaces/ai/research-t
 import { createAIThreadTimeTools } from "#/features/workspaces/ai/time-tools";
 import { createAIThreadWebTools } from "#/features/workspaces/ai/web-tools";
 import { createAIThreadWorkspaceTools } from "#/features/workspaces/ai/workspace-tools";
-import { workspaceCapabilityToolDefinitions } from "#/features/workspaces/capabilities/workspace-capability-tools";
+import { workspaceToolDefinitions } from "#/features/workspaces/operations/workspace-tool-definitions";
 import { formatWorkspaceAiContextForPrompt } from "#/features/workspaces/model/workspace-ai-context";
 
 const thinkPromptSectionDivider = "══════════════════════════════════════════════";
@@ -165,7 +165,7 @@ const AI_THREAD_TIME_TOOL_DESCRIPTORS: AIThreadToolDescriptor[] = [
 ];
 
 const AI_THREAD_WORKSPACE_TOOL_DESCRIPTORS: AIThreadToolDescriptor[] = [
-	...workspaceCapabilityToolDefinitions.map(({ name, mutating }) => ({
+	...workspaceToolDefinitions.map(({ name, mutating }) => ({
 		name,
 		codemode: true,
 		mutating,

src/features/workspaces/ai/workspace-tools.ts

@@ -3,17 +3,17 @@ import { tool } from "ai";
 
 import type { AIThreadContext } from "#/features/workspaces/ai/ai-thread-metadata";
 import {
-	workspaceCapabilityToolDefinitions,
-	type WorkspaceCapabilityToolDefinition,
-} from "#/features/workspaces/capabilities/workspace-capability-tools";
+	workspaceToolDefinitions,
+	type WorkspaceToolDefinition,
+} from "#/features/workspaces/operations/workspace-tool-definitions";
 import {
-	createWorkspaceCapabilityContext,
-	type WorkspaceCapabilityContext,
-	type WorkspaceCapabilityScope,
-} from "#/features/workspaces/capabilities/workspace-capability-context";
+	createWorkspaceAccessContext,
+	type WorkspaceAccessContext,
+	type WorkspaceAccessScope,
+} from "#/features/workspaces/operations/workspace-access-context";
 
 type WorkspaceThreadToolConfig = {
-	definition: WorkspaceCapabilityToolDefinition;
+	definition: WorkspaceToolDefinition;
 	getThreadContext: () => Promise<AIThreadContext | null>;
 };
 
@@ -31,7 +31,7 @@ function createWorkspaceThreadTool(input: WorkspaceThreadToolConfig) {
 
 			return await definition.execute(
 				args,
-				createThreadWorkspaceCapabilityContext(thread, definition.scopes),
+				createThreadWorkspaceAccessContext(thread, definition.scopes),
 			);
 		},
 	});
@@ -41,7 +41,7 @@ export function createAIThreadWorkspaceTools(input: {
 	getThreadContext: () => Promise<AIThreadContext | null>;
 }): ToolSet {
 	return Object.fromEntries(
-		workspaceCapabilityToolDefinitions.map((definition) => [
+		workspaceToolDefinitions.map((definition) => [
 			definition.name,
 			createWorkspaceThreadTool({
 				definition,
@@ -61,11 +61,11 @@ async function requireThreadContext(getThreadContext: () => Promise<AIThreadCont
 	return thread;
 }
 
-function createThreadWorkspaceCapabilityContext(
+function createThreadWorkspaceAccessContext(
 	thread: AIThreadContext,
-	scopes: readonly WorkspaceCapabilityScope[],
-): WorkspaceCapabilityContext {
-	return createWorkspaceCapabilityContext({
+	scopes: readonly WorkspaceAccessScope[],
+): WorkspaceAccessContext {
+	return createWorkspaceAccessContext({
 		scopes,
 		userId: thread.userId,
 		workspaceId: thread.workspaceId,

src/features/workspaces/capabilities/account-capability-context.ts

@@ -0,0 +1,38 @@
+export interface AccessActor<TScope extends string> {
+	scopes: ReadonlySet<TScope>;
+	userId: string;
+}
+
+export interface ScopedAccessContext<TScope extends string> {
+	actor: AccessActor<TScope>;
+}
+
+export class AccessScopeError<TScope extends string> extends Error {
+	constructor(
+		readonly domain: string,
+		readonly scope: TScope,
+	) {
+		super(`Missing ${domain} access scope: ${scope}`);
+		this.name = "AccessScopeError";
+	}
+}
+
+export function createAccessActor<TScope extends string>(input: {
+	scopes: readonly TScope[];
+	userId: string;
+}): AccessActor<TScope> {
+	return {
+		scopes: new Set(input.scopes),
+		userId: input.userId,
+	};
+}
+
+export function assertAccessScope<TScope extends string>(
+	context: ScopedAccessContext<TScope>,
+	domain: string,
+	scope: TScope,
+) {
+	if (!context.actor.scopes.has(scope)) {
+		throw new AccessScopeError(domain, scope);
+	}
+}

src/features/workspaces/capabilities/capability-context.ts

@@ -0,0 +1,27 @@
+import {
+	assertAccessScope,
+	type AccessActor,
+	createAccessActor,
+	type ScopedAccessContext,
+} from "#/features/workspaces/operations/access-context";
+
+export const accountAccessScopes = ["workspaces:read"] as const;
+
+export type AccountAccessScope = (typeof accountAccessScopes)[number];
+
+export type AccountAccessActor = AccessActor<AccountAccessScope>;
+
+export type AccountAccessContext = ScopedAccessContext<AccountAccessScope>;
+
+export function createAccountAccessContext(input: {
+	scopes: readonly AccountAccessScope[];
+	userId: string;
+}): AccountAccessContext {
+	return {
+		actor: createAccessActor(input),
+	};
+}
+
+export function assertAccountAccessScope(context: AccountAccessContext, scope: AccountAccessScope) {
+	assertAccessScope(context, "account", scope);
+}