@dxos/plugin-markdown 0.8.4-main.72ec0f3 → 0.8.4-main.7996785055

package/src/operations/update.test.ts

@@ -0,0 +1,216 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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 { TestHelpers } from '@dxos/effect/testing';
+import { FunctionInvocationService } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { ObjectId } from '@dxos/keys';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { HasSubject } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+import { WithProperties } from '../testing';
+import MarkdownBlueprint from '../blueprints/markdown-blueprint';
+
+import { Update } from './definitions';
+import { MarkdownOperationHandlerSet } from './index';
+
+ObjectId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: MarkdownOperationHandlerSet,
+  types: [SpaceProperties, Collection.Collection, Blueprint.Blueprint, Markdown.Document, HasSubject.HasSubject],
+  tracing: 'pretty',
+});
+
+describe('update', () => {
+  it.effect(
+    'call a function to update a markdown document',
+    Effect.fnUntraced(
+      function* (_) {
+        const doc = Markdown.make({
+          name: 'BlueYard',
+          content: 'Founders and portfolio of BlueYard.',
+        });
+        yield* Database.add(doc);
+
+        yield* FunctionInvocationService.invokeFunction(Update, {
+          doc: Ref.make(doc),
+          edits: [{ oldString: 'Founders', newString: '# Founders' }],
+        });
+
+        const updatedDoc = yield* Database.resolve(Obj.getDXN(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.');
+      },
+      WithProperties,
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.scoped(
+    '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)],
+        });
+
+        yield* AiConversationService.run({
+          prompt: `Create a document with a cookie recipe.`,
+        });
+        {
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
+          if (docs.length !== 1) {
+            throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+          }
+
+          const doc = docs[0];
+          invariant(Obj.instanceOf(Markdown.Document, doc));
+          console.log({
+            name: doc.name,
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
+          });
+        }
+
+        yield* AiConversationService.run({
+          prompt: 'Add a section with a holiday-themed variation.',
+        });
+        {
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
+          if (docs.length !== 1) {
+            throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+          }
+
+          const doc = docs[0];
+          invariant(Obj.instanceOf(Markdown.Document, doc));
+          console.log({
+            name: doc.name,
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
+          });
+        }
+      },
+      WithProperties,
+      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      TestHelpers.provideTestContext,
+    ),
+    MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
+  );
+
+  it.scoped(
+    'update existing document',
+    Effect.fnUntraced(
+      function* (_) {
+        const document = yield* Database.add(
+          Markdown.make({
+            name: 'Cookie Recipe',
+            content: trim`
+                Ingredients: 
+                  - 2 cups of ???
+                  - 1 cup of sugar
+                  - 1 cup of butter
+                  - 1 cup of eggs
+          `,
+          }),
+        );
+        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
+        yield* AiContextService.bindContext({
+          blueprints: [Ref.make(markdownBlueprint)],
+          objects: [Ref.make(document)],
+        });
+
+        yield* AiConversationService.run({
+          prompt: 'Add the missing ingredient (its flour).',
+        });
+
+        {
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
+          if (docs.length !== 1) {
+            throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+          }
+
+          const doc = docs[0];
+          invariant(Obj.instanceOf(Markdown.Document, doc));
+          const content = yield* Database.load(doc.content).pipe(Effect.map((_) => _.content));
+          console.log({
+            name: doc.name,
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
+          });
+          expect(content.toLowerCase()).toContain('flour');
+        }
+      },
+      WithProperties,
+      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      TestHelpers.provideTestContext,
+    ),
+    MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
+  );
+
+  it.scoped(
+    'add lines to document one by one',
+    Effect.fnUntraced(
+      function* (_) {
+        const document = yield* Database.add(
+          Markdown.make({
+            name: 'Shopping list',
+            content: trim`
+              # Shopping list
+            `,
+          }),
+        );
+        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
+        yield* AiContextService.bindContext({
+          blueprints: [Ref.make(markdownBlueprint)],
+          objects: [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.',
+        });
+
+        {
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
+          if (docs.length !== 1) {
+            throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+          }
+
+          const doc = docs[0];
+          invariant(Obj.instanceOf(Markdown.Document, doc));
+          const content = yield* Database.load(doc.content).pipe(Effect.map((_) => _.content));
+          console.log({
+            name: doc.name,
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
+          });
+          expect(content.toLowerCase()).toContain('milk');
+          expect(content.toLowerCase()).toContain('bread');
+          expect(content.toLowerCase()).toContain('eggs');
+        }
+      },
+      WithProperties,
+      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      TestHelpers.provideTestContext,
+    ),
+    MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
+  );
+});

package/src/operations/update.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { next as A, type Doc } from '@automerge/automerge';
+import * as Effect from 'effect/Effect';
+
+import { Database } from '@dxos/echo';
+import { DocAccessor, createDocAccessor } from '@dxos/echo-db';
+import { Operation } from '@dxos/operation';
+
+import { Update } from './definitions';
+
+const handler: Operation.WithHandler<typeof Update> = Update.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ doc, edits }) {
+      const content = yield* doc.pipe(
+        Database.load,
+        Effect.map((_) => _.content),
+        Effect.flatMap(Database.load),
+      );
+      const accessor = createDocAccessor(content, ['content']);
+
+      for (const edit of edits) {
+        accessor.handle.change((doc: Doc<typeof content>) => {
+          const text = DocAccessor.getValue<string>(accessor);
+          if (edit.replaceAll) {
+            let idx = text.indexOf(edit.oldString);
+            while (idx !== -1) {
+              A.splice(doc, accessor.path as A.Prop[], idx, edit.oldString.length, edit.newString);
+              const updated = DocAccessor.getValue<string>(accessor);
+              idx = updated.indexOf(edit.oldString, idx + edit.newString.length);
+            }
+          } else {
+            const idx = text.indexOf(edit.oldString);
+            if (idx === -1) {
+              throw new Error(`Edit not found: ${JSON.stringify(edit.oldString)}`);
+            }
+            A.splice(doc, accessor.path as A.Prop[], idx, edit.oldString.length, edit.newString);
+          }
+        });
+      }
+
+      return {
+        newContent: DocAccessor.getValue<string>(accessor),
+      };
+    }),
+  ),
+);
+
+export default handler;

package/src/testing.ts

@@ -5,18 +5,18 @@
 import * as Toolkit from '@effect/ai/Toolkit';
 import * as Effect from 'effect/Effect';
 
-import { PropertiesType } from '@dxos/client-protocol';
+import { SpaceProperties } from '@dxos/client-protocol';
 import { Obj, Ref } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
-import { Collection } from '@dxos/schema';
+import { Database } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
 
 // TODO(wittjosiah): Factor out.
-export const WithProperties = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | DatabaseService> =>
+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* DatabaseService.add(
-        Obj.make(PropertiesType as any, {
+      yield* Database.add(
+        Obj.make(SpaceProperties, {
           [Collection.Collection.typename]: Ref.make(Collection.make()),
         }) as any,
       );

package/src/translations.ts

@@ -3,6 +3,7 @@
 //
 
 import { type Resource } from '@dxos/react-ui';
+import { translations as editorTranslations } from '@dxos/react-ui-editor';
 
 import { meta } from './meta';
 import { Markdown } from './types';
@@ -16,8 +17,10 @@ export const translations = [
         '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',
@@ -49,4 +52,5 @@ export const translations = [
       },
     },
   },
+  ...editorTranslations,
 ] as const satisfies Resource[];

package/src/types/Markdown.ts

@@ -4,10 +4,10 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Obj, Ref, Type } from '@dxos/echo';
-import { DescriptionAnnotation, FormAnnotation, LabelAnnotation } from '@dxos/echo/internal';
-import { EditorInputMode, EditorViewMode } from '@dxos/react-ui-editor/types';
-import { ItemAnnotation, Text } from '@dxos/schema';
+import { 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';
 
 /**
  * Document Item type.
@@ -15,16 +15,19 @@ import { ItemAnnotation, Text } from '@dxos/schema';
 export const Document = Schema.Struct({
   name: Schema.optional(Schema.String),
   description: Schema.optional(Schema.String),
-  fallbackName: Schema.String.pipe(FormAnnotation.set(false), Schema.optional),
-  content: Type.Ref(Text.Text).pipe(FormAnnotation.set(false)),
+  fallbackName: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional),
+  content: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
 }).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Document',
+  Type.object({
+    typename: 'org.dxos.type.document',
     version: '0.1.0',
   }),
   LabelAnnotation.set(['name', 'fallbackName']),
   DescriptionAnnotation.set('description'),
-  ItemAnnotation.set(true),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--text-aa--regular',
+    hue: 'indigo',
+  }),
 );
 
 export type Document = Schema.Schema.Type<typeof Document>;
@@ -35,8 +38,12 @@ export type Document = Schema.Schema.Type<typeof Document>;
 export const make = ({
   content = '',
   ...props
-}: Partial<{ name: string; fallbackName: string; content: string }> = {}) =>
-  Obj.make(Document, { ...props, content: Ref.make(Text.make(content)) });
+}: Partial<{ name: string; fallbackName: string; content: string }> = {}) => {
+  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.

package/src/types/capabilities.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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, type EditorViewMode } from '@dxos/ui-editor';
+
+import { meta } from '../meta';
+
+import type * as Markdown from './Markdown';
+import { type MarkdownExtensionProvider } from './types';
+
+/** Schema for persisted markdown state. */
+export const MarkdownStateSchema = 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 namespace MarkdownCapabilities {
+  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/events.ts

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

package/src/types/index.ts

@@ -2,7 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-export * as MarkdownAction from './MarkdownAction';
 export * as Markdown from './Markdown';
 
+export * from './capabilities';
+export * from './events';
 export * from './types';

package/src/types/types.ts

@@ -2,8 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Extension } from '@dxos/react-ui-editor';
-import { type EditorViewMode } from '@dxos/react-ui-editor/types';
+import { type Extension } from '@codemirror/state';
+
+import { type EditorViewMode } from '@dxos/ui-editor/types';
 
 import { type Document } from './Markdown';
 

package/src/util.test.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from 'vitest';
+
+import { trim } from '@dxos/util';
+
+import { getFallbackName } from './util';
+
+describe('markdown utils', () => {
+  it('getFallbackName', () => {
+    const tests = [
+      {
+        content: '',
+        expected: '',
+      },
+      {
+        content: trim`
+          ![img](https://dxos.network/dxos-logotype-blue.png)
+
+          # Welcome to Composer by DXOS
+
+          ## What is Composer?
+        `,
+        expected: 'Welcome to Composer by DXOS',
+      },
+      {
+        content: trim`
+          ![img](https://dxos.network/dxos-logotype-blue.png)
+
+          ---
+
+          This document is about the decetralized platform DXOS.
+        `,
+        expected: 'This document is about the…',
+      },
+    ];
+
+    tests.forEach(({ content, expected }) => {
+      expect(getFallbackName(content)).toBe(expected);
+    });
+  });
+});

package/src/util.tsx

@@ -32,23 +32,93 @@ export const isMarkdownProperties = (data: unknown): data is MarkdownProperties
 
 const nonTitleChars = /[^\w ]/g;
 
-export const getFallbackName = (content = '') => {
-  return content.substring(0, 31).split('\n')[0].replaceAll(nonTitleChars, '').trim();
+// Lines matching these patterns are skipped.
+const skipPatterns = [
+  /^!\[/, // Image.
+  /^---\s*$/, // Horizontal rule.
+  /^```/, // Code block fence.
+  /^\s*$/, // Empty or whitespace-only.
+];
+
+// Patterns to extract title text (first capture group is used).
+const titlePatterns = [
+  /^#{1,6}\s+(.+)/, // Heading.
+];
+
+/**
+ * Extracts a fallback name by scanning lines for the first heading or text fragment.
+ */
+export const getFallbackName = (content = ''): string => {
+  const len = content.length;
+
+  let i = 0;
+  while (i < len) {
+    // Find end of line.
+    let lineEnd = i;
+    while (lineEnd < len && content[lineEnd] !== '\n') {
+      lineEnd++;
+    }
+
+    const line = content.slice(i, lineEnd).trim();
+    i = lineEnd + 1;
+
+    // Skip lines matching skip patterns.
+    if (skipPatterns.some((pattern) => pattern.test(line))) {
+      continue;
+    }
+
+    // Check for title patterns.
+    for (const pattern of titlePatterns) {
+      const match = pattern.exec(line);
+      if (match) {
+        const text = match[1].replaceAll(nonTitleChars, '').trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+    }
+
+    // Use line as plain text fallback.
+    const maxLen = 32;
+    const text = line.replaceAll(nonTitleChars, '').trim();
+    if (text.length > 0) {
+      if (text.length > maxLen) {
+        const words = text.split(/\s+/);
+        let result = '';
+        for (const word of words) {
+          const next = result.length === 0 ? word : result + ' ' + word;
+          if (next.length > maxLen) {
+            break;
+          }
+          result = next;
+        }
+
+        return result + '…';
+      }
+
+      return text;
+    }
+  }
+
+  return '';
 };
 
-export const getContentSnippet = (content = '') => {
+// TODO(burdon): Option to strip Markdown.
+export const getContentSnippet = (content = '', maxLines = 3) => {
   const abstract = content
     .split('\n')
-    .filter((line) => !line.startsWith('#'))
+    .filter((line) => !line.startsWith('!'))
     .filter((line) => line.trim() !== '');
 
-  return abstract.length > 0 ? abstract[0].replaceAll(nonTitleChars, '').trim() + '...' : '';
+  return abstract.slice(0, maxLines).join('\n') ?? '';
 };
 
 export const setFallbackName = debounce((doc: Markdown.Document, content = '') => {
   const name = getFallbackName(content);
   if (doc.fallbackName !== name) {
-    doc.fallbackName = name;
+    Obj.change(doc, (obj) => {
+      obj.fallbackName = name;
+    });
   }
 }, 200);
 

package/dist/lib/browser/MarkdownCard-JYMDPKV5.mjs

@@ -1,12 +0,0 @@
-import {
-  MarkdownCard,
-  MarkdownCard_default
-} from "./chunk-PBJLFIOX.mjs";
-import "./chunk-GH6GQSBL.mjs";
-import "./chunk-QYSEJ5GP.mjs";
-import "./chunk-BQTYJOFB.mjs";
-export {
-  MarkdownCard,
-  MarkdownCard_default as default
-};
-//# sourceMappingURL=MarkdownCard-JYMDPKV5.mjs.map

package/dist/lib/browser/MarkdownContainer-Y75XSVBX.mjs

@@ -1,15 +0,0 @@
-import {
-  MarkdownContainer,
-  MarkdownContainer_default
-} from "./chunk-K3LXOU3E.mjs";
-import "./chunk-2MLGSYRN.mjs";
-import "./chunk-Y53FQREH.mjs";
-import "./chunk-IBCHVMZW.mjs";
-import "./chunk-GH6GQSBL.mjs";
-import "./chunk-QYSEJ5GP.mjs";
-import "./chunk-BQTYJOFB.mjs";
-export {
-  MarkdownContainer,
-  MarkdownContainer_default as default
-};
-//# sourceMappingURL=MarkdownContainer-Y75XSVBX.mjs.map

package/dist/lib/browser/anchor-sort-3HGPGCOO.mjs

@@ -1,31 +0,0 @@
-import {
-  Markdown_exports
-} from "./chunk-QYSEJ5GP.mjs";
-import "./chunk-BQTYJOFB.mjs";
-
-// src/capabilities/anchor-sort.ts
-import { Capabilities, contributes } from "@dxos/app-framework";
-import { createDocAccessor, getRangeFromCursor, getTarget } from "@dxos/react-client/echo";
-var anchor_sort_default = (() => contributes(Capabilities.AnchorSort, {
-  key: Markdown_exports.Document.typename,
-  sort: (anchorA, anchorB) => {
-    const doc = getTarget(anchorA);
-    const accessor = doc.content.target ? createDocAccessor(doc.content.target, [
-      "content"
-    ]) : void 0;
-    if (doc !== getTarget(anchorB) || !accessor) {
-      return 0;
-    }
-    const getStartPosition = (cursor) => {
-      const range = cursor ? getRangeFromCursor(accessor, cursor) : void 0;
-      return range?.start ?? Number.MAX_SAFE_INTEGER;
-    };
-    const posA = getStartPosition(anchorA.anchor);
-    const posB = getStartPosition(anchorB.anchor);
-    return posA - posB;
-  }
-}));
-export {
-  anchor_sort_default as default
-};
-//# sourceMappingURL=anchor-sort-3HGPGCOO.mjs.map