Allow mentioning in comments

Author: exAspArk

backend/src/entities/comment.ts

@@ -19,31 +19,37 @@ export class Comment extends BaseEntity {
   user: User;
 
   @Property({ columnType: 'text' })
-  text: string;
+  contentText: string;
+  @Property({ columnType: 'text' })
+  contentHtml: string;
   @Property()
   editedAt?: Date;
 
   constructor({
     boardCard,
     user,
-    text,
+    contentText,
+    contentHtml,
     createdAt,
   }: {
     boardCard: BoardCard;
     user: User;
-    text: string;
+    contentText: string;
+    contentHtml: string;
     createdAt?: Date;
   }) {
     super();
     this.boardCard = boardCard;
     this.user = user;
-    this.text = text;
+    this.contentText = contentText;
+    this.contentHtml = contentHtml;
     this.createdAt = createdAt ?? new Date();
     this.validate();
   }
 
-  update({ text }: { text: string }) {
-    this.text = text;
+  update({ contentText, contentHtml }: { contentText: string; contentHtml: string }) {
+    this.contentText = contentText;
+    this.contentHtml = contentHtml;
     this.editedAt = new Date();
     this.validate();
   }
@@ -53,7 +59,8 @@ export class Comment extends BaseEntity {
       id: comment.id,
       boardCardId: comment.boardCard.id,
       user: User.toJson(comment.loadedUser),
-      text: comment.text,
+      contentHtml: comment.contentHtml,
+      contentText: comment.contentText,
       createdAt: comment.createdAt,
       editedAt: comment.editedAt,
     };
@@ -62,10 +69,10 @@ export class Comment extends BaseEntity {
   static toText(comment: Loaded<Comment, 'user'>) {
     const user = comment.loadedUser;
     const items = [
-      `- Comment ID: ${comment.id}`,
+      `- ID: ${comment.id}`,
       `- Created At: ${comment.createdAt.toISOString()}`,
       `- User: ${User.toStr(user)}`,
-      `- Text: ${comment.text}`,
+      `- Content: ${comment.contentText}`,
     ];
 
     return `Comment:
@@ -75,6 +82,7 @@ ${items.join('\n')}`;
   private validate() {
     if (!this.boardCard) throw new Error('BoardCard is required');
     if (!this.user) throw new Error('User is required');
-    if (!this.text) throw new Error('Text is required');
+    if (!this.contentHtml) throw new Error('Content html is required');
+    if (!this.contentText) throw new Error('Content text is required');
   }
 }

backend/src/entities/email-message.ts

@@ -3,7 +3,7 @@ import { BaseEntity } from '@/entities/base-entity';
 import { Domain } from '@/entities/domain';
 import type { GmailAccount } from '@/entities/gmail-account';
 import { GmailAttachment } from '@/entities/gmail-attachment';
-import { htmlToText, parseHtmlBody, parseTextBody } from '@/utils/email';
+import { parseHtmlBody, parseTextBody } from '@/utils/email';
 import { type Participant, participantToString } from '@/utils/shared';
 
 export interface EmailMessage {

backend/src/migrations/.snapshot-bordly_dev.json

@@ -1889,8 +1889,17 @@
           "nullable": false,
           "mappedType": "uuid"
         },
-        "text": {
-          "name": "text",
+        "content_text": {
+          "name": "content_text",
+          "type": "text",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": false,
+          "mappedType": "text"
+        },
+        "content_html": {
+          "name": "content_html",
           "type": "text",
           "unsigned": false,
           "autoincrement": false,

backend/src/migrations/Migration20260224153054_add_content_html_in_comments.ts

@@ -0,0 +1,14 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260224153054_add_content_html_in_comments extends Migration {
+  override async up(): Promise<void> {
+    this.addSql(`alter table "comments" add column "content_html" text not null;`);
+    this.addSql(`alter table "comments" rename column "text" to "content_text";`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`alter table "comments" drop column "content_html";`);
+
+    this.addSql(`alter table "comments" rename column "content_text" to "text";`);
+  }
+}

backend/src/services/agent.service.ts

@@ -4,6 +4,7 @@ import { RequestContext } from '@mastra/core/request-context';
 import type { ToolAction } from '@mastra/core/tools';
 import type { Loaded } from '@mikro-orm/postgresql';
 import type { Board } from '@/entities/board';
+import type { BoardCard } from '@/entities/board-card';
 import { BoardMember } from '@/entities/board-member';
 import { BORDLY_USER_ID } from '@/entities/user';
 import { BoardMemberService } from '@/services/board-member.service';
@@ -17,6 +18,7 @@ export interface Context {
   userBoardMember?: Loaded<BoardMember>;
   userTimeZone?: string;
   bordlyBoardMember: Loaded<BoardMember>;
+  boardCard: Loaded<BoardCard>;
 }
 
 const BORDLY_AGENT = {
@@ -58,13 +60,13 @@ export class AgentService {
 
   static async runBordlyAgent({
     board,
-    boardCardId,
+    boardCard,
     prompt,
     userBoardMember,
     userTimeZone,
   }: {
     board: Loaded<Board>;
-    boardCardId: string;
+    boardCard: Loaded<BoardCard>;
     prompt: string;
     userBoardMember: Loaded<BoardMember, 'user' | 'memory'>;
     userTimeZone?: string;
@@ -78,19 +80,24 @@ export class AgentService {
     requestContext.set('bordlyBoardMember', bordlyBoardMember);
     requestContext.set('userBoardMember', userBoardMember);
     requestContext.set('userTimeZone', userTimeZone);
+    requestContext.set('boardCard', boardCard);
 
     const agent = AgentService.createAgent(BORDLY_AGENT);
     const messages: MessageListInput = [
-      { role: 'system', content: `You are assisting with email management for a board card with ID ${boardCardId}.` },
+      { role: 'system', content: `You are assisting with email management for a board card with ID ${boardCard.id}.` },
+      {
+        role: 'system',
+        content: `Current date and time: ${new Date().toLocaleString('en-US', { timeZone: userTimeZone })} (${userTimeZone})`,
+      },
       { role: 'system', content: `The user who sent the prompt: ${BoardMember.toText(userBoardMember)}` },
       { role: 'user', content: prompt },
     ];
 
-    Logger.info(`[AGENT] Running Bordly for board card ${boardCardId}`);
+    Logger.info(`[AGENT] Running Bordly for board card ${boardCard.id}`);
     Logger.logObjects(messages);
     const response = await agent.generate(messages, { requestContext });
-    Logger.info(`[AGENT] Completed Bordly for board card ${boardCardId}:\n${response.text}`);
+    Logger.info(`[AGENT] Completed Bordly for board card ${boardCard.id}:\n${response.text}`);
 
-    return response;
+    return requestContext.get('boardCard') as typeof boardCard;
   }
 }

backend/src/services/board-card.service.ts

@@ -1,4 +1,4 @@
-import type { Loaded, Populate } from '@mikro-orm/postgresql';
+import type { AutoPath, Loaded, Populate, PopulatePath } from '@mikro-orm/postgresql';
 import type { Board } from '@/entities/board';
 import type { BoardAccount } from '@/entities/board-account';
 import { BoardCard, State } from '@/entities/board-card';
@@ -81,6 +81,14 @@ export class BoardCardService {
     return orm.em.find(BoardCard, { boardColumn: { board } }, { populate });
   }
 
+  static async populate<Hint extends string = never>(
+    boardCard: Loaded<BoardCard>,
+    populate: readonly AutoPath<BoardCard, Hint, PopulatePath.ALL>[],
+  ) {
+    await orm.em.populate(boardCard, populate);
+    return boardCard as Loaded<BoardCard, Hint>;
+  }
+
   static async createWithEmailDraft(
     board: Loaded<Board>,
     { user, boardAccountId }: { user: Loaded<User, 'boardMembers'>; boardAccountId: string },

backend/src/services/board-member.service.ts

@@ -30,7 +30,7 @@ export class BoardMemberService {
     populate: readonly AutoPath<BoardMember, Hint, PopulatePath.ALL>[],
   ) {
     await orm.em.populate(boardMember, populate);
-    return boardMember;
+    return boardMember as Loaded<BoardMember, Hint>;
   }
 
   static async findMembers<Hint extends string = never>(

backend/src/services/board.service.ts

@@ -32,7 +32,7 @@ export class BoardService {
     populate: readonly AutoPath<Board, Hint, PopulatePath.ALL>[],
   ) {
     await orm.em.populate(board, populate);
-    return board;
+    return board as Loaded<Board, Hint>;
   }
 
   static async setName(board: Board, { name }: { name: string }) {

backend/src/services/comment.service.ts

@@ -1,7 +1,6 @@
 import type { Loaded, OrderDefinition, Populate } from '@mikro-orm/postgresql';
 import type { Board } from '@/entities/board';
 import type { BoardCard } from '@/entities/board-card';
-import type { BoardMember } from '@/entities/board-member';
 import { Comment } from '@/entities/comment';
 import type { User } from '@/entities/user';
 import { AgentService } from '@/services/agent.service';
@@ -16,16 +15,23 @@ export class CommentService {
     {
       board,
       user,
-      text,
+      contentHtml,
+      contentText,
       userTimeZone,
-    }: { board: Loaded<Board>; user: Loaded<User, 'boardMembers'>; text: string; userTimeZone?: string },
+    }: {
+      board: Loaded<Board>;
+      user: Loaded<User, 'boardMembers'>;
+      contentHtml: string;
+      contentText: string;
+      userTimeZone?: string;
+    },
   ) {
-    const comment = new Comment({ boardCard, user, text });
+    const comment = new Comment({ boardCard, user, contentHtml, contentText });
     const boardMember = user.boardMembers.find((bm) => bm.board.id === board.id)!;
 
     if (!boardCard.assignedBoardMember) boardCard.assignToBoardMember(boardMember);
     boardCard.addParticipantUserId(user.id);
-    boardCard.setSnippet(`${user.firstName}: ${text}`);
+    boardCard.setSnippet(`${user.firstName}: ${contentText}`);
     boardCard.setLastEventAt(comment.createdAt);
 
     const userBoardCardReadPosition = boardCard.boardCardReadPositions.find((pos) => pos.user.id === user.id)!;
@@ -35,16 +41,23 @@ export class CommentService {
 
     await orm.em.flush();
 
-    if (isBordlyComment(text)) {
+    if (isBordlyComment(contentText)) {
       const userBoardMember = await BoardMemberService.findById(board, {
         boardMemberId: boardMember.id,
         populate: ['user', 'memory'],
       });
-      const prompt = CommentService.bordlyPrompt(text);
-      await AgentService.runBordlyAgent({ board, boardCardId: boardCard.id, prompt, userBoardMember, userTimeZone });
+      const prompt = CommentService.bordlyPrompt(contentText);
+      const updatedBoardCard = await AgentService.runBordlyAgent({
+        board,
+        boardCard,
+        prompt,
+        userBoardMember,
+        userTimeZone,
+      });
+      return { boardCard: updatedBoardCard, comment };
     }
 
-    return comment;
+    return { boardCard, comment };
   }
 
   static async edit<Hint extends string = never>(
@@ -53,14 +66,16 @@ export class CommentService {
       board,
       user,
       commentId,
-      text,
+      contentHtml,
+      contentText,
       userTimeZone,
       populate,
     }: {
       board: Loaded<Board>;
       user: Loaded<User, 'boardMembers'>;
       commentId: string;
-      text: string;
+      contentHtml: string;
+      contentText: string;
       userTimeZone?: string;
       populate?: Populate<Comment, Hint>;
     },
@@ -69,26 +84,33 @@ export class CommentService {
     const boardMember = user.boardMembers.find((bm) => bm.board.id === board.id)!;
     const wasLastBoardCardEvent = comment.createdAt.getTime() === boardCard.lastEventAt.getTime();
 
-    comment.update({ text });
+    comment.update({ contentHtml, contentText });
     orm.em.persist(comment);
     if (wasLastBoardCardEvent) {
-      boardCard.setSnippet(`${comment.user.firstName}: ${text}`);
+      boardCard.setSnippet(`${comment.user.firstName}: ${contentText}`);
       orm.em.persist(boardCard);
     }
 
     await orm.em.flush();
 
-    if (isBordlyComment(text)) {
+    if (isBordlyComment(contentText)) {
       const userBoardMember = await BoardMemberService.findById(board, {
         boardMemberId: boardMember.id,
         populate: ['user', 'memory'],
       });
 
-      const prompt = CommentService.bordlyPrompt(text);
-      await AgentService.runBordlyAgent({ board, boardCardId: boardCard.id, prompt, userBoardMember, userTimeZone });
+      const prompt = CommentService.bordlyPrompt(contentText);
+      const updatedBoardCard = await AgentService.runBordlyAgent({
+        board,
+        boardCard,
+        prompt,
+        userBoardMember,
+        userTimeZone,
+      });
+      return { boardCard: updatedBoardCard, comment };
     }
 
-    return comment;
+    return { boardCard, comment };
   }
 
   static async delete(boardCard: BoardCard, { commentId }: { commentId: string }) {
@@ -115,14 +137,14 @@ export class CommentService {
 
       if (lastComment && lastEmailMessage) {
         if (lastComment.createdAt.getTime() > lastEmailMessage.externalCreatedAt.getTime()) {
-          boardCard.setSnippet(`${lastComment.user.firstName}: ${lastComment.text}`);
+          boardCard.setSnippet(`${lastComment.user.firstName}: ${lastComment.contentText}`);
           boardCard.setLastEventAt(lastComment.createdAt);
         } else {
           boardCard.setSnippet(lastEmailMessage.snippet);
           boardCard.setLastEventAt(lastEmailMessage.externalCreatedAt);
         }
       } else if (lastComment) {
-        boardCard.setSnippet(`${lastComment.user.firstName}: ${lastComment.text}`);
+        boardCard.setSnippet(`${lastComment.user.firstName}: ${lastComment.contentText}`);
         boardCard.setLastEventAt(lastComment.createdAt);
       } else if (lastEmailMessage) {
         boardCard.setSnippet(lastEmailMessage.snippet);

backend/src/tools/board-card-read.tool.ts

@@ -14,18 +14,17 @@ import { Logger } from '@/utils/logger';
 export const boardCardReadTool = createTool({
   id: 'board-card-read',
   description: 'Read board card with email messages, an email draft, and comments',
-  inputSchema: z.object({
-    boardCardId: z.uuid().describe('The ID of the board card to read'),
-  }),
-  execute: async ({ boardCardId }, context) => {
-    Logger.info(`[AGENT] Tool board-card-read for board card ${boardCardId}`);
+  inputSchema: z.object({}),
+  execute: async (_, context) => {
     const { requestContext } = context as { requestContext: RequestContext<Context> };
-    const bordlyBoardMember = requestContext.get('bordlyBoardMember');
+    const initialBoardCard = requestContext.get('boardCard');
+    Logger.info(`[AGENT] Tool board-card-read for board card ${initialBoardCard.id}`);
 
-    const boardCard = await BoardCardService.findById(bordlyBoardMember.board, {
-      boardCardId,
-      populate: ['assignedBoardMember.user', 'boardColumn', 'emailDraft.fileAttachments'],
-    });
+    const boardCard = await BoardCardService.populate(initialBoardCard, [
+      'assignedBoardMember.user',
+      'boardColumn',
+      'emailDraft.fileAttachments',
+    ]);
 
     const [lastEmailMessage] = await EmailMessageService.findEmailMessagesByBoardCard(boardCard, {
       populate: ['domain', 'gmailAttachments'],
@@ -50,6 +49,7 @@ export const boardCardReadTool = createTool({
     if (result.lastEmailMessage) Logger.log(result.lastEmailMessage);
     Logger.logObjects(result.commentsAsc);
 
+    requestContext.set('boardCard', boardCard);
     return result;
   },
 });