@dxos/plugin-markdown 0.8.4-main.70d3990 → 0.8.4-main.7996785055

package/src/operations/create.test.ts

@@ -0,0 +1,93 @@
+//
+// 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 { DXN, 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 { WithProperties } from '../testing';
+import MarkdownBlueprint from '../blueprints/markdown-blueprint';
+
+import { Create } 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('create', () => {
+  it.effect(
+    'call a function to create a markdown document',
+    Effect.fnUntraced(
+      function* (_) {
+        const name = 'BlueYard';
+        const content = 'Founders and portfolio of BlueYard.';
+        const result = yield* FunctionInvocationService.invokeFunction(Create, {
+          name,
+          content,
+        });
+
+        const doc = yield* Database.resolve(DXN.parse(result.id), Markdown.Document);
+        expect(doc.name).toBe(name);
+        const text = yield* Database.load(doc.content);
+        expect(text.content).toBe(content);
+      },
+      WithProperties,
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.scoped(
+    'create 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)),
+          });
+        }
+      },
+      WithProperties,
+      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      TestHelpers.provideTestContext,
+    ),
+    MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
+  );
+});

package/src/operations/create.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Obj } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { CollectionModel } from '@dxos/schema';
+
+import { Create } from './definitions';
+import { Markdown } from '../types';
+
+const handler: Operation.WithHandler<typeof Create> = Create.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ name, content }) {
+      const object = Markdown.make({ name, content });
+      yield* CollectionModel.add({ object });
+
+      return {
+        id: Obj.getDXN(object).toString(),
+      };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/definitions.ts

@@ -0,0 +1,119 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Database, Ref } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { EditorViewMode } from '@dxos/ui-editor/types';
+import { trim } from '@dxos/util';
+
+import { meta } from '../meta';
+import { Markdown } from '../types';
+
+const MARKDOWN_OPERATION = `${meta.id}.operation`;
+
+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: 'org.dxos.function.markdown.create',
+    name: 'Create',
+    description: 'Creates a new markdown document and adds it to the space.',
+  },
+  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: `${MARKDOWN_OPERATION}.create`, name: 'Create Markdown Document' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    name: Schema.optional(Schema.String),
+    content: Schema.optional(Schema.String),
+  }),
+  output: Schema.Struct({
+    object: Markdown.Document,
+  }),
+});
+
+export const Open = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.open',
+    name: 'Open',
+    description: 'Opens and reads the contents of a new markdown document.',
+  },
+  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: `${MARKDOWN_OPERATION}.scroll-to-anchor`, name: 'Scroll To Anchor' },
+  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: `${MARKDOWN_OPERATION}.set-view-mode`, name: 'Set View Mode' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    id: Schema.String,
+    viewMode: EditorViewMode,
+  }),
+  output: Schema.Void,
+});
+
+export const Update = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.update',
+    name: 'Update',
+    description: trim`
+      Applies a set of edits to the markdown document.
+    `,
+  },
+  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],
+});

package/src/operations/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * as MarkdownOperation from './definitions';
+
+export const MarkdownOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./create'),
+  () => import('./create-markdown'),
+  () => import('./open'),
+  () => import('./scroll-to-anchor'),
+  () => import('./set-view-mode'),
+  () => import('./update'),
+);

package/src/operations/open.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Database } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { Open } from './definitions';
+
+const handler: Operation.WithHandler<typeof Open> = Open.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ doc }) {
+      const { content } = yield* doc.pipe(
+        Database.load,
+        Effect.map((_) => _.content),
+        Effect.flatMap(Database.load),
+      );
+      return { content };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/scroll-to-anchor.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { EditorView } from '@codemirror/view';
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/operation';
+import { Cursor, setSelection } from '@dxos/ui-editor';
+
+import { ScrollToAnchor } from './definitions';
+
+import { MarkdownCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof ScrollToAnchor> = ScrollToAnchor.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ subject, cursor }) {
+      const editorViews = yield* Capability.get(MarkdownCapabilities.EditorViews);
+      const entry = editorViews.get(subject);
+      if (!entry) {
+        return;
+      }
+      const range = Cursor.getRangeFromCursor(entry.view.state, cursor);
+      if (range) {
+        const selection = entry.view.state.selection.main.from !== range.from ? { anchor: range.from } : undefined;
+        const effects: any[] = [EditorView.scrollIntoView(range.from, { y: 'start', yMargin: 96 })];
+        if (selection) {
+          effects.push(setSelection.of({ current: entry.documentId }));
+        }
+        entry.view.dispatch({
+          effects,
+          selection: selection ? { anchor: range.from } : undefined,
+        });
+      }
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/set-view-mode.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities } from '@dxos/app-framework';
+import { Operation } from '@dxos/operation';
+
+import { SetViewMode } from './definitions';
+
+import { MarkdownCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof SetViewMode> = SetViewMode.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ id, viewMode }) {
+      yield* Capabilities.updateAtomValue(MarkdownCapabilities.State, (current) => ({
+        ...current,
+        viewMode: { ...current.viewMode, [id]: viewMode },
+      }));
+    }),
+  ),
+);
+
+export default handler;