@critical-path/core 0.6.0 → 0.8.0

package/src/store/firebase.ts

@@ -6,6 +6,7 @@ import type {
   Team,
   TaskContainer,
   Comment,
+  Attachment,
   TimeEntry,
   Activity,
   Webhook,
@@ -101,6 +102,22 @@ export interface FirebaseStoreConfig {
   db: FirestoreDBInterface;
 }
 
+export function sanitizeFirestoreData<T>(obj: T): T {
+  if (obj === null || typeof obj !== 'object') {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(sanitizeFirestoreData) as unknown as T;
+  }
+  const clean: Record<string, any> = {};
+  for (const [key, value] of Object.entries(obj as Record<string, any>)) {
+    if (value !== undefined) {
+      clean[key] = sanitizeFirestoreData(value);
+    }
+  }
+  return clean as T;
+}
+
 export class FirebaseStore implements StorageAdapter {
   private db: FirestoreDBInterface;
 
@@ -130,7 +147,7 @@ export class FirebaseStore implements StorageAdapter {
     const now = new Date().toISOString();
     const key = project.key || generateProjectKey(project.name);
     const newProj: Project = { ...project, key, id: docRef.id, createdAt: now, updatedAt: now };
-    await docRef.set(newProj);
+    await docRef.set(sanitizeFirestoreData(newProj));
     return newProj;
   }
 
@@ -143,7 +160,7 @@ export class FirebaseStore implements StorageAdapter {
       ...updates,
       updatedAt: new Date().toISOString()
     };
-    await this.db.collection('projects').doc(id).set(updated, { merge: true });
+    await this.db.collection('projects').doc(id).set(sanitizeFirestoreData(updated), { merge: true });
     return updated;
   }
 
@@ -170,7 +187,7 @@ export class FirebaseStore implements StorageAdapter {
     const docRef = this.db.collection('workflows').doc();
     const now = new Date().toISOString();
     const newWf: Workflow = { ...workflow, id: docRef.id, createdAt: now, updatedAt: now };
-    await docRef.set(newWf);
+    await docRef.set(sanitizeFirestoreData(newWf));
     return newWf;
   }
 
@@ -183,7 +200,7 @@ export class FirebaseStore implements StorageAdapter {
       ...updates,
       updatedAt: new Date().toISOString()
     };
-    await this.db.collection('workflows').doc(id).set(updated, { merge: true });
+    await this.db.collection('workflows').doc(id).set(sanitizeFirestoreData(updated), { merge: true });
     return updated;
   }
 
@@ -210,7 +227,7 @@ export class FirebaseStore implements StorageAdapter {
     const docRef = this.db.collection('teams').doc();
     const now = new Date().toISOString();
     const newTeam: Team = { ...team, id: docRef.id, createdAt: now, updatedAt: now };
-    await docRef.set(newTeam);
+    await docRef.set(sanitizeFirestoreData(newTeam));
     return newTeam;
   }
 
@@ -219,7 +236,7 @@ export class FirebaseStore implements StorageAdapter {
     if (!existing) return null;
 
     const updated: Team = { ...existing, ...updates, updatedAt: new Date().toISOString() };
-    await this.db.collection('teams').doc(id).set(updated, { merge: true });
+    await this.db.collection('teams').doc(id).set(sanitizeFirestoreData(updated), { merge: true });
     return updated;
   }
 
@@ -246,7 +263,7 @@ export class FirebaseStore implements StorageAdapter {
     const docRef = this.db.collection('containers').doc();
     const now = new Date().toISOString();
     const newContainer: TaskContainer = { ...container, id: docRef.id, createdAt: now, updatedAt: now };
-    await docRef.set(newContainer);
+    await docRef.set(sanitizeFirestoreData(newContainer));
     return newContainer;
   }
 
@@ -255,7 +272,7 @@ export class FirebaseStore implements StorageAdapter {
     if (!existing) return null;
 
     const updated: TaskContainer = { ...existing, ...updates, updatedAt: new Date().toISOString() };
-    await this.db.collection('containers').doc(id).set(updated, { merge: true });
+    await this.db.collection('containers').doc(id).set(sanitizeFirestoreData(updated), { merge: true });
     return updated;
   }
 
@@ -287,7 +304,7 @@ export class FirebaseStore implements StorageAdapter {
     const docRef = this.db.collection('tasks').doc();
     const now = new Date().toISOString();
     const newTask: Task = { ...task, id: docRef.id, createdAt: now, updatedAt: now };
-    await docRef.set(newTask);
+    await docRef.set(sanitizeFirestoreData(newTask));
     return newTask;
   }
 
@@ -300,7 +317,7 @@ export class FirebaseStore implements StorageAdapter {
       ...updates,
       updatedAt: new Date().toISOString()
     };
-    await this.db.collection('tasks').doc(id).set(updated, { merge: true });
+    await this.db.collection('tasks').doc(id).set(sanitizeFirestoreData(updated), { merge: true });
     return updated;
   }
 
@@ -327,7 +344,7 @@ export class FirebaseStore implements StorageAdapter {
     const docRef = this.db.collection('iterations').doc();
     const now = new Date().toISOString();
     const newIteration: Iteration = { ...iteration, id: docRef.id, createdAt: now };
-    await docRef.set(newIteration);
+    await docRef.set(sanitizeFirestoreData(newIteration));
     return newIteration;
   }
 
@@ -336,7 +353,7 @@ export class FirebaseStore implements StorageAdapter {
     if (!snap.exists) return null;
 
     const updated: Iteration = { ...snap.data(), id, ...updates };
-    await this.db.collection('iterations').doc(id).set(updated, { merge: true });
+    await this.db.collection('iterations').doc(id).set(sanitizeFirestoreData(updated), { merge: true });
     return updated;
   }
 
@@ -347,20 +364,82 @@ export class FirebaseStore implements StorageAdapter {
     return true;
   }
 
-  // --- Comments & Activity ---
+  // --- Comments ---
   async getComments(taskId: string): Promise<Comment[]> {
     const snap = await this.db.collection('comments').where('taskId', '==', taskId).get();
     return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
   }
 
+  async getComment(id: string): Promise<Comment | null> {
+    const snap = await this.db.collection('comments').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
   async addComment(comment: Omit<Comment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Comment> {
     const docRef = this.db.collection('comments').doc();
     const now = new Date().toISOString();
     const newComment: Comment = { ...comment, id: docRef.id, createdAt: now, updatedAt: now };
-    await docRef.set(newComment);
+    await docRef.set(sanitizeFirestoreData(newComment));
     return newComment;
   }
 
+  async updateComment(id: string, updates: Partial<Comment>): Promise<Comment | null> {
+    const existing = await this.getComment(id);
+    if (!existing) return null;
+
+    const updated: Comment = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+    await this.db.collection('comments').doc(id).set(sanitizeFirestoreData(updated), { merge: true });
+    return updated;
+  }
+
+  async deleteComment(id: string): Promise<boolean> {
+    const existing = await this.getComment(id);
+    if (!existing) return false;
+    await this.db.collection('comments').doc(id).delete();
+    return true;
+  }
+
+  // --- Attachments ---
+  async getAttachments(filter?: { taskId?: string; projectId?: string; commentId?: string }): Promise<Attachment[]> {
+    let snap;
+    if (filter?.taskId) {
+      snap = await this.db.collection('attachments').where('taskId', '==', filter.taskId).get();
+    } else if (filter?.projectId) {
+      snap = await this.db.collection('attachments').where('projectId', '==', filter.projectId).get();
+    } else if (filter?.commentId) {
+      snap = await this.db.collection('attachments').where('commentId', '==', filter.commentId).get();
+    } else {
+      snap = await this.db.collection('attachments').get();
+    }
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getAttachment(id: string): Promise<Attachment | null> {
+    const snap = await this.db.collection('attachments').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createAttachment(attachment: Omit<Attachment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Attachment> {
+    const docRef = this.db.collection('attachments').doc();
+    const now = new Date().toISOString();
+    const newAtt: Attachment = { ...attachment, id: docRef.id, createdAt: now, updatedAt: now };
+    await docRef.set(sanitizeFirestoreData(newAtt));
+    return newAtt;
+  }
+
+  async deleteAttachment(id: string): Promise<boolean> {
+    const existing = await this.getAttachment(id);
+    if (!existing) return false;
+    await this.db.collection('attachments').doc(id).delete();
+    return true;
+  }
+
   async getActivities(filter?: { projectId?: string; taskId?: string }): Promise<Activity[]> {
     let snap;
     if (filter?.taskId) {
@@ -377,7 +456,7 @@ export class FirebaseStore implements StorageAdapter {
     const docRef = this.db.collection('activities').doc();
     const now = new Date().toISOString();
     const newAct: Activity = { ...activity, id: docRef.id, createdAt: now };
-    await docRef.set(newAct);
+    await docRef.set(sanitizeFirestoreData(newAct));
     return newAct;
   }
 
@@ -391,7 +470,7 @@ export class FirebaseStore implements StorageAdapter {
     const docRef = this.db.collection('time_entries').doc();
     const now = new Date().toISOString();
     const newEntry: TimeEntry = { ...entry, id: docRef.id, loggedAt: now };
-    await docRef.set(newEntry);
+    await docRef.set(sanitizeFirestoreData(newEntry));
     return newEntry;
   }
 
@@ -404,7 +483,7 @@ export class FirebaseStore implements StorageAdapter {
   async addDependency(dep: Omit<TaskDependency, 'id'>): Promise<TaskDependency> {
     const docRef = this.db.collection('dependencies').doc();
     const newDep: TaskDependency = { ...dep, id: docRef.id };
-    await docRef.set(newDep);
+    await docRef.set(sanitizeFirestoreData(newDep));
     return newDep;
   }
 
@@ -418,7 +497,7 @@ export class FirebaseStore implements StorageAdapter {
     const docRef = this.db.collection('webhooks').doc();
     const now = new Date().toISOString();
     const newWh: Webhook = { ...webhook, id: docRef.id, createdAt: now };
-    await docRef.set(newWh);
+    await docRef.set(sanitizeFirestoreData(newWh));
     return newWh;
   }
 }

package/src/store/index.ts

@@ -8,6 +8,7 @@ import type {
   Team,
   TaskContainer,
   Comment,
+  Attachment,
   TimeEntry,
   Activity,
   Webhook,
@@ -66,7 +67,17 @@ export interface IterationRepository {
 
 export interface CommentRepository {
   getComments(taskId: string): Promise<Comment[]>;
+  getComment(id: string): Promise<Comment | null>;
   addComment(comment: Omit<Comment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Comment>;
+  updateComment(id: string, updates: Partial<Comment>): Promise<Comment | null>;
+  deleteComment(id: string): Promise<boolean>;
+}
+
+export interface AttachmentRepository {
+  getAttachments(filter?: { taskId?: string; projectId?: string; commentId?: string }): Promise<Attachment[]>;
+  getAttachment(id: string): Promise<Attachment | null>;
+  createAttachment(attachment: Omit<Attachment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Attachment>;
+  deleteAttachment(id: string): Promise<boolean>;
 }
 
 export interface ActivityRepository {
@@ -97,6 +108,7 @@ export interface StorageAdapter
     ContainerRepository,
     IterationRepository,
     CommentRepository,
+    AttachmentRepository,
     ActivityRepository,
     TimeEntryRepository,
     DependencyRepository,
@@ -110,6 +122,7 @@ export class InMemoryStore implements StorageAdapter {
   private containers = new Map<string, TaskContainer>();
   private iterations = new Map<string, Iteration>();
   private comments = new Map<string, Comment>();
+  private attachments = new Map<string, Attachment>();
   private activities: Activity[] = [];
   private timeEntries = new Map<string, TimeEntry>();
   private dependencies = new Map<string, TaskDependency>();
@@ -328,6 +341,10 @@ export class InMemoryStore implements StorageAdapter {
     return Array.from(this.comments.values()).filter((c) => c.taskId === taskId);
   }
 
+  async getComment(id: string): Promise<Comment | null> {
+    return this.comments.get(id) || null;
+  }
+
   async addComment(comment: Omit<Comment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Comment> {
     const id = `cmt_${Math.random().toString(36).substring(2, 9)}`;
     const now = new Date().toISOString();
@@ -336,6 +353,53 @@ export class InMemoryStore implements StorageAdapter {
     return newComment;
   }
 
+  async updateComment(id: string, updates: Partial<Comment>): Promise<Comment | null> {
+    const existing = this.comments.get(id);
+    if (!existing) return null;
+    const updated: Comment = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+    this.comments.set(id, updated);
+    return updated;
+  }
+
+  async deleteComment(id: string): Promise<boolean> {
+    return this.comments.delete(id);
+  }
+
+  // Attachments
+  async getAttachments(filter?: { taskId?: string; projectId?: string; commentId?: string }): Promise<Attachment[]> {
+    return Array.from(this.attachments.values()).filter((a) => {
+      if (filter?.taskId && a.taskId !== filter.taskId) return false;
+      if (filter?.projectId && a.projectId !== filter.projectId) return false;
+      if (filter?.commentId && a.commentId !== filter.commentId) return false;
+      return true;
+    });
+  }
+
+  async getAttachment(id: string): Promise<Attachment | null> {
+    return this.attachments.get(id) || null;
+  }
+
+  async createAttachment(attachment: Omit<Attachment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Attachment> {
+    const id = `att_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newAttachment: Attachment = {
+      ...attachment,
+      id,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.attachments.set(id, newAttachment);
+    return newAttachment;
+  }
+
+  async deleteAttachment(id: string): Promise<boolean> {
+    return this.attachments.delete(id);
+  }
+
   // Activities
   async getActivities(filter?: { projectId?: string; taskId?: string }): Promise<Activity[]> {
     return this.activities.filter((a) => {

package/src/store/sqlite.test.ts

@@ -57,12 +57,31 @@ describe('SQLiteStore', () => {
     const comment = await store.addComment({
       taskId: 'task_1',
       authorId: 'user_1',
+      authorType: 'user',
       content: 'Great work!'
     });
     expect(comment.id).toMatch(/^cmt_/);
+    expect(comment.authorType).toBe('user');
+
+    // Threaded reply
+    const reply = await store.addComment({
+      taskId: 'task_1',
+      authorId: 'agent_1',
+      authorType: 'agent',
+      parentId: comment.id,
+      content: 'I agree!'
+    });
+    expect(reply.parentId).toBe(comment.id);
+    expect(reply.authorType).toBe('agent');
 
     const comments = await store.getComments('task_1');
-    expect(comments).toHaveLength(1);
+    expect(comments).toHaveLength(2);
+
+    const updatedComment = await store.updateComment(comment.id, { content: 'Updated content' });
+    expect(updatedComment?.content).toBe('Updated content');
+
+    const fetchedComment = await store.getComment(comment.id);
+    expect(fetchedComment?.content).toBe('Updated content');
 
     const timeEntry = await store.logTime({
       taskId: 'task_1',
@@ -74,6 +93,45 @@ describe('SQLiteStore', () => {
 
     const entries = await store.getTimeEntries('task_1');
     expect(entries).toHaveLength(1);
+
+    const deletedComment = await store.deleteComment(reply.id);
+    expect(deletedComment).toBe(true);
+    expect(await store.getComments('task_1')).toHaveLength(1);
+  });
+
+  it('should create, filter, retrieve, and delete attachments', async () => {
+    const attachment = await store.createAttachment({
+      filename: 'design-mockup.fig',
+      url: 'https://storage.example.com/design-mockup.fig',
+      storageKey: 'attachments/task_1/design-mockup.fig',
+      mimeType: 'application/octet-stream',
+      sizeBytes: 2048,
+      taskId: 'task_1',
+      projectId: 'proj_1',
+      uploaderId: 'user_1',
+      uploaderType: 'user'
+    });
+
+    expect(attachment.id).toMatch(/^att_/);
+    expect(attachment.filename).toBe('design-mockup.fig');
+
+    const fetched = await store.getAttachment(attachment.id);
+    expect(fetched?.url).toBe('https://storage.example.com/design-mockup.fig');
+
+    const taskAttachments = await store.getAttachments({ taskId: 'task_1' });
+    expect(taskAttachments).toHaveLength(1);
+
+    const projectAttachments = await store.getAttachments({ projectId: 'proj_1' });
+    expect(projectAttachments).toHaveLength(1);
+
+    const nonExistent = await store.getAttachments({ taskId: 'other_task' });
+    expect(nonExistent).toHaveLength(0);
+
+    const deleted = await store.deleteAttachment(attachment.id);
+    expect(deleted).toBe(true);
+
+    const remaining = await store.getAttachments({ taskId: 'task_1' });
+    expect(remaining).toHaveLength(0);
   });
 
   it('should create, retrieve, update, and delete workflows', async () => {

package/src/store/sqlite.ts

@@ -7,6 +7,7 @@ import type {
   Team,
   TaskContainer,
   Comment,
+  Attachment,
   TimeEntry,
   Activity,
   Webhook,
@@ -150,7 +151,27 @@ export class SQLiteStore implements StorageAdapter {
         id TEXT PRIMARY KEY,
         taskId TEXT NOT NULL,
         authorId TEXT NOT NULL,
+        authorType TEXT,
+        parentId TEXT,
         content TEXT NOT NULL,
+        metadata TEXT,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS attachments (
+        id TEXT PRIMARY KEY,
+        taskId TEXT,
+        projectId TEXT,
+        commentId TEXT,
+        uploaderId TEXT NOT NULL,
+        uploaderType TEXT,
+        filename TEXT NOT NULL,
+        mimeType TEXT NOT NULL,
+        sizeBytes INTEGER NOT NULL,
+        url TEXT NOT NULL,
+        storageKey TEXT,
+        metadata TEXT,
         createdAt TEXT NOT NULL,
         updatedAt TEXT NOT NULL
       );
@@ -660,10 +681,24 @@ export class SQLiteStore implements StorageAdapter {
     return (result.changes ?? 0) > 0;
   }
 
-  // --- Comments & Activity ---
+  // --- Comments ---
   async getComments(taskId: string): Promise<Comment[]> {
-    const stmt = this.db.prepare('SELECT * FROM comments WHERE taskId = ?');
-    return stmt.all(taskId) as any[];
+    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
+    }));
+  }
+
+  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
+    };
   }
 
   async addComment(comment: Omit<Comment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Comment> {
@@ -672,13 +707,144 @@ 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, content, createdAt, updatedAt)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO comments (id, taskId, authorId, authorType, parentId, content, metadata, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-    stmt.run(newComment.id, newComment.taskId, newComment.authorId, newComment.content, newComment.createdAt, newComment.updatedAt);
+    stmt.run(
+      newComment.id,
+      newComment.taskId,
+      newComment.authorId,
+      newComment.authorType || 'user',
+      newComment.parentId || null,
+      newComment.content,
+      newComment.metadata ? JSON.stringify(newComment.metadata) : null,
+      newComment.createdAt,
+      newComment.updatedAt
+    );
     return newComment;
   }
 
+  async updateComment(id: string, updates: Partial<Comment>): Promise<Comment | null> {
+    const existing = await this.getComment(id);
+    if (!existing) return null;
+
+    const updated: Comment = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+
+    const stmt = this.db.prepare(`
+      UPDATE comments SET
+        authorId = ?,
+        authorType = ?,
+        parentId = ?,
+        content = ?,
+        metadata = ?,
+        updatedAt = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      updated.authorId,
+      updated.authorType || 'user',
+      updated.parentId || null,
+      updated.content,
+      updated.metadata ? JSON.stringify(updated.metadata) : null,
+      updated.updatedAt,
+      id
+    );
+    return updated;
+  }
+
+  async deleteComment(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM comments WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
+  // --- Attachments ---
+  async getAttachments(filter?: { taskId?: string; projectId?: string; commentId?: string }): Promise<Attachment[]> {
+    let sql = 'SELECT * FROM attachments';
+    const params: any[] = [];
+    const conditions: string[] = [];
+
+    if (filter?.taskId) {
+      conditions.push('taskId = ?');
+      params.push(filter.taskId);
+    }
+    if (filter?.projectId) {
+      conditions.push('projectId = ?');
+      params.push(filter.projectId);
+    }
+    if (filter?.commentId) {
+      conditions.push('commentId = ?');
+      params.push(filter.commentId);
+    }
+
+    if (conditions.length > 0) {
+      sql += ' WHERE ' + conditions.join(' AND ');
+    }
+    sql += ' ORDER BY createdAt DESC';
+
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...params) as any[];
+    return rows.map((r) => ({
+      ...r,
+      sizeBytes: Number(r.sizeBytes),
+      metadata: r.metadata ? JSON.parse(r.metadata) : undefined
+    }));
+  }
+
+  async getAttachment(id: string): Promise<Attachment | null> {
+    const stmt = this.db.prepare('SELECT * FROM attachments WHERE id = ?');
+    const row = stmt.get(id) as any;
+    if (!row) return null;
+    return {
+      ...row,
+      sizeBytes: Number(row.sizeBytes),
+      metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+    };
+  }
+
+  async createAttachment(attachment: Omit<Attachment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Attachment> {
+    const id = `att_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newAtt: Attachment = {
+      ...attachment,
+      id,
+      createdAt: now,
+      updatedAt: now
+    };
+
+    const stmt = this.db.prepare(`
+      INSERT INTO attachments (id, taskId, projectId, commentId, uploaderId, uploaderType, filename, mimeType, sizeBytes, url, storageKey, metadata, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      newAtt.id,
+      newAtt.taskId || null,
+      newAtt.projectId || null,
+      newAtt.commentId || null,
+      newAtt.uploaderId,
+      newAtt.uploaderType || 'user',
+      newAtt.filename,
+      newAtt.mimeType,
+      newAtt.sizeBytes,
+      newAtt.url,
+      newAtt.storageKey || null,
+      newAtt.metadata ? JSON.stringify(newAtt.metadata) : null,
+      newAtt.createdAt,
+      newAtt.updatedAt
+    );
+    return newAtt;
+  }
+
+  async deleteAttachment(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM attachments WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
   async getActivities(filter?: { projectId?: string; taskId?: string }): Promise<Activity[]> {
     let sql = 'SELECT * FROM activities';
     const params: any[] = [];