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

package/dist/types/src/types/schema.d.ts

@@ -1,179 +0,0 @@
-import * as Schema from 'effect/Schema';
-import { Type } from '@dxos/echo';
-export declare const ThreadStatus: Schema.Union<[Schema.Literal<["staged"]>, Schema.Literal<["active"]>, Schema.Literal<["resolved"]>]>;
-declare const _ThreadType: Type.obj<Schema.Struct<{
-    name: Schema.optional<typeof Schema.String>;
-    status: Schema.optional<Schema.Union<[Schema.Literal<["staged"]>, Schema.Literal<["active"]>, Schema.Literal<["resolved"]>]>>;
-    messages: Schema.mutable<Schema.Array$<Type.ref<Type.obj<Schema.Struct<{
-        id: import("@dxos/keys").ObjectIdClass;
-        parentMessage: Schema.optional<import("@dxos/keys").ObjectIdClass>;
-        created: Schema.SchemaClass<string, string, never>;
-        sender: Schema.mutable<Schema.Struct<{
-            contact: Schema.optional<Type.ref<Type.obj<Schema.Struct<{
-                fullName: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                preferredName: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                nickname: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                image: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                organization: Schema.optional<Schema.Schema<import("@dxos/echo/internal").Ref<Type.OfKind<import("@dxos/echo/internal").EntityKind.Object> & {
-                    id: string;
-                    description?: string | undefined;
-                    name?: string | undefined;
-                    status?: "prospect" | "qualified" | "active" | "commit" | "reject" | undefined;
-                    image?: string | undefined;
-                    website?: string | undefined;
-                }>, import("@dxos/echo-protocol").EncodedReference, never>>;
-                jobTitle: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                department: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                notes: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                emails: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: Schema.refine<string, typeof Schema.String>;
-                }>>>>;
-                identities: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: typeof Schema.String;
-                }>>>>;
-                phoneNumbers: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: typeof Schema.String;
-                }>>>>;
-                addresses: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: Schema.Struct<{
-                        street: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        extended: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        locality: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        region: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        postalCode: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        postOfficeBoxNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        country: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                    }>;
-                }>>>>;
-                urls: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: Schema.refine<string, typeof Schema.String>;
-                }>>>>;
-                birthday: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                fields: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    category: Schema.optional<typeof Schema.String>;
-                    label: typeof Schema.String;
-                    value: typeof Schema.String;
-                }>>>>;
-            }>>>>;
-            identityDid: Schema.optional<typeof Schema.String>;
-            identityKey: Schema.optional<typeof Schema.String>;
-            email: Schema.optional<typeof Schema.String>;
-            name: Schema.optional<typeof Schema.String>;
-            role: Schema.optional<Schema.Literal<["user", "assistant", "tool"]>>;
-        }>>;
-        blocks: Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.TaggedStruct<"anchor", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            objectId: import("@dxos/keys").ObjectIdClass;
-            version: typeof Schema.Unknown;
-        }>>, Schema.mutable<Schema.TaggedStruct<"file", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            url: typeof Schema.String;
-            name: Schema.optional<typeof Schema.String>;
-            mediaType: Schema.optional<typeof Schema.String>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"image", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            id: Schema.optional<typeof Schema.String>;
-            source: Schema.optional<Schema.Union<[Schema.mutable<Schema.Struct<{
-                type: Schema.Literal<["base64"]>;
-                mediaType: typeof Schema.String;
-                data: typeof Schema.String;
-            }>>, Schema.mutable<Schema.Struct<{
-                type: Schema.Literal<["http"]>;
-                url: typeof Schema.String;
-            }>>]>>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"json", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            disposition: Schema.optional<typeof Schema.String>;
-            data: typeof Schema.String;
-        }>>, Schema.mutable<Schema.TaggedStruct<"proposal", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            text: typeof Schema.String;
-        }>>, Schema.mutable<Schema.TaggedStruct<"reasoning", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            reasoningText: Schema.optional<typeof Schema.String>;
-            redactedText: Schema.optional<typeof Schema.String>;
-            signature: Schema.optional<typeof Schema.String>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"reference", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            reference: Type.ref<Schema.Schema<Type.Expando, {
-                [x: string]: any;
-                id: string;
-            }, never>>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"select", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            options: Schema.Array$<typeof Schema.String>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"status", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            statusText: typeof Schema.String;
-        }>>, Schema.mutable<Schema.TaggedStruct<"suggestion", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            text: typeof Schema.String;
-        }>>, Schema.mutable<Schema.TaggedStruct<"summary", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            mimeType: Schema.optional<typeof Schema.String>;
-            message: Schema.optional<typeof Schema.String>;
-            model: Schema.optional<typeof Schema.String>;
-            usage: Schema.optional<Schema.Struct<{
-                inputTokens: Schema.optional<typeof Schema.Number>;
-                outputTokens: Schema.optional<typeof Schema.Number>;
-                totalTokens: Schema.optional<typeof Schema.Number>;
-            }>>;
-            toolCalls: Schema.optional<typeof Schema.Number>;
-            errors: Schema.optional<typeof Schema.Number>;
-            duration: Schema.optional<typeof Schema.Number>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"text", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            mimeType: Schema.optional<typeof Schema.String>;
-            text: typeof Schema.String;
-            disposition: Schema.optional<typeof Schema.String>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"toolkit", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"toolCall", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            toolCallId: typeof Schema.String;
-            name: typeof Schema.String;
-            input: typeof Schema.String;
-            providerExecuted: typeof Schema.Boolean;
-        }>>, Schema.mutable<Schema.TaggedStruct<"toolResult", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            toolCallId: typeof Schema.String;
-            name: typeof Schema.String;
-            result: Schema.optional<typeof Schema.String>;
-            error: Schema.optional<typeof Schema.String>;
-            providerExecuted: typeof Schema.Boolean;
-        }>>, Schema.mutable<Schema.TaggedStruct<"transcript", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            started: typeof Schema.String;
-            text: typeof Schema.String;
-        }>>]>>>;
-        properties: Schema.optional<Schema.mutable<Schema.Record$<typeof Schema.String, typeof Schema.Any>>>;
-    }>>>>>;
-}>>;
-export interface ThreadType extends Schema.Schema.Type<typeof _ThreadType> {
-}
-export declare const ThreadType: Type.obj<Schema.Schema<ThreadType, Schema.Schema.Encoded<typeof _ThreadType>, never>>;
-declare const _ChannelType: Type.obj<Schema.Struct<{
-    name: Schema.optional<typeof Schema.String>;
-    defaultThread: Type.ref<Type.obj<Schema.Schema<ThreadType, {
-        id: string;
-        messages: import("@dxos/echo-protocol").EncodedReference[];
-        name?: string | undefined;
-        status?: "staged" | "active" | "resolved" | undefined;
-    }, never>>>;
-    threads: Schema.mutable<Schema.Array$<Type.ref<Type.obj<Schema.Schema<ThreadType, {
-        id: string;
-        messages: import("@dxos/echo-protocol").EncodedReference[];
-        name?: string | undefined;
-        status?: "staged" | "active" | "resolved" | undefined;
-    }, never>>>>>;
-}>>;
-export interface ChannelType extends Schema.Schema.Type<typeof _ChannelType> {
-}
-export declare const ChannelType: Type.obj<Schema.Schema<ChannelType, Schema.Schema.Encoded<typeof _ChannelType>, never>>;
-export {};
-//# sourceMappingURL=schema.d.ts.map

package/dist/types/src/types/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGlC,eAAO,MAAM,YAAY,sGAIxB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;+BAkBqhe,CAAC;wBAA0C,CAAC;0BAA4C,CAAC;yBAA8F,CAAC;2BAA6C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAdnse,CAAC;AAC1E,MAAM,WAAW,UAAW,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC;CAAG;AAC7E,eAAO,MAAM,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,WAAW,CAAC,EAAE,KAAK,CAAC,CAChG,CAAC;AAEd,QAAA,MAAM,YAAY;;;;;;;;;;;;;;GAKwD,CAAC;AAC3E,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC;CAAG;AAC/E,eAAO,MAAM,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,YAAY,CAAC,EAAE,KAAK,CAAC,CAClG,CAAC"}

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

@@ -1,184 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Rx } from '@effect-rx/rx-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, createExtension, rxFromSignal } from '@dxos/plugin-graph';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
-
-import { meta } from '../meta';
-import { ChannelType, 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) =>
-        Rx.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(
-                rxFromSignal(() =>
-                  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 Rx.make((get) => {
-          return Function.pipe(
-            get(node),
-            Option.flatMap((node) => (Obj.instanceOf(ChannelType, node.data) ? Option.some(node.data) : Option.none())),
-            Option.map((channel) => {
-              const callManager = context.getCapability(ThreadCapabilities.CallManager);
-              const joined = get(
-                rxFromSignal(() => callManager.joined && callManager.roomId === fullyQualifiedId(channel)),
-              );
-              if (!joined) {
-                return [];
-              }
-
-              return [
-                {
-                  id: `${fullyQualifiedId(channel)}${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) =>
-        Rx.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(ChannelType, 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) =>
-        Rx.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(ChannelType, 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(
-                rxFromSignal(() => {
-                  const metadata = resolve(Obj.getTypename(object)!);
-                  const selection = selectionManager.getSelection(fullyQualifiedId(object), metadata.selectionMode);
-                  const anchor = getAnchor(selection);
-                  const invalidSelection = !anchor;
-                  const overlappingComment = toolbar[fullyQualifiedId(object)];
-                  return (metadata.comments === 'anchored' && invalidSelection) || overlappingComment;
-                }),
-              );
-
-              return [
-                {
-                  id: `${fullyQualifiedId(object)}/comment`,
-                  data: () => {
-                    const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-                    const metadata = resolve(Obj.getTypename(object)!);
-                    const selection = selectionManager.getSelection(fullyQualifiedId(object));
-                    // 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/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 ChannelType, 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?: ChannelType; 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`,
-  );
-}