@dxos/plugin-markdown 0.8.4-main.2e9d522 → 0.8.4-main.3eb6e50203

package/src/blueprints/functions/update.test.ts

@@ -0,0 +1,215 @@
+//
+// 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 { 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 { Collection } from '@dxos/schema';
+import { HasSubject } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+import { WithProperties } from '../../testing';
+import * as MarkdownBlueprint from '../markdown-blueprint';
+
+import update from './update';
+
+ObjectId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  functions: [...MarkdownBlueprint.functions],
+  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/blueprints/functions/update.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { next as A, type Doc } from '@automerge/automerge';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Database, Type } from '@dxos/echo';
+import { DocAccessor, createDocAccessor } from '@dxos/echo-db';
+import { defineFunction } from '@dxos/functions';
+import { trim } from '@dxos/util';
+
+import { Markdown } from '../../types';
+
+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).',
+  }),
+});
+
+// TODO(wittjosiah): Reconcile with ThreadAction.AddProposal.
+// Based on opencode's MutilEdit tool: https://deepwiki.com/search/how-does-text-edit-tool-work_a159bc76-5401-424e-b29f-f087d1ea4f78
+export default defineFunction({
+  key: 'dxos.org/function/markdown/update',
+  name: 'Update',
+  description: trim`
+    Applies a set of edits to the markdown document.
+  `,
+  inputSchema: Schema.Struct({
+    doc: Type.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.',
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    newContent: Schema.String,
+  }),
+  handler: Effect.fn(function* ({ data: { 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),
+    };
+  }),
+});

package/src/blueprints/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * as MarkdownBlueprint from './markdown-blueprint';

package/src/blueprints/markdown-blueprint.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Blueprint, Template } from '@dxos/blueprints';
+import { type FunctionDefinition } from '@dxos/functions';
+import { trim } from '@dxos/util';
+
+import { create, open, update } from './functions';
+
+export const functions: FunctionDefinition[] = [create, open, update];
+
+export const Key = 'dxos.org/blueprint/markdown';
+
+export const make = () =>
+  Blueprint.make({
+    key: Key,
+    name: 'Markdown',
+    tools: Blueprint.toolDefinitions({ functions }),
+    instructions: Template.make({
+      // TODO(wittjosiah): Move example to function input schema annotation.
+      source: trim`
+        {{! Markdown }}
+
+        You can create, read 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.
+
+        Example:
+        ${'```'}diff
+        - "There is a tyop in this sentence."
+        + "There is a typo in this sentence."
+        - "This id good."
+        + "This sentence is really good."
+        ${'```'}
+      `,
+    }),
+  });

package/src/capabilities/anchor-sort/anchor-sort.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Relation } from '@dxos/echo';
+import { createDocAccessor, getRangeFromCursor } from '@dxos/echo-db';
+import { type AnchoredTo } from '@dxos/types';
+
+import { Markdown } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(AppCapabilities.AnchorSort, {
+      key: Markdown.Document.typename,
+      sort: (anchorA: AnchoredTo.AnchoredTo, anchorB: AnchoredTo.AnchoredTo) => {
+        const doc = Relation.getTarget(anchorA) as Markdown.Document;
+        const accessor = doc.content.target ? createDocAccessor(doc.content.target, ['content']) : undefined;
+        if (doc !== Relation.getTarget(anchorB) || !accessor) {
+          return 0;
+        }
+
+        const getStartPosition = (cursor: string | undefined) => {
+          const range = cursor ? getRangeFromCursor(accessor, cursor) : undefined;
+          return range?.start ?? Number.MAX_SAFE_INTEGER;
+        };
+
+        const posA = getStartPosition(anchorA.anchor);
+        const posB = getStartPosition(anchorB.anchor);
+        return posA - posB;
+      },
+    }),
+  ),
+);

package/src/capabilities/anchor-sort/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const AnchorSort = Capability.lazy('AnchorSort', () => import('./anchor-sort'));

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

@@ -0,0 +1,60 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Obj } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space/types';
+import { isSpace } from '@dxos/react-client/echo';
+import { Collection } from '@dxos/schema';
+
+import { translations } from '../../translations';
+import { Markdown, MarkdownOperation } from '../../types';
+
+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 { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+          const createResult = await invokePromise(MarkdownOperation.Create, { name: data.name, content: data.data });
+          if (!createResult.data?.object) {
+            return undefined;
+          }
+          await invokePromise(SpaceOperation.AddObject, { target, object: createResult.data.object });
+
+          return createResult.data.object;
+        },
+      },
+    ]);
+  }),
+);

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

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const AppGraphSerializer = Capability.lazy('AppGraphSerializer', () => import('./app-graph-serializer'));

package/src/capabilities/artifact-definition/artifact-definition.ts

@@ -0,0 +1,110 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// ISSUE(burdon): defineArtifact
+// @ts-nocheck
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { ToolResult, createTool } from '@dxos/ai';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { ArtifactId, createArtifactElement } from '@dxos/assistant';
+import { defineArtifact } from '@dxos/blueprints';
+import { Obj } from '@dxos/echo';
+import { assertArgument, invariant } from '@dxos/invariant';
+import { SpaceOperation } from '@dxos/plugin-space/types';
+import { Filter } from '@dxos/react-client/echo';
+
+import { meta } from '../../meta';
+import { Markdown } from '../../types';
+
+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.',
+            }),
+          }),
+          execute: async ({ name, content }, { extensions }) => {
+            invariant(extensions?.space, 'No space');
+            invariant(extensions?.invoke, 'No operation invoker');
+
+            const document = Markdown.make({ name, content });
+
+            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(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,
+          }),
+          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: Obj.getDXN(document).toString(),
+              name: document.name || document.fallbackName || 'Unnamed Document',
+              content,
+            });
+          },
+        }),
+      ],
+    });
+
+    return Capability.contributes(Capabilities.ArtifactDefinition, definition);
+  }),
+);

package/src/capabilities/artifact-definition/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ArtifactDefinition = Capability.lazy('ArtifactDefinition', () => import('./artifact-definition'));

package/src/capabilities/blueprint-definition/blueprint-definition.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+
+import { MarkdownBlueprint } from '../../blueprints';
+
+export const functions = MarkdownBlueprint.functions;
+
+export type BlueprintCapabilities = [
+  Capability.Capability<typeof AppCapabilities.Functions>,
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>,
+];
+
+const blueprintDefinition = Capability.makeModule<[], BlueprintCapabilities>(() =>
+  Effect.succeed([
+    Capability.contributes(AppCapabilities.Functions, functions),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, MarkdownBlueprint.make()),
+  ]),
+);
+
+export default blueprintDefinition;

package/src/capabilities/blueprint-definition/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));

package/src/capabilities/index.ts

@@ -2,14 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
-
-export const AnchorSort = lazy(() => import('./anchor-sort'));
-export const AppGraphSerializer = lazy(() => import('./app-graph-serializer'));
-export const ArtifactDefinition = lazy(() => import('./artifact-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 * from './capabilities';
+export * from './anchor-sort';
+export * from './app-graph-serializer';
+export * from './blueprint-definition';
+export * from './operation-resolver';
+export * from './react-surface';
+export * from './settings';
+export * from './state';

package/src/capabilities/operation-resolver/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const OperationResolver = Capability.lazy('OperationResolver', () => import('./operation-resolver'));