@dxos/plugin-thread 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

package/src/capabilities/app-graph-builder.ts

@@ -3,192 +3,141 @@
 //
 
 import { Atom } from '@effect-atom/atom-react';
-import * as Function from 'effect/Function';
+import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
-import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, AppNode } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
-import { ROOT_ID, atomFromSignal, createExtension } from '@dxos/plugin-graph';
+import { GraphBuilder, NodeMatcher } from '@dxos/plugin-graph';
+import { linkedSegment } from '@dxos/react-ui-attention';
+import { type SelectionManager, type SelectionMode, defaultSelection } from '@dxos/react-ui-attention';
+import { Channel } from '@dxos/types';
+
+import { meta } from '#meta';
+import { ThreadOperation } from '#types';
+import { ThreadCapabilities, type ThreadState } from '#types';
 
-import { meta } from '../meta';
-import { Channel, ThreadAction } from '../types';
 import { getAnchor } from '../util';
 
-import { ThreadCapabilities } from './capabilities';
+type CommentDisabledParams = {
+  stateAtom: Atom.Atom<Atom.Writable<ThreadState>[]>;
+  selectionManager: SelectionManager;
+  objectId: string;
+  commentsType: string;
+  selectionMode: SelectionMode | undefined;
+};
+
+/**
+ * Atom family to derive whether the comment button should be disabled.
+ * Uses a composite key to ensure proper caching.
+ */
+const commentDisabledFamily = Atom.family(
+  ({ stateAtom, selectionManager, objectId, commentsType, selectionMode }: CommentDisabledParams) =>
+    Atom.make((get) => {
+      const stateAtoms = get(stateAtom);
+      const state = stateAtoms[0] ? get(stateAtoms[0]) : undefined;
+      const toolbar = state?.toolbar ?? {};
+      const selectionState = get(selectionManager.state);
+      const selection =
+        selectionState.selections[objectId] ?? (selectionMode ? defaultSelection(selectionMode) : undefined);
+      const anchor = getAnchor(selection);
+      const invalidSelection = !anchor;
+      const overlappingComment = toolbar[objectId];
+      return (commentsType === 'anchored' && invalidSelection) || overlappingComment;
+    }),
+);
+
+/** Match ECHO objects that are NOT Channels (i.e. objects that can have comments). */
+const whenCommentableObject = NodeMatcher.whenAll(
+  NodeMatcher.whenEchoObjectMatches,
+  NodeMatcher.whenNot(NodeMatcher.whenEchoTypeMatches(Channel.Channel)),
+);
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilities = yield* Capability.Service;
 
-// TODO(wittjosiah): Highlight active calls in L1.
-//  Track active meetings by subscribing to meetings query and polling the swarms of recent meetings in the space.
-export default (context: PluginContext) => {
-  const resolve = (typename: string) =>
-    context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
+    const getCommentConfig = (typename: string) =>
+      capabilities.getAll(AppCapabilities.CommentConfig).find(({ id }) => id === typename);
 
-  return contributes(Capabilities.AppGraphBuilder, [
-    createExtension({
-      id: `${meta.id}/active-call`,
-      connector: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
-            Option.map((node) => {
-              const [call] = get(context.capabilities(ThreadCapabilities.CallManager));
-              return get(
-                atomFromSignal(() =>
-                  call?.joined
-                    ? [
-                        {
-                          id: `${node.id}${ATTENDABLE_PATH_SEPARATOR}active-call`,
-                          type: DECK_COMPANION_TYPE,
-                          data: null,
-                          properties: {
-                            label: ['call panel label', { ns: meta.id }],
-                            icon: 'ph--video-conference--regular',
-                            position: 'hoist',
-                            disposition: 'hidden',
-                          },
-                        },
-                      ]
-                    : [],
-                ),
-              );
+    const extensions = yield* Effect.all([
+      GraphBuilder.createExtension({
+        id: 'comments-companion',
+        match: (node) => {
+          if (!Obj.isObject(node.data) || Option.isNone(whenCommentableObject(node))) {
+            return Option.none();
+          }
+          const commentConfig = getCommentConfig(Obj.getTypename(node.data)!);
+          return commentConfig ? Option.some(node) : Option.none();
+        },
+        connector: () =>
+          Effect.succeed([
+            AppNode.makeCompanion({
+              id: linkedSegment('comments'),
+              label: ['comments.label', { ns: meta.id }],
+              icon: 'ph--chat-text--regular',
+              data: 'comments',
+              position: 'first',
             }),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-    // TODO(wittjosiah): The channel shouldn't become the companion during a call.
-    //   Alternative: the call/meeting/thread should be a child node of the channel and that should be opened.
-    createExtension({
-      id: `${meta.id}/channel-chat-companion`,
-      connector: (node) => {
-        return Atom.make((get) => {
-          return Function.pipe(
-            get(node),
-            Option.flatMap((node) =>
-              Obj.instanceOf(Channel.Channel, node.data) ? Option.some(node.data) : Option.none(),
-            ),
-            Option.map((channel) => {
-              const callManager = context.getCapability(ThreadCapabilities.CallManager);
-              const joined = get(
-                atomFromSignal(() => callManager.joined && callManager.roomId === Obj.getDXN(channel).toString()),
-              );
-              if (!joined) {
-                return [];
-              }
+          ]),
+      }),
+      GraphBuilder.createExtension({
+        id: 'comment-toolbar',
+        match: (node) => {
+          if (!Obj.isObject(node.data) || Option.isNone(whenCommentableObject(node))) {
+            return Option.none();
+          }
+          const commentConfig = getCommentConfig(Obj.getTypename(node.data)!);
+          return commentConfig ? Option.some(node) : Option.none();
+        },
+        actions: (matched, get) => {
+          const object = matched.data;
+          const objectDXN = Obj.getDXN(object).toString();
+          const stateAtom = capabilities.atom(ThreadCapabilities.State);
+          const selectionManager = capabilities.get(AttentionCapabilities.Selection);
+          const commentConfig = getCommentConfig(Obj.getTypename(object)!)!;
 
-              return [
-                {
-                  id: `${Obj.getDXN(channel).toString()}${ATTENDABLE_PATH_SEPARATOR}chat`,
-                  type: PLANK_COMPANION_TYPE,
-                  data: 'chat',
-                  properties: {
-                    label: ['channel companion label', { ns: meta.id }],
-                    icon: 'ph--hash--regular',
-                    position: 'hoist',
-                    disposition: 'hidden',
-                  },
-                },
-              ];
+          const disabled = get(
+            commentDisabledFamily({
+              stateAtom,
+              selectionManager,
+              objectId: objectDXN,
+              commentsType: commentConfig.comments,
+              selectionMode: commentConfig.selectionMode as SelectionMode | undefined,
             }),
-            Option.getOrElse(() => []),
           );
-        });
-      },
-    }),
-    createExtension({
-      id: `${meta.id}/comments-companion`,
-      connector: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(Channel.Channel, node.data)) {
-                return Option.none();
-              }
-              const metadata = resolve(Obj.getTypename(node.data)!);
-              return typeof metadata.comments === 'string' ? Option.some(node) : Option.none();
-            }),
-            Option.map((node) => [
-              {
-                id: [node.id, 'comments'].join(ATTENDABLE_PATH_SEPARATOR),
-                type: PLANK_COMPANION_TYPE,
-                data: 'comments',
-                properties: {
-                  label: ['comments label', { ns: meta.id }],
-                  icon: 'ph--chat-text--regular',
-                  disposition: 'hidden',
-                  position: 'hoist',
-                },
+
+          return Effect.succeed([
+            {
+              id: 'comment',
+              data: Effect.fnUntraced(function* () {
+                const config = getCommentConfig(Obj.getTypename(object)!)!;
+                const selection = selectionManager.getSelection(objectDXN);
+                const anchor =
+                  (config.comments === 'anchored' ? getAnchor(selection) : undefined) ?? Date.now().toString();
+                const name = config.getAnchorLabel?.(object, anchor);
+                yield* Operation.invoke(ThreadOperation.Create, {
+                  anchor,
+                  name,
+                  subject: object,
+                });
+              }),
+              properties: {
+                label: ['add-comment.label', { ns: meta.id }],
+                icon: 'ph--chat-text--regular',
+                disposition: 'toolbar',
+                disabled,
+                testId: 'thread.comment.add',
               },
-            ]),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-    createExtension({
-      id: `${meta.id}/comment-toolbar`,
-      actions: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(Channel.Channel, node.data)) {
-                return Option.none();
-              }
-              const metadata = resolve(Obj.getTypename(node.data)!);
-              return typeof metadata.comments === 'string' ? Option.some(node.data) : Option.none();
-            }),
-            Option.map((object) => {
-              const selectionManager = context.getCapability(AttentionCapabilities.Selection);
-              const toolbar = get(context.capabilities(ThreadCapabilities.State))[0]?.state.toolbar ?? {};
-              const disabled = get(
-                atomFromSignal(() => {
-                  const metadata = resolve(Obj.getTypename(object)!);
-                  const selection = selectionManager.getSelection(
-                    Obj.getDXN(object).toString(),
-                    metadata.selectionMode,
-                  );
-                  const anchor = getAnchor(selection);
-                  const invalidSelection = !anchor;
-                  const overlappingComment = toolbar[Obj.getDXN(object).toString()];
-                  return (metadata.comments === 'anchored' && invalidSelection) || overlappingComment;
-                }),
-              );
+            },
+          ]);
+        },
+      }),
+    ]);
 
-              return [
-                {
-                  id: `${Obj.getDXN(object).toString()}/comment`,
-                  data: () => {
-                    const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-                    const metadata = resolve(Obj.getTypename(object)!);
-                    const selection = selectionManager.getSelection(Obj.getDXN(object).toString());
-                    // TODO(wittjosiah): Use presence of selection to determine if the comment should be anchored.
-                    // Requires all components which support selection (e.g. table/kanban) to support anchored comments.
-                    const anchor = metadata.comments === 'anchored' ? getAnchor(selection) : Date.now().toString();
-                    const name = metadata.getAnchorLabel?.(object, anchor);
-                    void dispatch(
-                      createIntent(ThreadAction.Create, {
-                        anchor,
-                        name,
-                        subject: object,
-                      }),
-                    );
-                  },
-                  properties: {
-                    label: ['add comment label', { ns: meta.id }],
-                    icon: 'ph--chat-text--regular',
-                    disposition: 'toolbar',
-                    disabled,
-                    testId: 'thread.comment.add',
-                  },
-                },
-              ];
-            }),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-  ]);
-};
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+  }),
+);

package/src/capabilities/blueprint-definition.ts

@@ -2,37 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
-import { Blueprint, Template } from '@dxos/blueprints';
-import { type FunctionDefinition } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import * as Effect from 'effect/Effect';
 
-import { createProposals } from '../functions';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint } from '@dxos/compute';
 
-const functions: FunctionDefinition[] = [createProposals];
+import { ThreadBlueprint } from '#blueprints';
 
-export const ASSISTANT_BLUEPRINT_KEY = 'dxos.org/blueprint/thread';
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, ThreadBlueprint)]));
 
-export default (): Capability<any>[] => [
-  contributes(Capabilities.Functions, functions),
-  contributes(
-    Capabilities.BlueprintDefinition,
-    Blueprint.make({
-      key: ASSISTANT_BLUEPRINT_KEY,
-      name: 'Thread',
-      tools: Blueprint.toolDefinitions({ functions }),
-      instructions: Template.make({
-        // TODO(wittjosiah): Move example to function input schema annotation.
-        source: trim`
-            You can update markdown documents via proposals.
-            For each diff, respond with the smallest possible matching span.
-            For example:
-              - "There is a tyop in this sentence."
-              + "There is a typo in this sentence."
-              - "This id goof."
-              + "This is good."
-          `,
-      }),
-    }),
-  ),
-];
+export default blueprintDefinition;

package/src/capabilities/create-object.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { SpaceOperation } from '@dxos/plugin-space';
+import { SpaceCapabilities } from '@dxos/plugin-space';
+import { Channel } from '@dxos/types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+      id: Channel.Channel.typename,
+      createObject: (props, options) =>
+        Effect.gen(function* () {
+          const object = Channel.make(props);
+          return yield* Operation.invoke(SpaceOperation.AddObject, {
+            object,
+            target: options.target,
+            hidden: true,
+            targetNodeId: options.targetNodeId,
+          });
+        }),
+    });
+  }),
+);

package/src/capabilities/index.ts

@@ -2,17 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint, OperationHandlerSet } from '@dxos/compute';
 
-export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
-export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
-export const CallManager = lazy(() => import('./call-manager'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const Markdown = lazy(() => import('./markdown'));
-export const ReactRoot = lazy(() => import('./react-root'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const Repair = lazy(() => import('./repair'));
-export const ThreadSettings = lazy(() => import('./settings'));
-export const ThreadState = lazy(() => import('./state'));
-
-export * from './capabilities';
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+export const Markdown = Capability.lazy('Markdown', () => import('./markdown'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const ThreadSettings = Capability.lazy('ThreadSettings', () => import('./settings'));
+export const ThreadState = Capability.lazy('ThreadState', () => import('./state'));
+export const UndoMappings = Capability.lazy('UndoMappings', () => import('./undo-mappings'));

package/src/capabilities/markdown.ts

@@ -3,55 +3,70 @@
 //
 
 import { EditorView } from '@codemirror/view';
+import * as Effect from 'effect/Effect';
 
-import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { Obj } from '@dxos/echo';
-import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
 import { MarkdownCapabilities } from '@dxos/plugin-markdown';
-import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/react-ui-editor';
+import { linkedSegment } from '@dxos/react-ui-attention';
+import { type EditorState, commentClickedEffect, commentsState, documentId, overlap } from '@dxos/ui-editor';
+
+import { ThreadCapabilities } from '#types';
 
 import { threads } from '../extensions';
 
-import { ThreadCapabilities } from './capabilities';
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // Get context for lazy capability access in callbacks.
+    const capabilities = yield* Capability.Service;
 
-export default (context: PluginContext) =>
-  contributes(MarkdownCapabilities.Extensions, [
-    ({ document: doc }) => {
-      const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      const { state } = context.getCapability(ThreadCapabilities.MutableState);
-      return threads(state, doc, dispatch);
-    },
-    ({ document: doc }) => {
-      if (!doc) return [];
-      const { state } = context.getCapability(ThreadCapabilities.MutableState);
+    return Capability.contributes(MarkdownCapabilities.Extensions, [
+      ({ document: doc }) => {
+        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+        const registry = capabilities.get(Capabilities.AtomRegistry);
+        const stateAtom = capabilities.get(ThreadCapabilities.State);
+        return threads({ registry, stateAtom }, doc, invokePromise);
+      },
+      ({ document: doc }) => {
+        if (!doc) {
+          return [];
+        }
+        const registry = capabilities.get(Capabilities.AtomRegistry);
+        const stateAtom = capabilities.get(ThreadCapabilities.State);
 
-      return EditorView.updateListener.of((update) => {
-        if (update.docChanged || update.selectionSet) {
-          state.toolbar[Obj.getDXN(doc).toString()] = selectionOverlapsComment(update.state);
+        return EditorView.updateListener.of((update) => {
+          if (update.docChanged || update.selectionSet) {
+            const id = update.state.facet(documentId);
+            const overlaps = selectionOverlapsComment(update.state);
+            const current = registry.get(stateAtom);
+            registry.set(stateAtom, {
+              ...current,
+              toolbar: { ...current.toolbar, [id]: overlaps },
+            });
+          }
+        });
+      },
+      ({ document: doc }) => {
+        if (!doc) {
+          return [];
         }
-      });
-    },
-    ({ document: doc }) => {
-      if (!doc) return [];
-      const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      const id = Obj.getDXN(doc).toString();
+        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
 
-      return EditorView.updateListener.of((update) => {
-        update.transactions.forEach((transaction) => {
-          transaction.effects.forEach(async (effect) => {
-            if (effect.is(commentClickedEffect)) {
-              void dispatch(
-                createIntent(DeckAction.ChangeCompanion, {
-                  primary: id,
-                  companion: `${id}${ATTENDABLE_PATH_SEPARATOR}comments`,
-                }),
-              );
-            }
+        return EditorView.updateListener.of((update) => {
+          update.transactions.forEach((transaction) => {
+            transaction.effects.forEach(async (effect) => {
+              if (effect.is(commentClickedEffect)) {
+                void invokePromise(LayoutOperation.UpdateCompanion, {
+                  subject: linkedSegment('comments'),
+                });
+              }
+            });
           });
         });
-      });
-    },
-  ]);
+      },
+    ]);
+  }),
+);
 
 const selectionOverlapsComment = (state: EditorState): boolean => {
   // May not be defined if thread plugin not installed.

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+
+import { ThreadOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, ThreadOperationHandlerSet);
+  }),
+);