@dxos/plugin-thread 0.8.4-main.4a85c3132b → 0.8.4-main.51f1e5ca51

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -1,399 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
-import { sleep } from '@dxos/async';
-import { Obj, Relation, Type } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { OperationResolver } from '@dxos/operation';
-import { Operation } from '@dxos/operation';
-import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from '@dxos/plugin-deck/types';
-import { ObservabilityOperation } from '@dxos/plugin-observability/types';
-import { SpaceOperation } from '@dxos/plugin-space/types';
-import { Ref } from '@dxos/react-client/echo';
-import { ManagedCollection } from '@dxos/schema';
-import { AnchoredTo, Message, Thread } from '@dxos/types';
-
-import { meta } from '../../meta';
-import { Channel, ThreadCapabilities, ThreadOperation } from '../../types';
-
-export default Capability.makeModule(
-  Effect.fnUntraced(function* () {
-    return [
-      Capability.contributes(Capabilities.UndoMapping, [
-        UndoMapping.make({
-          operation: ThreadOperation.Delete,
-          inverse: ThreadOperation.Restore,
-          deriveContext: (_input, output) => {
-            // Return undefined if not undoable (e.g., draft deletion or no db).
-            if (!output.thread || !output.anchor) {
-              return;
-            }
-            return {
-              thread: output.thread,
-              anchor: output.anchor,
-            };
-          },
-          message: ['thread deleted label', { ns: meta.id }],
-        }),
-        UndoMapping.make({
-          operation: ThreadOperation.DeleteMessage,
-          inverse: ThreadOperation.RestoreMessage,
-          deriveContext: (input, output) => {
-            // Return undefined if not undoable (e.g., message not found or thread deleted).
-            if (!output.message || output.messageIndex === undefined) {
-              return;
-            }
-            return {
-              anchor: input.anchor,
-              message: output.message,
-              messageIndex: output.messageIndex,
-            };
-          },
-          message: ['message deleted label', { ns: meta.id }],
-        }),
-      ]),
-      Capability.contributes(Capabilities.OperationResolver, [
-        //
-        // CreateChannel
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.CreateChannel,
-          handler: (input) =>
-            Effect.sync(() => ({
-              object: Channel.make({ name: input.name }),
-            })),
-        }),
-
-        //
-        // CreateChannelThread
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.CreateChannelThread,
-          handler: (input) =>
-            Effect.sync(() => {
-              const thread = Thread.make({ status: 'active' });
-              const threadRef = Ref.make(thread);
-              Obj.change(input.channel, (c) => {
-                c.threads.push(threadRef);
-              });
-              return { object: thread };
-            }),
-        }),
-
-        //
-        // Select
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.Select,
-          handler: Effect.fnUntraced(function* (input) {
-            const registry = yield* Capability.get(Capabilities.AtomRegistry);
-            const stateAtom = yield* Capability.get(ThreadCapabilities.State);
-            const current = registry.get(stateAtom);
-            registry.set(stateAtom, { ...current, current: input.current });
-          }),
-        }),
-
-        //
-        // ToggleResolved
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.ToggleResolved,
-          handler: Effect.fnUntraced(function* (input) {
-            const thread = input.thread;
-
-            Obj.change(thread, (t) => {
-              if (t.status === 'active' || t.status === undefined) {
-                t.status = 'resolved';
-              } else if (t.status === 'resolved') {
-                t.status = 'active';
-              }
-            });
-
-            const db = Obj.getDatabase(thread);
-            invariant(db, 'Database not found');
-
-            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-              name: 'threads.toggle-resolved',
-              properties: {
-                spaceId: db.spaceId,
-                threadId: thread.id,
-              },
-            });
-          }),
-        }),
-
-        //
-        // OnCreateSpace
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.OnCreateSpace,
-          handler: Effect.fnUntraced(function* ({ space, isDefault, rootCollection }) {
-            if (isDefault) {
-              return;
-            }
-
-            const collection = ManagedCollection.makeManagedCollection({ key: Type.getTypename(Channel.Channel) });
-            Obj.change(rootCollection, (c) => {
-              c.objects.push(Ref.make(collection));
-            });
-
-            const { object: channel } = yield* Operation.invoke(ThreadOperation.CreateChannel, {
-              name: 'General',
-              spaceId: space.id,
-            });
-            space.db.add(channel);
-          }),
-        }),
-
-        //
-        // Create
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.Create,
-          handler: Effect.fnUntraced(function* ({ name, anchor: _anchor, subject }) {
-            const registry = yield* Capability.get(Capabilities.AtomRegistry);
-            const stateAtom = yield* Capability.get(ThreadCapabilities.State);
-            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 state = registry.get(stateAtom);
-            const existingDrafts = state.drafts[subjectId];
-            registry.set(stateAtom, {
-              ...state,
-              drafts: {
-                ...state.drafts,
-                [subjectId]: existingDrafts ? [...existingDrafts, anchor] : [anchor],
-              },
-            });
-
-            // Follow-up operations.
-            yield* Operation.invoke(ThreadOperation.Select, { current: Obj.getDXN(thread).toString() });
-            yield* Operation.invoke(DeckOperation.ChangeCompanion, {
-              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
-            });
-          }),
-        }),
-
-        //
-        // Delete
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.Delete,
-          handler: Effect.fnUntraced(function* ({ subject, anchor, thread: _thread }) {
-            const registry = yield* Capability.get(Capabilities.AtomRegistry);
-            const stateAtom = yield* Capability.get(ThreadCapabilities.State);
-            const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);
-            const subjectId = Obj.getDXN(subject).toString();
-            const state = registry.get(stateAtom);
-            const draft = state.drafts[subjectId];
-            if (draft) {
-              // Check if we're deleting a draft; if so, remove it.
-              const index = draft.findIndex((a: { id: string }) => a.id === anchor.id);
-              if (index !== -1) {
-                registry.set(stateAtom, {
-                  ...state,
-                  drafts: {
-                    ...state.drafts,
-                    [subjectId]: state.drafts[subjectId]?.filter((_, i) => i !== index),
-                  },
-                });
-                // Draft deletion is not undoable.
-                return {};
-              }
-            }
-
-            const db = Obj.getDatabase(thread);
-            if (!db) {
-              return {};
-            }
-
-            // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-            db.remove(anchor);
-            yield* Effect.promise(() => sleep(100));
-            db.remove(thread);
-
-            // Schedule analytics event as followup (doesn't block return).
-            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-              name: 'threads.delete',
-              properties: {
-                spaceId: db.spaceId,
-                threadId: thread.id,
-              },
-            });
-
-            // Return data needed for undo.
-            return { thread, anchor };
-          }),
-        }),
-
-        //
-        // AddMessage
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.AddMessage,
-          handler: Effect.fnUntraced(function* ({ anchor, subject, sender, text }) {
-            const registry = yield* Capability.get(Capabilities.AtomRegistry);
-            const stateAtom = yield* Capability.get(ThreadCapabilities.State);
-            const thread = Relation.getSource(anchor) as Thread.Thread;
-            const subjectId = Obj.getDXN(subject).toString();
-            const db = Obj.getDatabase(subject);
-            invariant(db, 'Database not found');
-
-            const message = Obj.make(Message.Message, {
-              created: new Date().toISOString(),
-              sender,
-              blocks: [{ _tag: 'text', text }],
-            });
-            Obj.change(thread, (t) => {
-              t.messages.push(Ref.make(message));
-            });
-
-            const state = registry.get(stateAtom);
-            const draft = state.drafts[subjectId]?.find((a: { id: string }) => a.id === anchor.id);
-            if (draft) {
-              // Move draft to document.
-              Obj.change(thread, (t) => {
-                t.status = 'active';
-              });
-              registry.set(stateAtom, {
-                ...state,
-                drafts: {
-                  ...state.drafts,
-                  [subjectId]: state.drafts[subjectId]?.filter((a: { id: string }) => a.id !== anchor.id),
-                },
-              });
-              yield* Operation.invoke(SpaceOperation.AddObject, { object: thread, target: db, hidden: true });
-              yield* Operation.invoke(SpaceOperation.AddRelation, {
-                db,
-                schema: AnchoredTo.AnchoredTo,
-                source: thread,
-                target: subject,
-                fields: { anchor: draft.anchor },
-              });
-              yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-                name: 'threads.create',
-                properties: {
-                  spaceId: db.spaceId,
-                  threadId: thread.id,
-                },
-              });
-            }
-
-            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-              name: 'threads.message.add',
-              properties: {
-                spaceId: db.spaceId,
-                threadId: thread.id,
-                threadLength: thread.messages.length,
-                messageId: message.id,
-                messageLength: text.length,
-              },
-            });
-          }),
-        }),
-
-        //
-        // DeleteMessage
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.DeleteMessage,
-          handler: Effect.fnUntraced(function* ({ subject, anchor, messageId }) {
-            const thread = Relation.getSource(anchor) as Thread.Thread;
-            const db = Obj.getDatabase(subject);
-            invariant(db, 'Database not found');
-
-            const msgIndex = thread.messages.findIndex((ref) => ref.target?.id === messageId);
-            const msg = thread.messages[msgIndex]?.target;
-            if (!msg) {
-              return { messageIndex: -1 };
-            }
-
-            if (msgIndex === 0 && thread.messages.length === 1) {
-              // TODO(wittjosiah): This doesn't support restoring the thread.
-              yield* Operation.invoke(ThreadOperation.Delete, { subject, anchor });
-              return { messageIndex: -1 };
-            }
-
-            Obj.change(thread, (t) => {
-              t.messages.splice(msgIndex, 1);
-            });
-
-            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-              name: 'threads.message.delete',
-              properties: {
-                spaceId: db.spaceId,
-                threadId: thread.id,
-                threadLength: thread.messages.length,
-                messageId,
-              },
-            });
-
-            // Return data needed for undo.
-            return { message: msg, messageIndex: msgIndex };
-          }),
-        }),
-
-        //
-        // Restore (inverse of Delete)
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.Restore,
-          handler: Effect.fnUntraced(function* ({ thread, anchor }) {
-            const db = Obj.getDatabase(thread);
-            if (!db) {
-              return;
-            }
-
-            // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-            db.add(thread);
-            yield* Effect.promise(() => sleep(100));
-            db.add(anchor);
-
-            // Schedule analytics event as followup (doesn't block return).
-            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-              name: 'threads.undo-delete',
-              properties: {
-                spaceId: db.spaceId,
-                threadId: thread.id,
-              },
-            });
-          }),
-        }),
-
-        //
-        // RestoreMessage (inverse of DeleteMessage)
-        //
-        OperationResolver.make({
-          operation: ThreadOperation.RestoreMessage,
-          handler: Effect.fnUntraced(function* ({ anchor, message, messageIndex }) {
-            const thread = Relation.getSource(anchor) as Thread.Thread;
-            const db = Obj.getDatabase(thread);
-            invariant(db, 'Database not found');
-
-            Obj.change(thread, (t) => {
-              t.messages.splice(messageIndex, 0, Ref.make(message));
-            });
-
-            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-              name: 'threads.message.undo-delete',
-              properties: {
-                spaceId: db.spaceId,
-                threadId: thread.id,
-                messageId: message.id,
-              },
-            });
-          }),
-        }),
-      ]),
-    ];
-  }),
-);

package/src/capabilities/react-root/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capability } from '@dxos/app-framework';
-
-export const ReactRoot = Capability.lazy('ReactRoot', () => import('./react-root'));

package/src/capabilities/react-surface/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capability } from '@dxos/app-framework';
-
-export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/repair/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capability } from '@dxos/app-framework';
-
-export const Repair = Capability.lazy('Repair', () => import('./repair'));

package/src/capabilities/repair/repair.ts

@@ -1,55 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capability } from '@dxos/app-framework';
-import { Obj, Ref, Type } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
-import { SpaceCapabilities } from '@dxos/plugin-space';
-import { type Space } from '@dxos/react-client/echo';
-import { ManagedCollection } from '@dxos/schema';
-
-import { Channel } from '../../types';
-
-export default Capability.makeModule(() =>
-  Effect.succeed(
-    Capability.contributes(
-      SpaceCapabilities.Repair,
-      async ({ space, isDefault }: { space: Space; isDefault: boolean }) => {
-        if (isDefault) {
-          return;
-        }
-
-        await ensureSystemCollection(space);
-      },
-    ),
-  ),
-);
-
-/**
- * Ensure the root collection has a system collection for Channels.
- */
-const ensureSystemCollection = async (space: Space) => {
-  const rootCollection: Collection.Collection = await space.properties[Collection.Collection.typename]?.load();
-  if (!rootCollection) {
-    return;
-  }
-
-  const objects = await Promise.all(rootCollection.objects.map((ref) => ref.load()));
-  const channels = objects.find(
-    (object) =>
-      Obj.instanceOf(ManagedCollection.ManagedCollection, object) && object.key === Type.getTypename(Channel.Channel),
-  );
-  if (channels) {
-    return;
-  }
-
-  const channelCollectionRef = Ref.make(
-    ManagedCollection.makeManagedCollection({ key: Type.getTypename(Channel.Channel) }),
-  );
-  Obj.change(rootCollection, (c) => {
-    c.objects.push(channelCollectionRef);
-  });
-};

package/src/capabilities/settings/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capability } from '@dxos/app-framework';
-
-export const ThreadSettings = Capability.lazy('ThreadSettings', () => import('./settings'));

package/src/capabilities/state/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capability } from '@dxos/app-framework';
-
-export const ThreadState = Capability.lazy('ThreadState', () => import('./state'));

package/src/containers/ThreadSettings/ThreadSettings.tsx

@@ -1,22 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import React from 'react';
-
-import { useTranslation } from '@dxos/react-ui';
-import { Settings } from '@dxos/react-ui-form';
-
-import { meta } from '../../meta';
-import type { ThreadSettingsProps } from '../../types';
-
-export type ThreadSettingsComponentProps = {
-  settings: ThreadSettingsProps;
-  onSettingsChange: (fn: (current: ThreadSettingsProps) => ThreadSettingsProps) => void;
-};
-
-// TODO(burdon): Settings.
-export const ThreadSettings = ({ settings: _settings }: ThreadSettingsComponentProps) => {
-  const { t: _t } = useTranslation(meta.id);
-  return <Settings.Root></Settings.Root>;
-};

package/src/containers/ThreadSettings/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { ThreadSettings } from './ThreadSettings';
-
-export default ThreadSettings;

package/src/functions/create-proposals.ts

@@ -1,57 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-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 { computeDiffsWithCursors } from '@dxos/assistant';
-import { Database, Obj, Ref, Relation } from '@dxos/echo';
-import { createDocAccessor } from '@dxos/echo-db';
-import { defineFunction } from '@dxos/functions';
-import { Markdown } from '@dxos/plugin-markdown/types';
-import { AnchoredTo, Message, Thread } from '@dxos/types';
-
-export default defineFunction({
-  key: 'dxos.org/function/thread/create-proposals',
-  name: 'Create Proposals',
-  description: 'Proposes a set of changes to a document.',
-  inputSchema: Schema.Struct({
-    doc: Ref.Ref(Markdown.Document).annotations({
-      description: 'The ID of the document.',
-    }),
-    diffs: Schema.Array(Schema.String).annotations({
-      description: 'The diffs to propose for the document.',
-    }),
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { doc, diffs: _diffs } }) {
-    const object = yield* Database.load(doc);
-    const content = yield* Effect.promise(() => object.content.load());
-    const accessor = createDocAccessor(content, ['content']);
-
-    yield* Function.pipe(
-      computeDiffsWithCursors(accessor, _diffs),
-      Array.map(
-        Effect.fnUntraced(function* ({ cursor, text }) {
-          const proposal = Obj.make(Message.Message, {
-            created: new Date().toISOString(),
-            sender: { role: 'assistant' },
-            blocks: [{ _tag: 'proposal', text }],
-          });
-          const thread = Thread.make({ name: 'Proposal', messages: [Ref.make(proposal)], status: 'active' });
-          const relation = Relation.make(AnchoredTo.AnchoredTo, {
-            [Relation.Source]: thread,
-            [Relation.Target]: object,
-            anchor: cursor,
-          });
-          yield* Database.add(thread);
-          yield* Database.add(relation);
-        }),
-      ),
-      Effect.allWith({ concurrency: 'unbounded' }),
-    );
-  }),
-});

package/src/functions/index.ts

@@ -1,9 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import CreateProposals from './create-proposals';
-
-export const ThreadFunctions = {
-  CreateProposals,
-};

package/src/testing/stories.ts

@@ -1,56 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { OperationPlugin, type Plugin } from '@dxos/app-framework';
-import { ClientPlugin } from '@dxos/plugin-client';
-import { GraphPlugin } from '@dxos/plugin-graph';
-import { SettingsPlugin } from '@dxos/plugin-settings';
-import { SpacePlugin } from '@dxos/plugin-space';
-import { ThemePlugin } from '@dxos/plugin-theme';
-import { Config } from '@dxos/react-client';
-import { defaultTx } from '@dxos/ui-theme';
-
-import { ThreadPlugin } from '../ThreadPlugin';
-import { Channel } from '../types';
-
-export const createThreadPlugins = async (): Promise<Array<Plugin.Plugin>> => [
-  ThemePlugin({ tx: defaultTx }),
-  ClientPlugin({
-    onClientInitialized: ({ client }) =>
-      Effect.gen(function* () {
-        yield* Effect.promise(() => client.halo.createIdentity({ displayName: 'Test User' }));
-      }),
-    onSpacesReady: ({ client }) =>
-      Effect.gen(function* () {
-        yield* Effect.promise(() => client.spaces.default.waitUntilReady());
-        client.spaces.default.db.add(Channel.make());
-      }),
-    config: new Config({
-      runtime: {
-        client: {
-          edgeFeatures: {
-            signaling: true,
-          },
-        },
-        services: {
-          edge: {
-            url: 'https://edge.dxos.workers.dev/',
-          },
-          iceProviders: [
-            {
-              urls: 'https://edge.dxos.workers.dev/ice',
-            },
-          ],
-        },
-      },
-    }),
-  }),
-  SpacePlugin({}),
-  OperationPlugin(),
-  SettingsPlugin(),
-  GraphPlugin(),
-  ThreadPlugin(),
-];