@dxos/plugin-transcription 0.8.2-main.12df754 → 0.8.2-main.36232bc

package/src/model/model.test.ts

@@ -5,71 +5,97 @@
 import { EditorView } from '@codemirror/view';
 import { describe, test } from 'vitest';
 
-import { BlockModel, DocumentAdapter, type BlockRenderer } from './model';
-import { type TranscriptBlock } from '../types';
+import { type MessageType } from '@dxos/schema';
 
-const blockToMarkdown: BlockRenderer<TranscriptBlock> = (block: TranscriptBlock, debug = true): string[] => {
-  return [`###### ${block.authorName}`, ...block.segments.map((segment) => segment.text), ''];
+import { SerializationModel, DocumentAdapter, type ChunkRenderer } from './model';
+
+const blockToMarkdown: ChunkRenderer<MessageType> = (message: MessageType, index: number, debug = true): string[] => {
+  return [
+    `###### ${message.sender.name}`,
+    ...message.blocks.filter((block) => block.type === 'transcription').map((block) => block.text),
+    '',
+  ];
 };
 
 const createDate = () => new Date().toISOString();
 
-describe('BlockModel', () => {
+describe('SerializationModel', () => {
   test('basic', ({ expect }) => {
-    const model = new BlockModel<TranscriptBlock>(blockToMarkdown);
-    expect(model.blocks.length).to.eq(0);
+    const model = new SerializationModel<MessageType>(blockToMarkdown);
+    expect(model.chunks.length).to.eq(0);
     expect(model.doc.toString()).to.eq('');
 
-    // Create block.
-    const block = {
+    // Create message.
+    const message: MessageType = {
       id: '1',
-      authorName: 'Alice',
-      segments: [{ started: createDate(), text: 'Hello world!' }],
+      created: createDate(),
+      sender: { name: 'Alice' },
+      blocks: [
+        {
+          type: 'transcription',
+          started: createDate(),
+          text: 'Hello world!',
+        },
+      ],
     };
-    model.appendBlock(block);
+    model.appendChunk(message);
     {
       const text = model.doc.toString();
       expect(text).to.eq('###### Alice\nHello world!\n\n');
-      expect(model.blocks.length).to.eq(1);
+      expect(model.chunks.length).to.eq(1);
     }
 
-    // Update block.
-    block.segments.push({ started: new Date().toISOString(), text: 'Hello again!' });
-    model.updateBlock(block);
+    // Update message.
+    message.blocks.push({ type: 'transcription', started: createDate(), text: 'Hello again!' });
+    model.updateChunk(message);
     {
       const text = model.doc.toString();
       expect(text).to.eq('###### Alice\nHello world!\nHello again!\n\n');
-      expect(model.blocks.length).to.eq(1);
+      expect(model.chunks.length).to.eq(1);
     }
   });
 
   test('sync - append', ({ expect }) => {
     const view = new EditorView({ extensions: [], doc: '' });
-    const model = new BlockModel<TranscriptBlock>(blockToMarkdown);
+    const model = new SerializationModel<MessageType>(blockToMarkdown);
     const adapter = new DocumentAdapter(view);
     expect(adapter.lineCount()).to.eq(0);
     expect(view.state.doc.toString()).to.eq('');
 
-    // Append block.
+    // Append message.
     {
-      const block = {
+      const message: MessageType = {
         id: '1',
-        authorName: 'Alice',
-        segments: [{ started: createDate(), text: 'Hello world!' }],
+        created: createDate(),
+        sender: { name: 'Alice' },
+        blocks: [
+          {
+            type: 'transcription',
+            started: createDate(),
+            text: 'Hello world!',
+          },
+        ],
       };
-      model.appendBlock(block);
+      model.appendChunk(message);
       model.sync(adapter);
       expect(view.state.doc.toString()).to.eq('###### Alice\nHello world!\n\n');
     }
 
-    // Append block.
+    // Append message.
     {
-      const block = {
+      const message: MessageType = {
         id: '2',
-        authorName: 'Bob',
-        segments: [{ started: createDate(), text: 'Hello world!' }],
+        created: createDate(),
+        sender: { name: 'Bob' },
+        blocks: [
+          {
+            type: 'transcription',
+            started: createDate(),
+            text: 'Hello world!',
+          },
+        ],
       };
-      model.appendBlock(block);
+      model.appendChunk(message);
       model.sync(adapter);
       expect(view.state.doc.toString()).to.eq('###### Alice\nHello world!\n\n###### Bob\nHello world!\n\n');
     }
@@ -77,40 +103,56 @@ describe('BlockModel', () => {
 
   test('sync - append, update, delete', ({ expect }) => {
     const view = new EditorView({ extensions: [], doc: '' });
-    const model = new BlockModel<TranscriptBlock>(blockToMarkdown);
+    const model = new SerializationModel<MessageType>(blockToMarkdown);
     const adapter = new DocumentAdapter(view);
     expect(adapter.lineCount()).to.eq(0);
 
-    // Append block.
+    // Append message.
     {
-      const block = { id: '1', authorName: 'Alice', segments: [{ started: createDate(), text: 'Hello world!' }] };
-      model.appendBlock(block);
+      const message: MessageType = {
+        id: '1',
+        created: createDate(),
+        sender: { name: 'Alice' },
+        blocks: [
+          {
+            type: 'transcription',
+            started: createDate(),
+            text: 'Hello world!',
+          },
+        ],
+      };
+      model.appendChunk(message);
       model.sync(adapter);
       expect(view.state.doc.toString()).to.eq('###### Alice\nHello world!\n\n');
 
-      // Update block (add segment).
-      block.segments.push({ started: createDate(), text: 'Hello again!' });
-      model.updateBlock(block);
+      // Update message (add block).
+      message.blocks.push({ type: 'transcription', started: createDate(), text: 'Hello again!' });
+      model.updateChunk(message);
       model.sync(adapter);
       expect(view.state.doc.toString()).to.eq('###### Alice\nHello world!\nHello again!\n\n');
 
-      // Update block (remove segment).
-      block.segments.splice(0, 1);
-      model.updateBlock(block);
+      // Update message (remove block).
+      message.blocks.splice(0, 1);
+      model.updateChunk(message);
       model.sync(adapter);
       expect(view.state.doc.toString()).to.eq('###### Alice\nHello again!\n\n');
 
-      expect(model.getBlockAtLine(1)).to.eq(block);
+      expect(model.getChunkAtLine(1)).to.eq(message);
     }
 
-    // Append block.
+    // Append message.
     {
-      const block = { id: '2', authorName: 'Bob', segments: [{ started: createDate(), text: 'Hello again!' }] };
-      model.appendBlock(block);
+      const message: MessageType = {
+        id: '2',
+        created: createDate(),
+        sender: { name: 'Bob' },
+        blocks: [{ type: 'transcription', started: createDate(), text: 'Hello again!' }],
+      };
+      model.appendChunk(message);
       model.sync(adapter);
       expect(view.state.doc.toString()).to.eq('###### Alice\nHello again!\n\n###### Bob\nHello again!\n\n');
 
-      expect(model.getBlockAtLine(4)).to.eq(block);
+      expect(model.getChunkAtLine(4)).to.eq(message);
     }
 
     // Delete block.

package/src/model/model.ts

@@ -9,17 +9,17 @@ import { Event } from '@dxos/async';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
-export type Block = { id: string };
+export type Chunk = { id: string };
 
 /**
  * Covert block to a set of markdown lines.
  */
-export type BlockRenderer<T extends Block> = (block: T, debug?: boolean) => string[];
+export type ChunkRenderer<T extends Chunk> = (chunk: T, index: number, debug?: boolean) => string[];
 
 /**
  * Abstract representation of the document model.
  */
-export interface BlockDocument {
+export interface ChunkDocument {
   lineCount(): number;
   replaceLines(from: number, remove: number, insert: string[]): void;
 }
@@ -27,7 +27,7 @@ export interface BlockDocument {
 /**
  * Codemirror document adapter.
  */
-export class DocumentAdapter implements BlockDocument {
+export class DocumentAdapter implements ChunkDocument {
   constructor(private readonly _view: EditorView) {}
 
   /** The document must always have at least one line. */
@@ -54,16 +54,16 @@ export class DocumentAdapter implements BlockDocument {
   }
 }
 
-type BlockChange<T extends Block> =
+type ChunkChange<T extends Chunk> =
   | {
       type: 'append';
       index: number;
-      block: T;
+      chunk: T;
     }
   | {
       type: 'update';
       index: number;
-      block: T;
+      chunk: T;
     }
   | {
       type: 'delete';
@@ -72,98 +72,98 @@ type BlockChange<T extends Block> =
     };
 
 /**
- * Each Block can be converted into a set of lines.
- * Blocks can be added, updated or deleted from the Queue.
+ * Each Chunk can be converted into a set of lines.
+ * Chunks can be added, updated or deleted from the Queue.
  * A Document is an immutable projection that represents a flat list of lines corresponding to the Queue.
  *
  * Ideally we would implement a custom virtual Text model for the View, but this currently isn't possible in Codemirror.
- * Instead this model tracks changes and syncs them with the BlockDocument.
+ * Instead this model tracks changes and syncs them with the ChunkDocument.
  */
-export class BlockModel<T extends Block> {
-  /** Ordered set of blocks. */
-  private readonly _blocks: T[] = [];
+export class SerializationModel<T extends Chunk> {
+  /** Ordered set of chunks. */
+  private readonly _chunks: T[] = [];
 
-  /** Map of block IDs to their current line counts. */
-  private readonly _blockLineCounts = new Map<string, number>();
+  /** Map of chunk IDs to their current line counts. */
+  private readonly _chunkLineCounts = new Map<string, number>();
 
-  /** Map of line numbers to block IDs. */
-  private readonly _lineToBlock = new Map<number, T>();
+  /** Map of line numbers to chunk IDs. */
+  private readonly _lineToChunk = new Map<number, T>();
 
-  /** Track block changes since last sync. */
-  private readonly _changes: Array<BlockChange<T>> = [];
+  /** Track chunk changes since last sync. */
+  private readonly _changes: Array<ChunkChange<T>> = [];
 
   /** Emits when the document is updated. */
   public readonly update = new Event<void>();
 
   constructor(
-    private readonly _renderer: BlockRenderer<T>,
-    initialBlocks: T[] = [],
+    private readonly _renderer: ChunkRenderer<T>,
+    initialChunks: T[] = [],
   ) {
-    initialBlocks.forEach((block) => {
-      this.appendBlock(block);
+    initialChunks.forEach((chunk) => {
+      this.appendChunk(chunk);
     });
   }
 
   toJSON() {
     return {
-      blocks: this._blocks.length,
+      chunks: this._chunks.length,
       changes: this._changes.length,
     };
   }
 
   get doc() {
-    return Text.of([...this._blocks.flatMap((block) => this._renderer(block)), '']);
+    return Text.of([...this._chunks.flatMap((chunk, index) => this._renderer(chunk, index)), '']);
   }
 
-  get blocks() {
-    return this._blocks;
+  get chunks() {
+    return this._chunks;
   }
 
   /**
    * Get the block ID at the given line number.
    */
-  getBlockAtLine(line: number): T | undefined {
-    return this._lineToBlock.get(line);
+  getChunkAtLine(line: number): T | undefined {
+    return this._lineToChunk.get(line);
   }
 
   reset(): this {
-    this._blocks.length = 0;
-    this._blockLineCounts.clear();
-    this._lineToBlock.clear();
+    this._chunks.length = 0;
+    this._chunkLineCounts.clear();
+    this._lineToChunk.clear();
     this.update.emit();
     return this;
   }
 
-  appendBlock(block: T): this {
-    const index = this._blocks.length;
-    this._blocks.push(block);
-    this._changes.push({ type: 'append', index, block });
+  appendChunk(chunk: T): this {
+    const index = this._chunks.length;
+    this._chunks.push(chunk);
+    this._changes.push({ type: 'append', index, chunk });
     this.update.emit();
     return this;
   }
 
-  updateBlock(block: T): this {
-    const index = this._blocks.findIndex((b) => b.id === block.id);
+  updateChunk(chunk: T): this {
+    const index = this._chunks.findIndex((c) => c.id === chunk.id);
     invariant(index !== -1);
-    this._blocks[index] = block;
-    this._changes.push({ type: 'update', index, block });
+    this._chunks[index] = chunk;
+    this._changes.push({ type: 'update', index, chunk });
     this.update.emit();
     return this;
   }
 
   deleteBlock(id: string): this {
-    const index = this._blocks.findIndex((b) => b.id === id);
+    const index = this._chunks.findIndex((c) => c.id === id);
     invariant(index !== -1);
-    this._blocks.splice(index, 1);
+    this._chunks.splice(index, 1);
     this._changes.push({ type: 'delete', index, id });
     this.update.emit();
     return this;
   }
 
   /**
-   * Syncs the tracked changes with the BlockDocument.
+   * Syncs the tracked changes with the ChunkDocument.
    */
-  sync(document: BlockDocument): this {
+  sync(document: ChunkDocument): this {
     log('sync', { changes: this._changes });
 
     // Process each change in order.
@@ -171,7 +171,7 @@ export class BlockModel<T extends Block> {
       switch (change.type) {
         case 'append': {
           // For appends, convert block to lines and add at the end.
-          const lines = this._renderer(change.block);
+          const lines = this._renderer(change.chunk, change.index);
           const lastLine = document.lineCount();
           document.replaceLines(lastLine + 1, 0, lines);
           break;
@@ -181,10 +181,10 @@ export class BlockModel<T extends Block> {
           // For updates, find the block's line range and replace with new lines.
           let lineStart = 1;
           for (let i = 0; i < change.index; i++) {
-            lineStart += this._blockLineCounts.get(this._blocks[i].id)!;
+            lineStart += this._chunkLineCounts.get(this._chunks[i].id)!;
           }
-          const previousLineCount = this._blockLineCounts.get(change.block.id)!;
-          const newLines = this._renderer(change.block);
+          const previousLineCount = this._chunkLineCounts.get(change.chunk.id)!;
+          const newLines = this._renderer(change.chunk, change.index);
           document.replaceLines(lineStart, previousLineCount, newLines);
           break;
         }
@@ -193,9 +193,9 @@ export class BlockModel<T extends Block> {
           // For deletes, find the block's line range and remove those lines.
           let lineStart = 1;
           for (let i = 0; i < change.index; i++) {
-            lineStart += this._blockLineCounts.get(this._blocks[i].id)!;
+            lineStart += this._chunkLineCounts.get(this._chunks[i].id)!;
           }
-          const previousLineCount = this._blockLineCounts.get(change.id)!;
+          const previousLineCount = this._chunkLineCounts.get(change.id)!;
           document.replaceLines(lineStart, previousLineCount, []);
           break;
         }
@@ -203,22 +203,22 @@ export class BlockModel<T extends Block> {
     }
 
     // Clear the line-to-block mapping.
-    this._lineToBlock.clear();
+    this._lineToChunk.clear();
 
     // Update all block line counts and line-to-block mapping after processing changes.
     let currentLine = 1;
-    for (const block of this._blocks) {
-      const lineCount = this._renderer(block).length;
-      this._blockLineCounts.set(block.id, lineCount);
-      this._lineToBlock.set(currentLine, block);
+    for (const [index, chunk] of this._chunks.entries()) {
+      const lineCount = this._renderer(chunk, index).length;
+      this._chunkLineCounts.set(chunk.id, lineCount);
+      this._lineToChunk.set(currentLine, chunk);
       currentLine += lineCount;
     }
 
     // Clean up deleted blocks.
-    const blockIds = new Set(this._blocks.map((block) => block.id));
-    for (const id of this._blockLineCounts.keys()) {
-      if (!blockIds.has(id)) {
-        this._blockLineCounts.delete(id);
+    const chunkIds = new Set(this._chunks.map((chunk) => chunk.id));
+    for (const id of this._chunkLineCounts.keys()) {
+      if (!chunkIds.has(id)) {
+        this._chunkLineCounts.delete(id);
       }
     }
 

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './testing';

package/src/testing/testing.ts

@@ -0,0 +1,208 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect, useMemo, useState } from 'react';
+
+import { AIServiceEdgeClient } from '@dxos/assistant';
+import { AI_SERVICE_ENDPOINT } from '@dxos/assistant/testing';
+import { scheduleTaskInterval } from '@dxos/async';
+import { createQueueDxn, Filter, type Queue } from '@dxos/client/echo';
+import { Context } from '@dxos/context';
+import { AST, create, EchoObject, ObjectId, S } from '@dxos/echo-schema';
+import { IdentityDid } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { faker } from '@dxos/random';
+import { live, makeRef, useQueue, type Space } from '@dxos/react-client/echo';
+import { Contact, MessageType, Organization, type TranscriptionContentBlock } from '@dxos/schema';
+import { Testing, seedTestData } from '@dxos/schema/testing';
+
+import { processTranscriptMessage } from '../entity-extraction';
+
+// TODO(burdon): Reconcile with plugin-markdown. Move to @dxos/schema/testing.
+
+export const TestItem = S.Struct({
+  title: S.String.annotations({
+    [AST.TitleAnnotationId]: 'Title',
+    [AST.DescriptionAnnotationId]: 'Product title',
+  }),
+  description: S.String.annotations({
+    [AST.TitleAnnotationId]: 'Description',
+    [AST.DescriptionAnnotationId]: 'Product description',
+  }),
+}).pipe(EchoObject({ typename: 'dxos.org/type/Test', version: '0.1.0' }));
+
+// TODO(wittjosiah): Make builder generic and reuse for all message types.
+abstract class AbstractMessageBuilder {
+  abstract createMessage(numSegments?: number): Promise<MessageType>;
+}
+
+/**
+ * Generator of transcript messages.
+ */
+export class MessageBuilder extends AbstractMessageBuilder {
+  static readonly singleton = new MessageBuilder();
+
+  users = Array.from({ length: 5 }, () => ({
+    identityDid: IdentityDid.random().toString(),
+    name: faker.person.fullName(),
+    email: faker.internet.email(),
+  }));
+
+  start = new Date(Date.now() - 24 * 60 * 60 * 10_000);
+
+  constructor(private readonly _space?: Space) {
+    super();
+  }
+
+  override async createMessage(numSegments = 1): Promise<MessageType> {
+    return {
+      id: ObjectId.random().toString(),
+      created: this.next().toISOString(),
+      sender: faker.helpers.arrayElement(this.users),
+      blocks: Array.from({ length: numSegments }).map(() => this.createBlock()),
+    };
+  }
+
+  createBlock(): TranscriptionContentBlock {
+    let text = faker.lorem.paragraph();
+    if (this._space) {
+      const label = faker.commerce.productName();
+      const obj = this._space.db.add(live(TestItem, { title: label, description: faker.lorem.paragraph() }));
+      const dxn = makeRef(obj).dxn.toString();
+      const words = text.split(' ');
+      words.splice(Math.floor(Math.random() * words.length), 0, `[${label}][${dxn}]`);
+      text = words.join(' ');
+    }
+
+    return {
+      type: 'transcription',
+      started: this.next().toISOString(),
+      text,
+    };
+  }
+
+  next() {
+    this.start = new Date(this.start.getTime() + Math.random() * 10_000);
+    return this.start;
+  }
+}
+
+// TODO(burdon): Reconcile with BlockBuilder.
+class EntityExtractionMessageBuilder extends AbstractMessageBuilder {
+  aiService = new AIServiceEdgeClient({
+    endpoint: AI_SERVICE_ENDPOINT.REMOTE,
+  });
+
+  space: Space | undefined;
+  currentMessage: number = 0;
+  transcriptMessages: MessageType[] = [];
+
+  async connect(space: Space) {
+    this.space = space;
+    const { transcriptMessages } = await seedTestData(space);
+    this.transcriptMessages = transcriptMessages;
+  }
+
+  override async createMessage(): Promise<MessageType> {
+    if (!this.space) {
+      throw new Error('Space not connected');
+    }
+
+    const { objects } = await this.space.db
+      .query(Filter.or(Filter.schema(Contact), Filter.schema(Organization), Filter.schema(Testing.DocumentType)))
+      .run();
+
+    log.info('context', { objects });
+    const message = this.transcriptMessages[this.currentMessage];
+    this.currentMessage++;
+    this.currentMessage = this.currentMessage % this.transcriptMessages.length;
+
+    const { message: enhancedMessage } = await processTranscriptMessage({
+      message,
+      aiService: this.aiService,
+      context: {
+        objects,
+      },
+    });
+
+    return enhancedMessage;
+  }
+}
+
+type UseTestTranscriptionQueue = (
+  space: Space | undefined,
+  queueId?: ObjectId,
+  running?: boolean,
+  interval?: number,
+) => Queue<MessageType> | undefined;
+
+/**
+ * Test transcriptionqueue.
+ */
+export const useTestTranscriptionQueue: UseTestTranscriptionQueue = (
+  space: Space | undefined,
+  queueId?: ObjectId,
+  running = true,
+  interval = 1_000,
+) => {
+  const queueDxn = useMemo(() => (space ? createQueueDxn(space.id, queueId) : undefined), [space, queueId]);
+  const queue = useQueue<MessageType>(queueDxn);
+  const builder = useMemo(() => new MessageBuilder(space), [space]);
+
+  useEffect(() => {
+    if (!queue || !running) {
+      return;
+    }
+
+    const i = setInterval(() => {
+      void builder.createMessage(Math.ceil(Math.random() * 3)).then((message) => {
+        queue.append([create(MessageType, message)]);
+      });
+    }, interval);
+    return () => clearInterval(i);
+  }, [queue, running, interval]);
+
+  return queue;
+};
+
+/**
+ * Test transcription queue.
+ */
+// TODO(burdon): Reconcile with useTestTranscriptionQueue.
+export const useTestTranscriptionQueueWithEntityExtraction: UseTestTranscriptionQueue = (
+  space: Space | undefined,
+  queueId?: ObjectId,
+  running = true,
+  interval = 1_000,
+) => {
+  const queueDxn = useMemo(() => (space ? createQueueDxn(space.id, queueId) : undefined), [space, queueId]);
+  const queue = useQueue<MessageType>(queueDxn);
+  const [builder] = useState(() => new EntityExtractionMessageBuilder());
+
+  useEffect(() => {
+    if (!queue || !running) {
+      return;
+    }
+
+    if (space) {
+      void builder.connect(space);
+    }
+
+    const ctx = new Context();
+    scheduleTaskInterval(
+      ctx,
+      async () => {
+        const message = await builder.createMessage();
+        queue.append([create(MessageType, message)]);
+      },
+      interval,
+    );
+
+    return () => {
+      void ctx.dispose();
+    };
+  }, [space, queue, running, interval]);
+
+  return queue;
+};