@dxos/plugin-markdown 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

package/src/{blueprints/functions → operations}/update.test.ts

@@ -4,33 +4,40 @@
 
 import { describe, expect, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
 
 import { MemoizedAiService } from '@dxos/ai/testing';
-import { AiContextService, AiConversationService } from '@dxos/assistant';
-import { AssistantTestLayer } from '@dxos/assistant/testing';
-import { Blueprint } from '@dxos/blueprints';
 import { SpaceProperties } from '@dxos/client-protocol';
-import { Database, Obj, Query, Ref } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
+import { Blueprint, Operation } from '@dxos/compute';
+import { Collection, Database, Feed, Obj, Query, Ref } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { FunctionInvocationService } from '@dxos/functions';
+import { AgentService } from '@dxos/functions-runtime';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 import { invariant } from '@dxos/invariant';
-import { ObjectId } from '@dxos/keys';
-import { Markdown } from '@dxos/plugin-markdown/types';
+import { EntityId } from '@dxos/keys';
+import { Markdown } from '@dxos/plugin-markdown';
 import { HasSubject } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { WithProperties } from '../../testing';
-import MarkdownBlueprint from '../markdown-blueprint';
+import { WithProperties } from '#testing';
 
-import update from './update';
+import MarkdownBlueprint from '../blueprints/markdown-blueprint';
+import { MarkdownOperation } from '../types';
+import { MarkdownOperationHandlerSet } from './index';
 
-ObjectId.dangerouslyDisableRandomness();
+EntityId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayer({
-  functions: [...MarkdownBlueprint.functions],
-  types: [SpaceProperties, Collection.Collection, Blueprint.Blueprint, Markdown.Document, HasSubject.HasSubject],
+  aiServicePreset: 'edge-remote',
+  operationHandlers: MarkdownOperationHandlerSet,
+  types: [
+    SpaceProperties,
+    Collection.Collection,
+    Blueprint.Blueprint,
+    Markdown.Document,
+    HasSubject.HasSubject,
+    Feed.Feed,
+  ],
+  blueprints: [MarkdownBlueprint.make()],
   tracing: 'pretty',
 });
 
@@ -45,12 +52,12 @@ describe('update', () => {
         });
         yield* Database.add(doc);
 
-        yield* FunctionInvocationService.invokeFunction(update, {
+        yield* Operation.invoke(MarkdownOperation.Update, {
           doc: Ref.make(doc),
           edits: [{ oldString: 'Founders', newString: '# Founders' }],
         });
 
-        const updatedDoc = yield* Database.resolve(Obj.getDXN(doc), Markdown.Document);
+        const updatedDoc = yield* Database.resolve(Obj.getURI(doc), Markdown.Document);
         expect(updatedDoc.name).toBe(doc.name);
         const text = yield* Database.load(updatedDoc.content);
         expect(text.content).toBe('# Founders and portfolio of BlueYard.');
@@ -61,18 +68,16 @@ describe('update', () => {
     ),
   );
 
-  it.scoped(
+  it.effect(
     'create and update a markdown document',
     Effect.fnUntraced(
       function* (_) {
-        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
-        yield* AiContextService.bindContext({
-          blueprints: [Ref.make(markdownBlueprint)],
+        const agent = yield* AgentService.createSession({
+          blueprints: [MarkdownBlueprint.make()],
         });
 
-        yield* AiConversationService.run({
-          prompt: `Create a document with a cookie recipe.`,
-        });
+        yield* agent.submitPrompt('Create a document with a cookie recipe.');
+        yield* agent.waitForCompletion();
         {
           const docs = yield* Database.runQuery(Query.type(Markdown.Document));
           if (docs.length !== 1) {
@@ -87,9 +92,8 @@ describe('update', () => {
           });
         }
 
-        yield* AiConversationService.run({
-          prompt: 'Add a section with a holiday-themed variation.',
-        });
+        yield* agent.submitPrompt('Add a section with a holiday-themed variation.');
+        yield* agent.waitForCompletion();
         {
           const docs = yield* Database.runQuery(Query.type(Markdown.Document));
           if (docs.length !== 1) {
@@ -105,13 +109,13 @@ describe('update', () => {
         }
       },
       WithProperties,
-      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
     ),
     MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
   );
 
-  it.scoped(
+  it.effect(
     'update existing document',
     Effect.fnUntraced(
       function* (_) {
@@ -127,15 +131,13 @@ describe('update', () => {
           `,
           }),
         );
-        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
-        yield* AiContextService.bindContext({
-          blueprints: [Ref.make(markdownBlueprint)],
-          objects: [Ref.make(document)],
+        const agent = yield* AgentService.createSession({
+          blueprints: [MarkdownBlueprint.make()],
+          context: [Ref.make(document)],
         });
 
-        yield* AiConversationService.run({
-          prompt: 'Add the missing ingredient (its flour).',
-        });
+        yield* agent.submitPrompt('Add the missing ingredient (its flour).');
+        yield* agent.waitForCompletion();
 
         {
           const docs = yield* Database.runQuery(Query.type(Markdown.Document));
@@ -154,13 +156,13 @@ describe('update', () => {
         }
       },
       WithProperties,
-      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
     ),
     MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
   );
 
-  it.scoped(
+  it.effect(
     'add lines to document one by one',
     Effect.fnUntraced(
       function* (_) {
@@ -172,21 +174,17 @@ describe('update', () => {
             `,
           }),
         );
-        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
-        yield* AiContextService.bindContext({
-          blueprints: [Ref.make(markdownBlueprint)],
-          objects: [Ref.make(document)],
+        const agent = yield* AgentService.createSession({
+          blueprints: [MarkdownBlueprint.make()],
+          context: [Ref.make(document)],
         });
 
-        yield* AiConversationService.run({
-          prompt: 'Add milk to the shopping list.',
-        });
-        yield* AiConversationService.run({
-          prompt: 'Add bread to the shopping list.',
-        });
-        yield* AiConversationService.run({
-          prompt: 'Add eggs to the shopping list.',
-        });
+        yield* agent.submitPrompt('Add milk to the shopping list.');
+        yield* agent.waitForCompletion();
+        yield* agent.submitPrompt('Add bread to the shopping list.');
+        yield* agent.waitForCompletion();
+        yield* agent.submitPrompt('Add eggs to the shopping list.');
+        yield* agent.waitForCompletion();
 
         {
           const docs = yield* Database.runQuery(Query.type(Markdown.Document));
@@ -207,7 +205,7 @@ describe('update', () => {
         }
       },
       WithProperties,
-      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
     ),
     MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const MarkdownPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { MarkdownOperationHandlerSet } from './operations';

package/src/testing.ts

@@ -5,21 +5,34 @@
 import * as Toolkit from '@effect/ai/Toolkit';
 import * as Effect from 'effect/Effect';
 
+import { RootCollectionAnnotation } from '@dxos/app-toolkit';
 import { SpaceProperties } from '@dxos/client-protocol';
-import { Obj, Ref } from '@dxos/echo';
-import { Database } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
+import { Annotation, Collection, Database, Obj, Ref } from '@dxos/echo';
+
+// Eager re-export of `MarkdownPlugin`. See `@dxos/plugin-testing/src/core.ts`
+// for the rationale. Uses the `#plugin` subpath so the node-only build is
+// re-exported in test environments, avoiding the browser-only `MarkdownPlugin.tsx`
+// which references React-surface capabilities that are intentionally omitted
+// from `capabilities/node.ts`.
+export * from '#plugin';
 
 // TODO(wittjosiah): Factor out.
 export const WithProperties = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | Database.Service> =>
   Effect.zipRight(
     Effect.gen(function* () {
-      // TODO(wittjosiah): Remove cast.
-      yield* Database.add(
-        Obj.make(SpaceProperties, {
-          [Collection.Collection.typename]: Ref.make(Collection.make()),
-        }) as any,
-      );
+      const collection = Collection.make({ objects: [] });
+      const properties = Obj.make(SpaceProperties, {});
+      yield* Database.add(collection);
+      yield* Database.add(properties);
+      // Both entities are in the DB before setting the annotation so Database.load
+      // works in CollectionModel.add (which uses the Effect DB context, not Ref.load).
+      Obj.update(properties, (properties) => {
+        const meta = Obj.getMeta(properties);
+        if (!meta.annotations) {
+          meta.annotations = {};
+        }
+        Annotation.setDictionary(meta.annotations, RootCollectionAnnotation, Ref.make(collection));
+      });
     }),
     effect,
   );

package/src/translations.ts

@@ -2,52 +2,41 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
-import { translations as editorTranslations } from '@dxos/react-ui-editor';
+import { translations as editorTranslations } from '@dxos/react-ui-editor/translations';
 
-import { meta } from './meta';
-import { Markdown } from './types';
+import { meta } from '#meta';
+import { Markdown } from '#types';
 
 export const translations = [
   {
     'en-US': {
-      [Markdown.Document.typename]: {
-        'typename label': 'Document',
-        'typename label_zero': 'Documents',
-        'typename label_one': 'Document',
-        'typename label_other': 'Documents',
-        'object name placeholder': 'New document',
-        'rename object label': 'Rename document',
-        'delete object label': 'Delete document',
-        'object deleted label': 'Document deleted',
+      [Type.getTypename(Markdown.Document)]: {
+        'typename.label': 'Document',
+        'typename.label_zero': 'Documents',
+        'typename.label_one': 'Document',
+        'typename.label_other': 'Documents',
+        'object-name.placeholder': 'New document',
+        'add-object.label': 'Add document',
+        'rename-object.label': 'Rename document',
+        'delete-object.label': 'Delete document',
+        'object-deleted.label': 'Document deleted',
       },
       [meta.id]: {
-        'plugin name': 'Editor',
-        'settings title': 'Editor settings',
-        'choose markdown from space dialog title': 'Choose one or more documents to add',
-        // TODO(burdon): Style-guide for user-facing text (e.g., hints, questions, capitalization, etc.)
-        'empty choose markdown from space message': 'None available; try creating a new one instead?',
-        'chooser done label': 'Add selected',
-        'editor placeholder': '',
-        'editor input mode label': 'Editor input mode',
-        'select editor input mode placeholder': 'Select editor input mode…',
-        'settings editor input mode default label': 'Default',
-        'settings editor input mode vim label': 'Vim',
-        'settings editor input mode vscode label': 'VS Code',
-        'settings toolbar label': 'Show toolbar',
-        'settings numbered headings label': 'Numbered headings',
-        'settings folding label': 'Folding',
-        'settings experimental label': 'Enable experimental features',
-        'settings debug label': 'Enable debugging features',
-        'settings debug placeholder': 'Typewriter script...',
-        'toggle view mode label': 'Toggle read-only',
-        'default view mode label': 'Default view mode',
-        'upload image label': 'Upload image',
-        'fallback title': 'Untitled',
-        'navigate to document label': 'Open document',
-        'words label_zero': 'words',
-        'words label_one': 'word',
-        'words label_other': 'words',
+        'plugin.name': 'Editor',
+        'choose-markdown-from-space-dialog.title': 'Choose one or more documents to add',
+        'empty-choose-markdown-from-space.message': 'None available; try creating a new one instead?',
+        'chooser-done.label': 'Add selected',
+        'editor.placeholder': 'Enter text…',
+        'toggle-view-mode.label': 'Toggle read-only',
+        'upload-image.label': 'Upload image',
+        'fallback.title': 'Untitled',
+        'navigate-to-document.label': 'Open document',
+        'words.label': 'words',
+        'words.label_zero': 'words',
+        'words.label_one': 'word',
+        'words.label_other': 'words',
       },
     },
   },

package/src/types/Markdown.ts

@@ -4,10 +4,17 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Annotation, Obj, Ref, Type } from '@dxos/echo';
+import { BlueprintsAnnotation, GraphPropsAnnotation } from '@dxos/app-toolkit';
+import { DXN, Annotation, Obj, Ref, Type } from '@dxos/echo';
 import { DescriptionAnnotation, FormInputAnnotation, LabelAnnotation } from '@dxos/echo/internal';
 import { Text } from '@dxos/schema';
-import { EditorInputMode, EditorViewMode } from '@dxos/ui-editor/types';
+
+export const BLUEPRINT_KEY = 'org.dxos.blueprint.markdown';
+
+// Re-export Settings as merged const/type (not as namespace).
+import * as SettingsModule from './Settings';
+export const Settings = SettingsModule.Settings;
+export type Settings = SettingsModule.Settings;
 
 /**
  * Document Item type.
@@ -18,19 +25,15 @@ export const Document = Schema.Struct({
   fallbackName: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional),
   content: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
 }).pipe(
-  Type.object({
-    typename: 'dxos.org/type/Document',
-    version: '0.1.0',
-  }),
   LabelAnnotation.set(['name', 'fallbackName']),
   DescriptionAnnotation.set('description'),
-  Annotation.IconAnnotation.set({
-    icon: 'ph--text-aa--regular',
-    hue: 'green',
-  }),
+  Annotation.IconAnnotation.set({ icon: 'ph--text-aa--regular', hue: 'indigo' }),
+  BlueprintsAnnotation.set([BLUEPRINT_KEY]),
+  GraphPropsAnnotation.set({ managesAutofocus: true }),
+  Type.makeObject(DXN.make('org.dxos.type.document', '0.1.0')),
 );
 
-export type Document = Schema.Schema.Type<typeof Document>;
+export type Document = Type.InstanceType<typeof Document>;
 
 /**
  * Document factory.
@@ -39,27 +42,8 @@ export const make = ({
   content = '',
   ...props
 }: Partial<{ name: string; fallbackName: string; content: string }> = {}) => {
-  const doc = Obj.make(Document, { ...props, content: Ref.make(Text.make(content)) });
+  const doc = Obj.make(Document, { ...props, content: Ref.make(Text.make({ content })) });
   // TODO(dmaretskyi): We need a better way to set parents when creating hierarchies.
   Obj.setParent(doc.content.target!, doc);
   return doc;
 };
-
-/**
- * Plugin settings.
- */
-export const Settings = Schema.mutable(
-  Schema.Struct({
-    defaultViewMode: EditorViewMode,
-    editorInputMode: Schema.optional(EditorInputMode),
-    experimental: Schema.optional(Schema.Boolean),
-    debug: Schema.optional(Schema.Boolean),
-    toolbar: Schema.optional(Schema.Boolean),
-    typewriter: Schema.optional(Schema.String),
-    // TODO(burdon): Per document settings.
-    numberedHeadings: Schema.optional(Schema.Boolean),
-    folding: Schema.optional(Schema.Boolean),
-  }),
-);
-
-export interface Settings extends Schema.Schema.Type<typeof Settings> {}

package/src/types/MarkdownCapabilities.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import { type EditorView } from '@codemirror/view';
+import { type Atom } from '@effect-atom/atom-react';
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { type EditorStateStore } from '@dxos/ui-editor';
+import { type EditorViewMode } from '@dxos/ui-editor/types';
+
+import { meta } from '#meta';
+
+import type * as Markdown from './Markdown';
+import { type MarkdownExtensionProvider } from './types';
+
+/** Schema for persisted markdown state. */
+export const StateSchema = Schema.mutable(
+  Schema.Struct({
+    viewMode: Schema.Record({ key: Schema.String, value: Schema.String }),
+  }),
+);
+
+export type MarkdownState = {
+  viewMode: Record<string, EditorViewMode>;
+};
+
+export type EditorViewEntry = { view: EditorView; documentId: string };
+
+export type EditorViewRegistry = {
+  register: (attendableId: string, view: EditorView, documentId: string) => void;
+  unregister: (attendableId: string) => void;
+  get: (attendableId: string) => EditorViewEntry | undefined;
+};
+
+export const Settings = Capability.make<Atom.Writable<Markdown.Settings>>(`${meta.id}.capability.settings`);
+
+/** Persisted state atom for view mode per document. */
+export const State = Capability.make<Atom.Writable<MarkdownState>>(`${meta.id}.capability.state`);
+
+/** Editor state store for cursor positions, scroll state, etc. */
+export const EditorState = Capability.make<EditorStateStore>(`${meta.id}.capability.editor-state`);
+
+/** Registry of active EditorView instances keyed by attendable ID. */
+export const EditorViews = Capability.make<EditorViewRegistry>(`${meta.id}.capability.editor-views`);
+
+// TODO(burdon): Move to ./types (external API)?
+export const Extensions = Capability.make<MarkdownExtensionProvider[]>(`${meta.id}.capability.extensions`);

package/src/types/MarkdownEvents.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import { type ActivationEvent } from '@dxos/app-framework';
+import { AppActivationEvents } from '@dxos/app-toolkit';
+
+import { meta } from '#meta';
+
+export const SetupExtensions: ActivationEvent.ActivationEvent = AppActivationEvents.createStateEvent(
+  `${meta.id}.event.setup-extensions`,
+);

package/src/types/MarkdownOperation.ts

@@ -0,0 +1,133 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Database, Ref, Type, DXN } from '@dxos/echo';
+import { EditorViewMode } from '@dxos/ui-editor/types';
+import { trim } from '@dxos/util';
+
+import { meta } from '#meta';
+
+import * as Markdown from './Markdown';
+
+const makeKey = (name: string) => DXN.make(`${meta.id}.operation.${name}`);
+
+const Edit = Schema.Struct({
+  oldString: Schema.String.annotations({
+    description: 'The text to find in the document.',
+  }),
+  newString: Schema.String.annotations({
+    description: 'The text to replace it with.',
+  }),
+  replaceAll: Schema.optional(Schema.Boolean).annotations({
+    description: 'If true, replaces all occurrences. Defaults to false (first occurrence only).',
+  }),
+});
+
+export const Create = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.markdown.create'),
+    name: 'Create',
+    description: 'Creates a new markdown document and adds it to the space.',
+    icon: 'ph--file-text--regular',
+  },
+  input: Schema.Struct({
+    name: Schema.String,
+    content: Schema.String,
+  }),
+  output: Schema.Struct({
+    id: Schema.String.annotations({
+      description: 'The DXN of the created document.',
+    }),
+  }),
+  services: [Database.Service],
+});
+
+export const CreateMarkdown = Operation.make({
+  meta: {
+    key: makeKey('create'),
+    name: 'Create Markdown Document',
+    icon: 'ph--file-text--regular',
+  },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    name: Schema.optional(Schema.String),
+    content: Schema.optional(Schema.String),
+  }),
+  output: Schema.Struct({
+    object: Type.getSchema(Markdown.Document),
+  }),
+});
+
+export const Open = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.markdown.open'),
+    name: 'Open',
+    description: 'Opens and reads the contents of a new markdown document.',
+    icon: 'ph--arrow-square-out--regular',
+  },
+  input: Schema.Struct({
+    doc: Ref.Ref(Markdown.Document).annotations({
+      description: 'The ID of the markdown document.',
+    }),
+  }),
+  output: Schema.Struct({
+    content: Schema.String,
+  }),
+  services: [Database.Service],
+});
+
+export const ScrollToAnchor = Operation.make({
+  meta: {
+    key: makeKey('scrollToAnchor'),
+    name: 'Scroll To Anchor',
+    icon: 'ph--anchor-simple--regular',
+  },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    subject: Schema.String.annotations({ description: 'Attendable ID of the markdown editor.' }),
+    cursor: Schema.String.annotations({ description: 'Cursor position to scroll to.' }),
+    ref: Schema.optional(Schema.String.annotations({ description: 'Reference ID (e.g. thread ID).' })),
+  }),
+  output: Schema.Void,
+});
+
+// TODO(wittjosiah): This appears to be unused.
+export const SetViewMode = Operation.make({
+  meta: { key: makeKey('setViewMode'), name: 'Set View Mode', icon: 'ph--layout--regular' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    id: Schema.String,
+    viewMode: EditorViewMode,
+  }),
+  output: Schema.Void,
+});
+
+export const Update = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.markdown.update'),
+    name: 'Update',
+    description: trim`
+      Applies a set of edits to the markdown document.
+    `,
+    icon: 'ph--pencil-simple--regular',
+  },
+  input: Schema.Struct({
+    doc: Ref.Ref(Markdown.Document).annotations({
+      description: 'The ID of the markdown document.',
+    }),
+    edits: Schema.Array(Edit).annotations({
+      description: 'The edits to apply to the document. Each edit finds oldString and replaces it with newString.',
+    }),
+  }),
+  output: Schema.Struct({
+    newContent: Schema.String,
+  }),
+  services: [Database.Service],
+});