@dxos/plugin-markdown 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

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

@@ -2,53 +2,62 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Function from 'effect/Function';
+import * as Effect from 'effect/Effect';
 
-import { Capabilities, type PluginContext, chain, contributes, createIntent } from '@dxos/app-framework';
-import { Obj } from '@dxos/echo';
-import { SpaceAction } from '@dxos/plugin-space/types';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Collection, Obj } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space';
 import { isSpace } from '@dxos/react-client/echo';
-import { DataType } from '@dxos/schema';
 
-import { translations } from '../translations';
-import { Markdown, MarkdownAction } from '../types';
+import { translations } from '#translations';
+import { MarkdownOperation } from '#types';
+import { Markdown } from '#types';
 
-export default (context: PluginContext) =>
-  contributes(Capabilities.AppGraphSerializer, [
-    {
-      inputType: Markdown.Document.typename,
-      outputType: 'text/markdown',
-      // Reconcile with metadata serializers.
-      serialize: async (node) => {
-        const doc = node.data;
-        const content = await doc.content.load();
-        return {
-          name:
-            doc.name ||
-            doc.fallbackName ||
-            translations[0]['en-US'][Markdown.Document.typename]['object name placeholder'],
-          data: content.content,
-          type: 'text/markdown',
-        };
-      },
-      deserialize: async (data, ancestors) => {
-        const space = ancestors.find(isSpace);
-        const target =
-          ancestors.findLast((ancestor) => Obj.instanceOf(DataType.Collection, ancestor)) ??
-          space?.properties[DataType.Collection.typename]?.target;
-        if (!space || !target) {
-          return;
-        }
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // Get context for lazy capability access in callbacks.
+    const capabilities = yield* Capability.Service;
+
+    return Capability.contributes(AppCapabilities.AppGraphSerializer, [
+      {
+        inputType: Markdown.Document.typename,
+        outputType: 'text/markdown',
+        // Reconcile with metadata serializers.
+        serialize: async (node) => {
+          const doc = node.data;
+          const content = await doc.content.load();
+          return {
+            name:
+              doc.name ||
+              doc.fallbackName ||
+              translations[0]['en-US'][Markdown.Document.typename]['object-name.placeholder'],
+            data: content.content,
+            type: 'text/markdown',
+          };
+        },
+        deserialize: async (data, ancestors) => {
+          const space = ancestors.find(isSpace);
+          const target =
+            ancestors.findLast((ancestor) => Obj.instanceOf(Collection.Collection, ancestor)) ??
+            space?.properties[Collection.Collection.typename]?.target;
+          if (!space || !target) {
+            return;
+          }
 
-        const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const result = await dispatch(
-          Function.pipe(
-            createIntent(MarkdownAction.Create, { name: data.name, content: data.data }),
-            chain(SpaceAction.AddObject, { target }),
-          ),
-        );
+          const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+          const createResult = await invokePromise(MarkdownOperation.CreateMarkdown, {
+            name: data.name,
+            content: data.data,
+          });
+          if (!createResult.data?.object) {
+            return undefined;
+          }
+          await invokePromise(SpaceOperation.AddObject, { target, object: createResult.data.object });
 
-        return result.data?.object;
+          return createResult.data.object;
+        },
       },
-    },
-  ]);
+    ]);
+  }),
+);

package/src/capabilities/artifact-definition.ts

@@ -5,108 +5,105 @@
 // ISSUE(burdon): defineArtifact
 // @ts-nocheck
 
-import * as Function from 'effect/Function';
+import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { ToolResult, createTool } from '@dxos/ai';
-import { Capabilities, chain, contributes, createIntent } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
 import { ArtifactId, createArtifactElement } from '@dxos/assistant';
-import { defineArtifact } from '@dxos/blueprints';
-import { Obj } from '@dxos/echo';
+import { defineArtifact } from '@dxos/compute';
+import { Filter, Obj } from '@dxos/echo';
 import { assertArgument, invariant } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Filter, fullyQualifiedId } from '@dxos/react-client/echo';
+import { SpaceOperation } from '@dxos/plugin-space';
 
-import { meta } from '../meta';
-import { Markdown, MarkdownAction } from '../types';
+import { meta } from '#meta';
+import { Markdown } from '#types';
 
-export default () => {
-  const definition = defineArtifact({
-    id: `artifact:${meta.id}`, // TODO(burdon): meta.id/artifact?
-    name: meta.name,
-    instructions: `
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const definition = defineArtifact({
+      id: `artifact:${meta.id}`, // TODO(burdon): meta.id/artifact?
+      name: meta.name,
+      instructions: `
       The markdown plugin allows you to work with text documents in the current space.
       Use these tools to interact with documents, including listing available documents and retrieving their content.
       Documents are stored in Markdown format.
     `,
-    schema: Markdown.Document,
-    tools: [
-      createTool(meta.id, {
-        name: 'create',
-        description: 'Create a new markdown document',
-        caption: 'Creating document...',
-        schema: Schema.Struct({
-          name: Schema.optional(Schema.String).annotations({
-            description: 'Optional name for the document.',
-          }),
-          content: Schema.String.annotations({
-            description: 'The content of the document.',
+      schema: Markdown.Document,
+      tools: [
+        createTool(meta.id, {
+          name: 'create',
+          description: 'Create a new markdown document',
+          caption: 'Creating document...',
+          schema: Schema.Struct({
+            name: Schema.optional(Schema.String).annotations({
+              description: 'Optional name for the document.',
+            }),
+            content: Schema.String.annotations({
+              description: 'The content of the document.',
+            }),
           }),
-        }),
-        execute: async ({ name, content }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          invariant(extensions?.dispatch, 'No intent dispatcher');
+          execute: async ({ name, content }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            invariant(extensions?.invoke, 'No operation invoker');
 
-          const intent = Function.pipe(
-            createIntent(MarkdownAction.Create, {
-              spaceId: extensions.space.id,
-              name,
-              content,
-            }),
-            chain(SpaceAction.AddObject, { target: extensions.space }),
-          );
+            const document = Markdown.make({ name, content });
 
-          const { data, error } = await extensions.dispatch(intent);
-          if (!data || error) {
-            return ToolResult.Error(error?.message ?? 'Failed to create document');
-          }
+            const { error } = await extensions.invoke(SpaceOperation.AddObject, {
+              target: extensions.space,
+              object: document,
+            });
+            if (error) {
+              return ToolResult.Error(error?.message ?? 'Failed to add document to space');
+            }
 
-          return ToolResult.Success(createArtifactElement(data.id));
-        },
-      }),
-      createTool(meta.id, {
-        name: 'list',
-        description: 'List all markdown documents in the current space.',
-        caption: 'Listing markdown documents...',
-        schema: Schema.Struct({}),
-        execute: async (_input, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          const space = extensions.space;
-          const { objects: documents } = await space.db.query(Filter.type(Markdown.Document)).run();
-          const documentInfo = documents.map((doc) => {
-            invariant(Obj.instanceOf(Markdown.Document, doc));
-            return {
-              id: fullyQualifiedId(doc),
-              name: doc.name || doc.fallbackName || 'Unnamed Document',
-              // TODO(ZaymonFC): Include updatedAt?
-            };
-          });
+            return ToolResult.Success(createArtifactElement(document.id));
+          },
+        }),
+        createTool(meta.id, {
+          name: 'list',
+          description: 'List all markdown documents in the current space.',
+          caption: 'Listing markdown documents...',
+          schema: Schema.Struct({}),
+          execute: async (_input, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            const space = extensions.space;
+            const { objects: documents } = await space.db.query(Filter.type(Markdown.Document)).run();
+            const documentInfo = documents.map((doc) => {
+              invariant(Obj.instanceOf(Markdown.Document, doc));
+              return {
+                id: Obj.getDXN(doc).toString(),
+                name: doc.name || doc.fallbackName || 'Unnamed Document',
+                // TODO(ZaymonFC): Include updatedAt?
+              };
+            });
 
-          return ToolResult.Success(documentInfo);
-        },
-      }),
-      createTool(meta.id, {
-        name: 'inspect',
-        description: 'Read the content of a markdown document.',
-        caption: 'Inspecting markdown document...',
-        schema: Schema.Struct({
-          id: ArtifactId,
+            return ToolResult.Success(documentInfo);
+          },
         }),
-        execute: async ({ id }, { extensions }) => {
-          invariant(extensions?.space, 'No space');
-          const document = await extensions.space.db.query(Filter.ids(ArtifactId.toDXN(id).toString())).first();
-          assertArgument(Obj.instanceOf(Markdown.Document, document), 'document', 'Invalid type');
+        createTool(meta.id, {
+          name: 'inspect',
+          description: 'Read the content of a markdown document.',
+          caption: 'Inspecting markdown document...',
+          schema: Schema.Struct({
+            id: ArtifactId,
+          }),
+          execute: async ({ id }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            const document = await extensions.space.db.query(Filter.id(ArtifactId.toDXN(id).toString())).first();
+            assertArgument(Obj.instanceOf(Markdown.Document, document), 'document', 'Invalid type');
 
-          const { content } = await document.content?.load();
-          return ToolResult.Success({
-            id: fullyQualifiedId(document),
-            name: document.name || document.fallbackName || 'Unnamed Document',
-            content,
-          });
-        },
-      }),
-    ],
-  });
+            const { content } = await document.content?.load();
+            return ToolResult.Success({
+              id: Obj.getDXN(document).toString(),
+              name: document.name || document.fallbackName || 'Unnamed Document',
+              content,
+            });
+          },
+        }),
+      ],
+    });
 
-  return contributes(Capabilities.ArtifactDefinition, definition);
-};
+    return Capability.contributes(Capabilities.ArtifactDefinition, definition);
+  }),
+);

package/src/capabilities/blueprint-definition.ts

@@ -2,38 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
-import { Blueprint, Template } from '@dxos/blueprints';
-import { type FunctionDefinition } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import * as Effect from 'effect/Effect';
 
-import { diff, open } from '../functions';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint } from '@dxos/compute';
 
-const functions: FunctionDefinition[] = [diff, open];
-const tools = ['add-proposals', 'create-document'];
+import { MarkdownBlueprint } from '#blueprints';
 
-export const ASSISTANT_BLUEPRINT_KEY = 'dxos.org/blueprint/markdown';
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, MarkdownBlueprint)]));
 
-export default (): Capability<any>[] => [
-  contributes(Capabilities.Functions, functions),
-  contributes(
-    Capabilities.BlueprintDefinition,
-    Blueprint.make({
-      key: ASSISTANT_BLUEPRINT_KEY,
-      name: 'Markdown',
-      tools: Blueprint.toolDefinitions({ functions, tools }),
-      instructions: Template.make({
-        source: trim`
-            You can create and update markdown documents.
-            When asked to edit or update documents return updates as a set of compact diff string pairs.
-            For each diff, respond with the smallest possible matching span.
-            For example:
-            - "There is a tyop in this sentence."
-            + "There is a typo in this sentence."
-            - "This id goof."
-            + "This is good."
-          `,
-      }),
-    }),
-  ),
-];
+export default blueprintDefinition;

package/src/capabilities/comment-config.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Operation } from '@dxos/compute';
+import { createDocAccessor, getTextInRange } from '@dxos/echo-db';
+
+import { MarkdownOperation } from '#types';
+import { Markdown } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const config: AppCapabilities.CommentConfig = {
+      id: Markdown.Document.typename,
+      comments: 'anchored',
+      selectionMode: 'multi-range',
+      getAnchorLabel: (doc: Markdown.Document, anchor: string): string | undefined => {
+        if (doc.content) {
+          const [start, end] = anchor.split(':');
+          return getTextInRange(createDocAccessor(doc.content.target!, ['content']), start, end);
+        }
+      },
+      scrollToAnchor: MarkdownOperation.ScrollToAnchor,
+    };
+    return Capability.contributes(AppCapabilities.CommentConfig, config);
+  }),
+);

package/src/capabilities/create-object.ts

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

package/src/capabilities/index.ts

@@ -2,16 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint, Operation, OperationHandlerSet } from '@dxos/compute';
 
-export const AnchorSort = lazy(() => import('./anchor-sort'));
-export const AppGraphSerializer = lazy(() => import('./app-graph-serializer'));
-export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const MarkdownSettings = lazy(() => import('./settings'));
-export const MarkdownState = lazy(() => import('./state'));
-export const Toolkit = lazy(() => import('./toolkit'));
-
-export * from './blueprint-definition';
-export * from './capabilities';
+export const AnchorSort = Capability.lazy('AnchorSort', () => import('./anchor-sort'));
+export const AppGraphSerializer = Capability.lazy('AppGraphSerializer', () => import('./app-graph-serializer'));
+export const CommentConfig = Capability.lazy('CommentConfig', () => import('./comment-config'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const MarkdownSettings = Capability.lazy('MarkdownSettings', () => import('./settings'));
+export const MarkdownState = Capability.lazy('MarkdownState', () => import('./state'));

package/src/capabilities/node.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
+
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);

package/src/capabilities/operation-handler.ts

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