@dxos/plugin-thread 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/src/capabilities/intent-resolver.ts

@@ -1,348 +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 { CollectionAction, SpaceAction } from '@dxos/plugin-space/types';
-import { Ref, fullyQualifiedId, getSpace } from '@dxos/react-client/echo';
-import { AnchoredTo, DataType } from '@dxos/schema';
-
-import { meta } from '../meta';
-import { ChannelType, ThreadAction, ThreadType } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: ThreadAction.onCreateSpace,
-      resolve: ({ space, rootCollection }) =>
-        Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const { object: collection } = yield* dispatch(
-            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(ChannelType) }),
-          );
-          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: Obj.make(ChannelType, {
-            name,
-            defaultThread: Ref.make(Obj.make(ThreadType, { messages: [], status: 'active' })),
-            threads: [],
-          }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannelThread,
-      resolve: ({ channel }) => {
-        const thread = Obj.make(ThreadType, { messages: [], 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 space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const thread = Obj.make(ThreadType, { name, messages: [], status: 'staged' });
-        const anchor = Relation.make(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: fullyQualifiedId(thread) }),
-            createIntent(DeckAction.ChangeCompanion, {
-              primary: subjectId,
-              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.AddProposal,
-      resolve: ({ text, anchor, sender, subject }) => {
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const subjectId = fullyQualifiedId(subject);
-        const proposal = Obj.make(DataType.Message, {
-          created: new Date().toISOString(),
-          sender,
-          blocks: [{ _tag: 'proposal', text }],
-        });
-        const thread = Obj.make(ThreadType, { name: 'Proposal', messages: [Ref.make(proposal)], status: 'active' });
-
-        return {
-          intents: [
-            createIntent(SpaceAction.AddObject, { object: thread, target: space, hidden: true }),
-            createIntent(SpaceAction.AddRelation, {
-              space,
-              schema: AnchoredTo,
-              source: thread,
-              target: subject,
-              fields: { anchor },
-            }),
-            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
-            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 ThreadType);
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        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 ThreadType;
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const message = Obj.make(DataType.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,
-              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 ThreadType;
-        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,69 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { EditorView } from '@codemirror/view';
-
-import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
-import { MarkdownCapabilities } from '@dxos/plugin-markdown';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
-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 }) => {
-      const { state } = context.getCapability(ThreadCapabilities.MutableState);
-
-      return EditorView.updateListener.of((update) => {
-        if (update.docChanged || update.selectionSet) {
-          state.toolbar[fullyQualifiedId(doc)] = selectionOverlapsComment(update.state);
-        }
-      });
-    },
-    ({ document: doc }) => {
-      const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      const id = fullyQualifiedId(doc);
-
-      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 />,
-  });
-};

package/src/capabilities/react-surface.tsx

@@ -1,89 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { Capabilities, contributes, createSurface, useCapability } from '@dxos/app-framework';
-import { Obj, type Ref } from '@dxos/echo';
-import { SettingsStore } from '@dxos/local-storage';
-import { getSpace } from '@dxos/react-client/echo';
-
-import {
-  CallDebugPanel,
-  CallSidebar,
-  ChannelContainer,
-  ChatContainer,
-  ThreadComplementary,
-  ThreadSettings,
-} from '../components';
-import { meta } from '../meta';
-import { ChannelType, type ThreadSettingsProps, ThreadType } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${meta.id}/channel`,
-      role: 'article',
-      filter: (data): data is { subject: ChannelType } => Obj.instanceOf(ChannelType, data.subject),
-      component: ({ data: { subject: channel }, role }) => <ChannelContainer channel={channel} role={role} />,
-    }),
-    createSurface({
-      id: `${meta.id}/chat-companion`,
-      role: 'article',
-      filter: (data): data is { companionTo: ChannelType; subject: 'chat' } =>
-        Obj.instanceOf(ChannelType, data.companionTo) && data.subject === 'chat',
-      component: ({ data: { companionTo: channel } }) => {
-        const space = getSpace(channel);
-        const thread = channel.defaultThread.target;
-        if (!space || !thread) {
-          return null;
-        }
-
-        return <ChatContainer thread={thread} space={space} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/thread`,
-      role: 'article',
-      filter: (data): data is { subject: ThreadType } => Obj.instanceOf(ThreadType, data.subject),
-      component: ({ data: { subject: thread } }) => {
-        const space = getSpace(thread);
-        if (!space || !thread) {
-          return null;
-        }
-
-        return <ChatContainer thread={thread} space={space} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/comments`,
-      role: 'article',
-      filter: (data): data is { companionTo: { threads: Ref.Ref<ThreadType>[] } } =>
-        data.subject === 'comments' && Obj.isObject(data.companionTo),
-      // TODO(wittjosiah): This isn't scrolling properly in a plank.
-      component: ({ data }) => <ThreadComplementary subject={data.companionTo} />,
-    }),
-    createSurface({
-      id: `${meta.id}/plugin-settings`,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<ThreadSettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
-      component: ({ data: { subject } }) => <ThreadSettings settings={subject.value} />,
-    }),
-    createSurface({
-      id: `${meta.id}/assistant`,
-      role: 'deck-companion--active-call',
-      component: () => <CallSidebar />,
-    }),
-    createSurface({
-      id: `${meta.id}/devtools-overview`,
-      role: 'devtools-overview',
-      component: () => {
-        const call = useCapability(ThreadCapabilities.CallManager);
-        return <CallDebugPanel state={call.state} />;
-      },
-    }),
-  ]);

package/src/capabilities/settings.ts

@@ -1,19 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
-
-import { meta } from '../meta';
-import { type ThreadSettingsProps, ThreadSettingsSchema } from '../types';
-
-export default () => {
-  const settings = live<ThreadSettingsProps>({});
-
-  return contributes(Capabilities.Settings, {
-    prefix: meta.id,
-    schema: ThreadSettingsSchema,
-    value: settings,
-  });
-};

package/src/capabilities/state.ts

@@ -1,26 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
-
-import { type ThreadState, type ViewStore } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-const initialViewState = { showResolvedThreads: false };
-
-export default () => {
-  const state = live<ThreadState>({ toolbar: {}, drafts: {} });
-  const viewStore = live<ViewStore>({});
-
-  const getViewState = (subjectId: string) => {
-    if (!viewStore[subjectId]) {
-      viewStore[subjectId] = { ...initialViewState };
-    }
-    return viewStore[subjectId];
-  };
-
-  return contributes(ThreadCapabilities.State, { state, getViewState });
-};

package/src/capabilities/toolkit.ts

@@ -1,82 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Tool from '@effect/ai/Tool';
-import * as Toolkit from '@effect/ai/Toolkit';
-import * as Array from 'effect/Array';
-import * as Effect from 'effect/Effect';
-import * as Function from 'effect/Function';
-import * as Schema from 'effect/Schema';
-
-import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { ArtifactId, computeDiffsWithCursors } from '@dxos/assistant';
-import { type SpaceId } from '@dxos/keys';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { type Markdown } from '@dxos/plugin-markdown/types';
-import { createDocAccessor } from '@dxos/react-client/echo';
-import { trim } from '@dxos/util';
-
-import { ThreadAction } from '../types';
-
-// TODO(wittjosiah): How to make this work for more than Documents?
-class ThreadToolkit extends Toolkit.make(
-  Tool.make('add-proposals', {
-    description: trim`
-      Proposes a set of changes to a document.
-    `,
-    parameters: {
-      id: ArtifactId,
-      diffs: Schema.Array(Schema.String).annotations({
-        description: 'The diffs to propose for the document.',
-      }),
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-) {
-  static layer = (context: PluginContext) =>
-    ThreadToolkit.toLayer({
-      'add-proposals': ({ id, diffs: _diffs }) =>
-        Effect.gen(function* () {
-          // TODO(wittjosiah): Get capabilities via layers.
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const client = context.getCapability(ClientCapabilities.Client);
-          const state = context.getCapability(Capabilities.Layout);
-
-          const dxn = ArtifactId.toDXN(id, state.workspace as SpaceId);
-
-          const echoDxn = dxn.asEchoDXN();
-          if (!echoDxn) {
-            throw new Error(`Invalid object ID: ${id}`);
-          }
-
-          const space = client.spaces.get(echoDxn.spaceId!);
-          const object = space?.db.getObjectById<Markdown.Document>(echoDxn.echoId);
-          if (!object) {
-            throw new Error(`Object not found: ${id}`);
-          }
-
-          const content = yield* Effect.promise(() => object.content.load());
-          const accessor = createDocAccessor(content, ['content']);
-          yield* Function.pipe(
-            computeDiffsWithCursors(accessor, _diffs),
-            Array.map(({ cursor, text }) =>
-              createIntent(ThreadAction.AddProposal, {
-                subject: object,
-                sender: { role: 'assistant' },
-                anchor: cursor,
-                text,
-              }),
-            ),
-            Array.map(dispatch),
-            Effect.allWith({ concurrency: 'unbounded' }),
-          );
-        }).pipe(Effect.orDie),
-    });
-}
-
-export default (context: PluginContext) => [
-  contributes(Capabilities.Toolkit, ThreadToolkit),
-  contributes(Capabilities.ToolkitHandler, ThreadToolkit.layer(context)),
-];

package/src/components/CallSidebar.tsx

@@ -1,18 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import React from 'react';
-
-import { useCapability } from '@dxos/app-framework';
-
-import { ThreadCapabilities } from '../capabilities';
-
-import { ChannelContainer } from './ChannelContainer';
-
-export const CallSidebar = () => {
-  const call = useCapability(ThreadCapabilities.CallManager);
-  return <ChannelContainer roomId={call.roomId} />;
-};
-
-export default CallSidebar;