@critical-path/core 0.8.3 → 0.10.0

package/src/domain/events.ts

@@ -8,6 +8,7 @@ import type {
   TaskDependency,
   TimeEntry,
   Comment,
+  CommentReaction,
   Attachment
 } from '../types/index.js';
 
@@ -65,6 +66,16 @@ export interface CommentDeletedEvent extends DomainEvent<{ commentId: string; ta
   readonly aggregateType: 'Comment';
 }
 
+export interface CommentReactionAddedEvent extends DomainEvent<{ commentId: string; reaction: CommentReaction; comment: Comment }> {
+  readonly name: 'comment.reaction.added';
+  readonly aggregateType: 'Comment';
+}
+
+export interface CommentReactionRemovedEvent extends DomainEvent<{ commentId: string; reaction: { emoji: string; userId: string }; comment: Comment }> {
+  readonly name: 'comment.reaction.removed';
+  readonly aggregateType: 'Comment';
+}
+
 export interface AttachmentCreatedEvent extends DomainEvent<{ attachment: Attachment }> {
   readonly name: 'attachment.created';
   readonly aggregateType: 'Attachment';
@@ -134,6 +145,8 @@ export type CriticalPathDomainEvent =
   | CommentAddedEvent
   | CommentUpdatedEvent
   | CommentDeletedEvent
+  | CommentReactionAddedEvent
+  | CommentReactionRemovedEvent
   | AttachmentCreatedEvent
   | AttachmentDeletedEvent
   | TaskDependencyAddedEvent

package/src/engine/index.ts

@@ -48,6 +48,8 @@ import {
   CommentAddedEvent,
   CommentUpdatedEvent,
   CommentDeletedEvent,
+  CommentReactionAddedEvent,
+  CommentReactionRemovedEvent,
   AttachmentCreatedEvent,
   AttachmentDeletedEvent
 } from '../domain/events.js';
@@ -683,6 +685,82 @@ export class CriticalPathEngine {
     return deleted;
   }
 
+  async addCommentReaction(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null> {
+    const existing = await this.store.getComment(commentId);
+    if (!existing) return null;
+
+    let updated: Comment | null;
+    if (this.store.addReaction) {
+      updated = await this.store.addReaction(commentId, reaction);
+    } else {
+      const reactions = existing.reactions ? [...existing.reactions] : [];
+      const alreadyExists = reactions.some((r) => r.emoji === reaction.emoji && r.userId === reaction.userId);
+      if (!alreadyExists) {
+        reactions.push({
+          emoji: reaction.emoji,
+          userId: reaction.userId,
+          createdAt: new Date().toISOString()
+        });
+      }
+      updated = await this.store.updateComment(commentId, { reactions });
+    }
+
+    if (!updated) return null;
+
+    const now = new Date().toISOString();
+    const event: CommentReactionAddedEvent = {
+      id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+      name: 'comment.reaction.added',
+      aggregateId: commentId,
+      aggregateType: 'Comment',
+      occurredAt: now,
+      payload: {
+        commentId,
+        reaction: {
+          emoji: reaction.emoji,
+          userId: reaction.userId,
+          createdAt: now
+        },
+        comment: updated
+      }
+    };
+    await this.events.publish(event);
+
+    this.dispatchWebhook('comment.reaction.added', { comment: updated, reaction });
+    return updated;
+  }
+
+  async removeCommentReaction(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null> {
+    const existing = await this.store.getComment(commentId);
+    if (!existing) return null;
+
+    let updated: Comment | null;
+    if (this.store.removeReaction) {
+      updated = await this.store.removeReaction(commentId, reaction);
+    } else {
+      const reactions = (existing.reactions || []).filter(
+        (r) => !(r.emoji === reaction.emoji && r.userId === reaction.userId)
+      );
+      updated = await this.store.updateComment(commentId, { reactions });
+    }
+
+    if (!updated) return null;
+
+    const now = new Date().toISOString();
+    const event: CommentReactionRemovedEvent = {
+      id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+      name: 'comment.reaction.removed',
+      aggregateId: commentId,
+      aggregateType: 'Comment',
+      occurredAt: now,
+      payload: { commentId, reaction, comment: updated }
+    };
+    await this.events.publish(event);
+
+    this.dispatchWebhook('comment.reaction.removed', { comment: updated, reaction });
+    return updated;
+  }
+
   // --- Attachments ---
   async getAttachments(filter?: { taskId?: string; projectId?: string; commentId?: string }): Promise<Attachment[]> {
     return this.store.getAttachments(filter);

package/src/index.test.ts

@@ -257,5 +257,58 @@ describe('CriticalPathEngine Core Tests', () => {
       })
     ).rejects.toThrow('Attachment URL cannot be a large data URI');
   });
+
+  it('supports adding and removing emoji reactions on comments with events and deduplication', async () => {
+    const engine = new CriticalPathEngine();
+    const proj = await engine.createProject({ key: 'CMT', name: 'Comment Project' });
+    const task = await engine.createTask({ projectId: proj.id, title: 'Comment Task', status: 'todo' });
+
+    const comment = await engine.addComment({
+      taskId: task.id,
+      authorId: 'user_1',
+      content: 'Great progress!'
+    });
+
+    const receivedEvents: string[] = [];
+    engine.events.subscribe('*', (event) => {
+      receivedEvents.push(event.name);
+    });
+
+    // Add reaction 👍
+    const withReaction = await engine.addCommentReaction(comment.id, {
+      emoji: '👍',
+      userId: 'user_2'
+    });
+    expect(withReaction?.reactions).toHaveLength(1);
+    expect(withReaction?.reactions?.[0]).toMatchObject({
+      emoji: '👍',
+      userId: 'user_2'
+    });
+    expect(withReaction?.reactions?.[0].createdAt).toBeDefined();
+    expect(receivedEvents).toContain('comment.reaction.added');
+
+    // Add duplicate reaction from same user (should deduplicate)
+    const duplicateReaction = await engine.addCommentReaction(comment.id, {
+      emoji: '👍',
+      userId: 'user_2'
+    });
+    expect(duplicateReaction?.reactions).toHaveLength(1);
+
+    // Add different reaction from another user
+    const secondReaction = await engine.addCommentReaction(comment.id, {
+      emoji: '🚀',
+      userId: 'user_3'
+    });
+    expect(secondReaction?.reactions).toHaveLength(2);
+
+    // Remove reaction 👍
+    const afterRemoval = await engine.removeCommentReaction(comment.id, {
+      emoji: '👍',
+      userId: 'user_2'
+    });
+    expect(afterRemoval?.reactions).toHaveLength(1);
+    expect(afterRemoval?.reactions?.[0].emoji).toBe('🚀');
+    expect(receivedEvents).toContain('comment.reaction.removed');
+  });
 });
 

package/src/store/firebase.ts

@@ -404,6 +404,30 @@ export class FirebaseStore implements StorageAdapter {
     return true;
   }
 
+  async addReaction(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null> {
+    const existing = await this.getComment(commentId);
+    if (!existing) return null;
+    const reactions = existing.reactions ? [...existing.reactions] : [];
+    const alreadyExists = reactions.some((r) => r.emoji === reaction.emoji && r.userId === reaction.userId);
+    if (!alreadyExists) {
+      reactions.push({
+        emoji: reaction.emoji,
+        userId: reaction.userId,
+        createdAt: new Date().toISOString()
+      });
+    }
+    return this.updateComment(commentId, { reactions });
+  }
+
+  async removeReaction(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null> {
+    const existing = await this.getComment(commentId);
+    if (!existing) return null;
+    const reactions = (existing.reactions || []).filter(
+      (r) => !(r.emoji === reaction.emoji && r.userId === reaction.userId)
+    );
+    return this.updateComment(commentId, { reactions });
+  }
+
   // --- Attachments ---
   async getAttachments(filter?: { taskId?: string; projectId?: string; commentId?: string }): Promise<Attachment[]> {
     let snap;

package/src/store/index.ts

@@ -71,6 +71,8 @@ export interface CommentRepository {
   addComment(comment: Omit<Comment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Comment>;
   updateComment(id: string, updates: Partial<Comment>): Promise<Comment | null>;
   deleteComment(id: string): Promise<boolean>;
+  addReaction?(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null>;
+  removeReaction?(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null>;
 }
 
 export interface AttachmentRepository {
@@ -369,6 +371,42 @@ export class InMemoryStore implements StorageAdapter {
     return this.comments.delete(id);
   }
 
+  async addReaction(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null> {
+    const existing = this.comments.get(commentId);
+    if (!existing) return null;
+    const reactions = existing.reactions ? [...existing.reactions] : [];
+    const alreadyExists = reactions.some((r) => r.emoji === reaction.emoji && r.userId === reaction.userId);
+    if (!alreadyExists) {
+      reactions.push({
+        emoji: reaction.emoji,
+        userId: reaction.userId,
+        createdAt: new Date().toISOString()
+      });
+    }
+    const updated: Comment = {
+      ...existing,
+      reactions,
+      updatedAt: new Date().toISOString()
+    };
+    this.comments.set(commentId, updated);
+    return updated;
+  }
+
+  async removeReaction(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null> {
+    const existing = this.comments.get(commentId);
+    if (!existing) return null;
+    const reactions = (existing.reactions || []).filter(
+      (r) => !(r.emoji === reaction.emoji && r.userId === reaction.userId)
+    );
+    const updated: Comment = {
+      ...existing,
+      reactions,
+      updatedAt: new Date().toISOString()
+    };
+    this.comments.set(commentId, updated);
+    return updated;
+  }
+
   // Attachments
   async getAttachments(filter?: { taskId?: string; projectId?: string; commentId?: string }): Promise<Attachment[]> {
     return Array.from(this.attachments.values()).filter((a) => {

package/src/store/sqlite.test.ts

@@ -94,6 +94,17 @@ describe('SQLiteStore', () => {
     const entries = await store.getTimeEntries('task_1');
     expect(entries).toHaveLength(1);
 
+    // Emoji reactions
+    const reactComment = await store.addReaction(comment.id, { emoji: '🔥', userId: 'user_2' });
+    expect(reactComment?.reactions).toHaveLength(1);
+    expect(reactComment?.reactions?.[0].emoji).toBe('🔥');
+
+    const fetchedWithReactions = await store.getComment(comment.id);
+    expect(fetchedWithReactions?.reactions).toHaveLength(1);
+
+    const unreactComment = await store.removeReaction(comment.id, { emoji: '🔥', userId: 'user_2' });
+    expect(unreactComment?.reactions).toHaveLength(0);
+
     const deletedComment = await store.deleteComment(reply.id);
     expect(deletedComment).toBe(true);
     expect(await store.getComments('task_1')).toHaveLength(1);

package/src/store/sqlite.ts

@@ -154,6 +154,7 @@ export class SQLiteStore implements StorageAdapter {
         authorType TEXT,
         parentId TEXT,
         content TEXT NOT NULL,
+        reactions TEXT,
         metadata TEXT,
         createdAt TEXT NOT NULL,
         updatedAt TEXT NOT NULL
@@ -212,6 +213,12 @@ export class SQLiteStore implements StorageAdapter {
         createdAt TEXT NOT NULL
       );
     `);
+
+    try {
+      this.db.exec('ALTER TABLE comments ADD COLUMN reactions TEXT');
+    } catch {
+      // Column may already exist
+    }
   }
 
   // --- Projects ---
@@ -682,23 +689,32 @@ export class SQLiteStore implements StorageAdapter {
   }
 
   // --- Comments ---
+  private mapComment(row: any): Comment {
+    return {
+      id: row.id,
+      taskId: row.taskId,
+      authorId: row.authorId,
+      authorType: row.authorType,
+      parentId: row.parentId || undefined,
+      content: row.content,
+      reactions: row.reactions ? JSON.parse(row.reactions) : undefined,
+      metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+
   async getComments(taskId: string): Promise<Comment[]> {
     const stmt = this.db.prepare('SELECT * FROM comments WHERE taskId = ? ORDER BY createdAt ASC');
     const rows = stmt.all(taskId) as any[];
-    return rows.map((r) => ({
-      ...r,
-      metadata: r.metadata ? JSON.parse(r.metadata) : undefined
-    }));
+    return rows.map((r) => this.mapComment(r));
   }
 
   async getComment(id: string): Promise<Comment | null> {
     const stmt = this.db.prepare('SELECT * FROM comments WHERE id = ?');
     const row = stmt.get(id) as any;
     if (!row) return null;
-    return {
-      ...row,
-      metadata: row.metadata ? JSON.parse(row.metadata) : undefined
-    };
+    return this.mapComment(row);
   }
 
   async addComment(comment: Omit<Comment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Comment> {
@@ -707,8 +723,8 @@ export class SQLiteStore implements StorageAdapter {
     const newComment: Comment = { ...comment, id, createdAt: now, updatedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO comments (id, taskId, authorId, authorType, parentId, content, metadata, createdAt, updatedAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO comments (id, taskId, authorId, authorType, parentId, content, reactions, metadata, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newComment.id,
@@ -717,6 +733,7 @@ export class SQLiteStore implements StorageAdapter {
       newComment.authorType || 'user',
       newComment.parentId || null,
       newComment.content,
+      newComment.reactions ? JSON.stringify(newComment.reactions) : null,
       newComment.metadata ? JSON.stringify(newComment.metadata) : null,
       newComment.createdAt,
       newComment.updatedAt
@@ -740,6 +757,7 @@ export class SQLiteStore implements StorageAdapter {
         authorType = ?,
         parentId = ?,
         content = ?,
+        reactions = ?,
         metadata = ?,
         updatedAt = ?
       WHERE id = ?
@@ -749,6 +767,7 @@ export class SQLiteStore implements StorageAdapter {
       updated.authorType || 'user',
       updated.parentId || null,
       updated.content,
+      updated.reactions ? JSON.stringify(updated.reactions) : null,
       updated.metadata ? JSON.stringify(updated.metadata) : null,
       updated.updatedAt,
       id
@@ -762,6 +781,30 @@ export class SQLiteStore implements StorageAdapter {
     return (result.changes ?? 0) > 0;
   }
 
+  async addReaction(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null> {
+    const existing = await this.getComment(commentId);
+    if (!existing) return null;
+    const reactions = existing.reactions ? [...existing.reactions] : [];
+    const alreadyExists = reactions.some((r) => r.emoji === reaction.emoji && r.userId === reaction.userId);
+    if (!alreadyExists) {
+      reactions.push({
+        emoji: reaction.emoji,
+        userId: reaction.userId,
+        createdAt: new Date().toISOString()
+      });
+    }
+    return this.updateComment(commentId, { reactions });
+  }
+
+  async removeReaction(commentId: string, reaction: { emoji: string; userId: string }): Promise<Comment | null> {
+    const existing = await this.getComment(commentId);
+    if (!existing) return null;
+    const reactions = (existing.reactions || []).filter(
+      (r) => !(r.emoji === reaction.emoji && r.userId === reaction.userId)
+    );
+    return this.updateComment(commentId, { reactions });
+  }
+
   // --- Attachments ---
   async getAttachments(filter?: { taskId?: string; projectId?: string; commentId?: string }): Promise<Attachment[]> {
     let sql = 'SELECT * FROM attachments';

package/src/types/index.ts

@@ -119,6 +119,14 @@ export interface TaskDependencyGraph {
   dependencies: TaskDependency[];
 }
 
+export interface TaskTodoItem {
+  id: string;
+  title: string;
+  completed: boolean;
+  createdAt?: string;
+  completedAt?: string;
+}
+
 export interface Task {
   id: string;
   projectId: string;
@@ -149,6 +157,7 @@ export interface Task {
   // Progress (0 to 100 percentage)
   progress?: number;
   tags?: string[];
+  todos?: TaskTodoItem[];
   customFields?: Record<string, unknown>;
   parentId?: string; // Subtask support
   createdAt: string;
@@ -176,6 +185,12 @@ export interface Iteration {
 
 export type AuthorType = 'user' | 'agent' | 'system';
 
+export interface CommentReaction {
+  emoji: string;
+  userId: string;
+  createdAt?: string;
+}
+
 export interface Comment {
   id: string;
   taskId: string;
@@ -183,6 +198,7 @@ export interface Comment {
   authorType?: AuthorType;
   parentId?: string; // Threaded reply support
   content: string;
+  reactions?: CommentReaction[];
   metadata?: Record<string, unknown>;
   createdAt: string;
   updatedAt: string;
@@ -282,6 +298,8 @@ export type WebhookEvent =
   | 'comment.created'
   | 'comment.updated'
   | 'comment.deleted'
+  | 'comment.reaction.added'
+  | 'comment.reaction.removed'
   | 'attachment.created'
   | 'attachment.deleted'
   | 'iteration.started'