@dxos/plugin-thread 0.8.4-main.70d3990 → 0.8.4-main.7996785055

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

@@ -1,194 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Atom } from '@effect-atom/atom-react';
-import * as Function from 'effect/Function';
-import * as Option from 'effect/Option';
-
-import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-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 { meta } from '../meta';
-import { Channel, ThreadAction } from '../types';
-import { getAnchor } from '../util';
-
-import { ThreadCapabilities } from './capabilities';
-
-// 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 ?? {};
-
-  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',
-                          },
-                        },
-                      ]
-                    : [],
-                ),
-              );
-            }),
-            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 [];
-              }
-
-              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',
-                  },
-                },
-              ];
-            }),
-            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',
-                },
-              },
-            ]),
-            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(() => []),
-          ),
-        ),
-    }),
-  ]);
-};

package/src/capabilities/blueprint-definition.ts

@@ -1,38 +0,0 @@
-//
-// 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 { createProposals } from '../functions';
-
-const functions: FunctionDefinition[] = [createProposals];
-
-export const ASSISTANT_BLUEPRINT_KEY = 'dxos.org/blueprint/thread';
-
-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."
-          `,
-      }),
-    }),
-  ),
-];

package/src/capabilities/call-manager.ts

@@ -1,20 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type PluginContext, contributes } from '@dxos/app-framework';
-import { ClientCapabilities } from '@dxos/plugin-client';
-
-import { CallManager } from '../calls';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default async (context: PluginContext) => {
-  const client = context.getCapability(ClientCapabilities.Client);
-  const callManager = new CallManager(client);
-  await callManager.open();
-
-  return contributes(ThreadCapabilities.CallManager, callManager, () => {
-    void callManager.close();
-  });
-};

package/src/capabilities/capabilities.ts

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineCapability } from '@dxos/app-framework';
-import { type DeepReadonly } from '@dxos/util';
-
-import { type CallManager, type CallState, type MediaState } from '../calls';
-import { meta } from '../meta';
-import { type Channel, type ThreadState, type ViewState } from '../types';
-
-export namespace ThreadCapabilities {
-  export const CallManager = defineCapability<CallManager>(`${meta.id}/capability/call-manager`);
-
-  // TODO(burdon): Better way to define specific extensions for meeting companions.
-  // TODO(burdon): This brings in deps from ../calls; how should we manage/minimize explicit type exposure to other plugins?
-  // TODO(wittjosiah): These callbacks could be intents once we support broadcast.
-  export type CallProperties = {
-    onJoin: (state: { channel?: Channel.Channel; roomId?: string }) => Promise<void>;
-    onLeave: (roomId?: string) => Promise<void>;
-    onCallStateUpdated: (callState: CallState) => Promise<void>;
-    onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => Promise<void>;
-  };
-  export const CallExtension = defineCapability<CallProperties>(`${meta.id}/capability/call-extension`);
-
-  type GetViewState = (subjectId: string) => ViewState;
-  export const State = defineCapability<{ state: DeepReadonly<ThreadState>; getViewState: GetViewState }>(
-    `${meta.id}/capability/state`,
-  );
-  export const MutableState = defineCapability<{ state: ThreadState; getViewState: GetViewState }>(
-    `${meta.id}/capability/state`,
-  );
-}

package/src/capabilities/intent-resolver.ts

@@ -1,311 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
-import { sleep } from '@dxos/async';
-import { Obj, Relation, Type } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
-import { ObservabilityAction } from '@dxos/plugin-observability/types';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Ref, getSpace } from '@dxos/react-client/echo';
-import { Collection } from '@dxos/schema';
-import { AnchoredTo, Message, Thread } from '@dxos/types';
-
-import { meta } from '../meta';
-import { Channel, ThreadAction } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: ThreadAction.OnCreateSpace,
-      resolve: ({ space, isDefault, rootCollection }) =>
-        Effect.gen(function* () {
-          if (isDefault) {
-            return;
-          }
-
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const collection = Collection.makeManaged({ key: Type.getTypename(Channel.Channel) });
-          rootCollection.objects.push(Ref.make(collection));
-
-          const { object: channel } = yield* dispatch(
-            createIntent(ThreadAction.CreateChannel, { name: 'General', spaceId: space.id }),
-          );
-          space.db.add(channel);
-        }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannel,
-      resolve: ({ name }) => ({
-        data: {
-          object: Channel.make({ name }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannelThread,
-      resolve: ({ channel }) => {
-        const thread = Thread.make({ status: 'active' });
-        channel.threads.push(Ref.make(thread));
-        return {
-          data: {
-            object: thread,
-          },
-        };
-      },
-    }),
-    // TODO(wittjosiah): Break this up into more composable pieces.
-    createResolver({
-      intent: ThreadAction.Create,
-      resolve: ({ name, anchor: _anchor, subject }) => {
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = Obj.getDXN(subject).toString();
-        const thread = Thread.make({ name });
-        const anchor = Relation.make(AnchoredTo.AnchoredTo, {
-          [Relation.Source]: thread,
-          [Relation.Target]: subject,
-          anchor: _anchor,
-        });
-
-        const draft = state.drafts[subjectId];
-        if (draft) {
-          draft.push(anchor);
-        } else {
-          state.drafts[subjectId] = [anchor];
-        }
-
-        return {
-          intents: [
-            createIntent(ThreadAction.Select, { current: Obj.getDXN(thread).toString() }),
-            createIntent(DeckAction.ChangeCompanion, {
-              primary: subjectId,
-              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.Select,
-      resolve: ({ current }) => {
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        state.current = current;
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.ToggleResolved,
-      resolve: ({ thread }) => {
-        if (thread.status === 'active' || thread.status === undefined) {
-          thread.status = 'resolved';
-        } else if (thread.status === 'resolved') {
-          thread.status = 'active';
-        }
-
-        const space = getSpace(thread);
-        invariant(space, 'Space not found');
-        const spaceId = space.id;
-
-        return {
-          intents: [
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.toggle-resolved',
-              properties: {
-                spaceId,
-                threadId: thread.id,
-              },
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.Delete,
-      resolve: async ({ subject, anchor, thread: _thread }, undo) => {
-        const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = Obj.getDXN(subject).toString();
-        const draft = state.drafts[subjectId];
-        if (draft) {
-          // Check if we're deleting a draft; if so, remo ve it.
-          const index = draft.findIndex((a) => a.id === anchor.id);
-          if (index !== -1) {
-            draft.splice(index, 1);
-            return;
-          }
-        }
-
-        const space = getSpace(anchor);
-        if (!space) {
-          return;
-        }
-
-        if (!undo) {
-          // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-          space.db.remove(anchor);
-          await sleep(100);
-          space.db.remove(thread);
-
-          return {
-            undoable: {
-              message: ['thread deleted label', { ns: meta.id }],
-              data: { thread, anchor },
-            },
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                },
-              }),
-            ],
-          };
-        } else {
-          // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-          space.db.add(thread);
-          await sleep(100);
-          space.db.add(anchor);
-
-          return {
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.undo-delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                },
-              }),
-            ],
-          };
-        }
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.AddMessage,
-      resolve: ({ anchor, subject, sender, text }) => {
-        const thread = Relation.getSource(anchor) as Thread.Thread;
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = Obj.getDXN(subject).toString();
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const message = Obj.make(Message.Message, {
-          created: new Date().toISOString(),
-          sender,
-          blocks: [{ _tag: 'text', text }],
-          // TODO(wittjosiah): Context based on attention.
-          // context: context ? Ref.make(context) : undefined,
-        });
-        thread.messages.push(Ref.make(message));
-
-        const intents = [];
-        const draft = state.drafts[subjectId]?.find((a) => a.id === anchor.id);
-        if (draft) {
-          // Move draft to document.
-          thread.status = 'active';
-          // TODO(wittjosiah): This causes the thread to flash as it transitions from draft to db.
-          state.drafts[subjectId] = state.drafts[subjectId]?.filter((a) => a.id !== anchor.id);
-          intents.push(createIntent(SpaceAction.AddObject, { object: thread, target: space, hidden: true }));
-          intents.push(
-            createIntent(SpaceAction.AddRelation, {
-              space,
-              schema: AnchoredTo.AnchoredTo,
-              source: thread,
-              target: subject,
-              fields: { anchor: draft.anchor },
-            }),
-          );
-          intents.push(
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.create',
-              properties: {
-                spaceId: space.id,
-                threadId: thread.id,
-              },
-            }),
-          );
-        }
-
-        intents.push(
-          createIntent(ObservabilityAction.SendEvent, {
-            name: 'threads.message.add',
-            properties: {
-              spaceId: space.id,
-              threadId: thread.id,
-              threadLength: thread.messages.length,
-              messageId: message.id,
-              messageLength: text.length,
-            },
-          }),
-        );
-
-        return { intents };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.DeleteMessage,
-      resolve: ({ subject, anchor, messageId, message, messageIndex }, undo) => {
-        const thread = Relation.getSource(anchor) as Thread.Thread;
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        if (!undo) {
-          const messageIndex = thread.messages.findIndex(Ref.hasObjectId(messageId));
-          const message = thread.messages[messageIndex]?.target;
-          if (!message) {
-            return;
-          }
-
-          if (messageIndex === 0 && thread.messages.length === 1) {
-            // If the message is the only message in the thread, delete the thread.
-            return {
-              intents: [createIntent(ThreadAction.Delete, { subject, anchor })],
-            };
-          } else {
-            thread.messages.splice(messageIndex, 1);
-          }
-
-          return {
-            undoable: {
-              message: ['message deleted label', { ns: meta.id }],
-              data: { message, messageIndex },
-            },
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.message.delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                  messageId: message.id,
-                },
-              }),
-            ],
-          };
-        } else {
-          if (messageIndex === undefined || !message) {
-            return;
-          }
-
-          thread.messages.splice(messageIndex, 0, Ref.make(message));
-          return {
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.message.undo-delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                  messageId: message.id,
-                },
-              }),
-            ],
-          };
-        }
-      },
-    }),
-  ]);

package/src/capabilities/markdown.ts

@@ -1,71 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { EditorView } from '@codemirror/view';
-
-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 { MarkdownCapabilities } from '@dxos/plugin-markdown';
-import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/react-ui-editor';
-
-import { threads } from '../extensions';
-
-import { ThreadCapabilities } from './capabilities';
-
-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 EditorView.updateListener.of((update) => {
-        if (update.docChanged || update.selectionSet) {
-          state.toolbar[Obj.getDXN(doc).toString()] = selectionOverlapsComment(update.state);
-        }
-      });
-    },
-    ({ document: doc }) => {
-      if (!doc) return [];
-      const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      const id = Obj.getDXN(doc).toString();
-
-      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`,
-                }),
-              );
-            }
-          });
-        });
-      });
-    },
-  ]);
-
-const selectionOverlapsComment = (state: EditorState): boolean => {
-  // May not be defined if thread plugin not installed.
-  const commentState = state.field(commentsState, false);
-  if (commentState === undefined) {
-    return false;
-  }
-
-  const { selection } = state;
-  for (const range of selection.ranges) {
-    if (commentState.comments.some(({ range: commentRange }) => overlap(commentRange, range))) {
-      return true;
-    }
-  }
-
-  return false;
-};

package/src/capabilities/react-root.tsx

@@ -1,17 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { Capabilities, contributes } from '@dxos/app-framework';
-
-import { Call } from '../components';
-import { meta } from '../meta';
-
-export default () => {
-  return contributes(Capabilities.ReactRoot, {
-    id: meta.id,
-    root: () => <Call.Audio />,
-  });
-};