@critical-path/core 0.5.2 → 0.7.0

package/src/store/index.ts

@@ -8,6 +8,7 @@ import type {
   Team,
   TaskContainer,
   Comment,
+  Attachment,
   TimeEntry,
   Activity,
   Webhook,
@@ -16,68 +17,103 @@ import type {
 } from '../types/index.js';
 import { generateProjectKey } from '../utils/key.js';
 
-export interface StorageAdapter {
-  // Projects
+export interface ProjectRepository {
   getProjects(): Promise<Project[]>;
   getProject(id: string): Promise<Project | null>;
   createProject(project: Omit<Project, 'id' | 'createdAt' | 'updatedAt'>): Promise<Project>;
   updateProject(id: string, updates: Partial<Project>): Promise<Project | null>;
   deleteProject(id: string): Promise<boolean>;
+}
 
-  // Workflows
+export interface WorkflowRepository {
   getWorkflows(): Promise<Workflow[]>;
   getWorkflow(id: string): Promise<Workflow | null>;
   createWorkflow(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow>;
   updateWorkflow(id: string, updates: Partial<Workflow>): Promise<Workflow | null>;
   deleteWorkflow(id: string): Promise<boolean>;
+}
 
-  // Tasks
+export interface TaskRepository {
   getTasks(projectId?: string): Promise<Task[]>;
   getTask(id: string): Promise<Task | null>;
   createTask(task: Omit<Task, 'id' | 'createdAt' | 'updatedAt'>): Promise<Task>;
   updateTask(id: string, updates: Partial<Task>): Promise<Task | null>;
   deleteTask(id: string): Promise<boolean>;
+}
 
-  // Teams
+export interface TeamRepository {
   getTeams(): Promise<Team[]>;
   getTeam(id: string): Promise<Team | null>;
   createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team>;
   updateTeam(id: string, updates: Partial<Team>): Promise<Team | null>;
   deleteTeam(id: string): Promise<boolean>;
+}
 
-  // Task Containers
+export interface ContainerRepository {
   getContainers(projectId: string): Promise<TaskContainer[]>;
   getContainer(id: string): Promise<TaskContainer | null>;
   createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer>;
   updateContainer(id: string, updates: Partial<TaskContainer>): Promise<TaskContainer | null>;
   deleteContainer(id: string): Promise<boolean>;
+}
 
-  // Iterations
+export interface IterationRepository {
   getIterations(projectId: string): Promise<Iteration[]>;
   getIteration(id: string): Promise<Iteration | null>;
   createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration>;
   updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null>;
   deleteIteration(id: string): Promise<boolean>;
+}
 
-  // Comments & Activity
+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 {
   getActivities(filter?: { projectId?: string; taskId?: string }): Promise<Activity[]>;
   logActivity(activity: Omit<Activity, 'id' | 'createdAt'>): Promise<Activity>;
+}
 
-  // Time Tracking
+export interface TimeEntryRepository {
   getTimeEntries(taskId: string): Promise<TimeEntry[]>;
   logTime(entry: Omit<TimeEntry, 'id' | 'loggedAt'>): Promise<TimeEntry>;
+}
 
-  // Dependencies
+export interface DependencyRepository {
   getDependencies(taskId: string): Promise<TaskDependency[]>;
   addDependency(dep: Omit<TaskDependency, 'id'>): Promise<TaskDependency>;
+}
 
-  // Webhooks
+export interface WebhookRepository {
   getWebhooks(): Promise<Webhook[]>;
   addWebhook(webhook: Omit<Webhook, 'id' | 'createdAt'>): Promise<Webhook>;
 }
 
+export interface StorageAdapter
+  extends ProjectRepository,
+    WorkflowRepository,
+    TaskRepository,
+    TeamRepository,
+    ContainerRepository,
+    IterationRepository,
+    CommentRepository,
+    AttachmentRepository,
+    ActivityRepository,
+    TimeEntryRepository,
+    DependencyRepository,
+    WebhookRepository {}
+
 export class InMemoryStore implements StorageAdapter {
   private projects = new Map<string, Project>();
   private workflows = new Map<string, Workflow>();
@@ -86,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>();
@@ -304,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();
@@ -312,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[] = [];

package/src/types/index.ts

@@ -155,6 +155,13 @@ export interface Task {
   updatedAt: string;
 }
 
+export type CreateTaskInput = Omit<Task, 'id' | 'createdAt' | 'updatedAt' | 'status' | 'priority'> & {
+  status?: TaskStatus;
+  priority?: Priority;
+};
+
+export type CreateProjectInput = Omit<Project, 'id' | 'createdAt' | 'updatedAt'>;
+
 export interface Iteration {
   id: string;
   projectId: string;
@@ -167,15 +174,73 @@ export interface Iteration {
   createdAt: string;
 }
 
+export type AuthorType = 'user' | 'agent' | 'system';
+
 export interface Comment {
   id: string;
   taskId: string;
   authorId: string;
+  authorType?: AuthorType;
+  parentId?: string; // Threaded reply support
   content: string;
+  metadata?: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface Attachment {
+  id: string;
+  taskId?: string;
+  projectId?: string;
+  commentId?: string;
+  uploaderId: string;
+  uploaderType?: AuthorType;
+  filename: string;
+  mimeType: string;
+  sizeBytes: number;
+  url: string;
+  storageKey?: string;
+  metadata?: Record<string, unknown>;
   createdAt: string;
   updatedAt: string;
 }
 
+export type CreateAttachmentInput = Omit<Attachment, 'id' | 'createdAt' | 'updatedAt'>;
+
+export interface UploadFileInput {
+  filename: string;
+  data: Uint8Array | ArrayBuffer | Buffer | Blob | string;
+  mimeType?: string;
+  pathPrefix?: string;
+}
+
+export interface UploadFileResult {
+  storageKey: string;
+  url: string;
+  sizeBytes: number;
+  mimeType: string;
+}
+
+export interface PresignedUrlOptions {
+  storageKey: string;
+  expiresInSeconds?: number;
+  contentType?: string;
+}
+
+export interface PresignedUploadResult {
+  uploadUrl: string;
+  storageKey: string;
+  method?: 'PUT' | 'POST';
+  headers?: Record<string, string>;
+}
+
+export interface FileStorageAdapter {
+  upload(input: UploadFileInput): Promise<UploadFileResult>;
+  delete(storageKey: string): Promise<boolean>;
+  getDownloadUrl?(storageKey: string): Promise<string>;
+  getPresignedUploadUrl?(options: PresignedUrlOptions): Promise<PresignedUploadResult>;
+}
+
 export interface TimeEntry {
   id: string;
   taskId: string;
@@ -214,6 +279,10 @@ export type WebhookEvent =
   | 'task.deleted'
   | 'task.status_changed'
   | 'comment.created'
+  | 'comment.updated'
+  | 'comment.deleted'
+  | 'attachment.created'
+  | 'attachment.deleted'
   | 'iteration.started'
   | 'iteration.completed'
   | 'team.created'
@@ -243,6 +312,7 @@ export interface CriticalPathPlugin {
 
 export interface CriticalPathConfig {
   store?: 'memory' | 'sqlite' | unknown;
+  fileStorage?: FileStorageAdapter;
   plugins?: CriticalPathPlugin[];
   webhooks?: Omit<Webhook, 'id' | 'createdAt'>[];
   initialData?: {

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/index.test.ts","./src/index.ts","./src/use-case-validation.test.ts","./src/engine/index.ts","./src/plugins/index.ts","./src/store/firebase.test.ts","./src/store/firebase.ts","./src/store/index.ts","./src/store/sqlite.test.ts","./src/store/sqlite.ts","./src/types/index.ts","./src/utils/index.ts","./src/utils/key.test.ts","./src/utils/key.ts","./src/utils/status.ts","./src/utils/workflow.ts"],"version":"5.9.3"}
+{"root":["./src/index.test.ts","./src/index.ts","./src/use-case-validation.test.ts","./src/domain/custom-fields.ts","./src/domain/ddd.test.ts","./src/domain/entities.ts","./src/domain/events.ts","./src/domain/graph.ts","./src/domain/index.ts","./src/engine/index.ts","./src/plugins/index.ts","./src/storage/file-storage.ts","./src/storage/firebase-storage.ts","./src/storage/index.ts","./src/storage/s3.ts","./src/storage/storage.test.ts","./src/store/firebase.test.ts","./src/store/firebase.ts","./src/store/index.ts","./src/store/sqlite.test.ts","./src/store/sqlite.ts","./src/types/index.ts","./src/utils/index.ts","./src/utils/key.test.ts","./src/utils/key.ts","./src/utils/status.ts","./src/utils/workflow.ts"],"version":"5.9.3"}