@critical-path/core 0.11.0 → 0.13.0

package/src/domain/events.ts

@@ -9,14 +9,15 @@ import type {
   TimeEntry,
   Comment,
   CommentReaction,
-  Attachment
+  Attachment,
+  Deliverable
 } from '../types/index.js';
 
 export interface DomainEvent<TPayload = Record<string, unknown>> {
   readonly id: string;
   readonly name: string;
   readonly aggregateId: string;
-  readonly aggregateType: 'Task' | 'Project' | 'Workflow' | 'Iteration' | 'Team' | 'Container' | 'Dependency' | 'Comment' | 'Attachment';
+  readonly aggregateType: 'Task' | 'Project' | 'Workflow' | 'Iteration' | 'Team' | 'Container' | 'Dependency' | 'Comment' | 'Attachment' | 'Deliverable';
   readonly occurredAt: string;
   readonly payload: TPayload;
 }
@@ -136,6 +137,26 @@ export interface ContainerCreatedEvent extends DomainEvent<{ container: TaskCont
   readonly aggregateType: 'Container';
 }
 
+export interface DeliverableCreatedEvent extends DomainEvent<{ deliverable: Deliverable }> {
+  readonly name: 'deliverable.created';
+  readonly aggregateType: 'Deliverable';
+}
+
+export interface DeliverableUpdatedEvent extends DomainEvent<{ deliverable: Deliverable; previous: Deliverable }> {
+  readonly name: 'deliverable.updated';
+  readonly aggregateType: 'Deliverable';
+}
+
+export interface DeliverableStatusChangedEvent extends DomainEvent<{ deliverable: Deliverable; previousStatus: string; newStatus: string }> {
+  readonly name: 'deliverable.status_changed';
+  readonly aggregateType: 'Deliverable';
+}
+
+export interface DeliverableDeletedEvent extends DomainEvent<{ deliverableId: string; projectId: string }> {
+  readonly name: 'deliverable.deleted';
+  readonly aggregateType: 'Deliverable';
+}
+
 export type CriticalPathDomainEvent =
   | TaskCreatedEvent
   | TaskUpdatedEvent
@@ -158,7 +179,11 @@ export type CriticalPathDomainEvent =
   | IterationStartedEvent
   | IterationCompletedEvent
   | TeamCreatedEvent
-  | ContainerCreatedEvent;
+  | ContainerCreatedEvent
+  | DeliverableCreatedEvent
+  | DeliverableUpdatedEvent
+  | DeliverableStatusChangedEvent
+  | DeliverableDeletedEvent;
 
 export type DomainEventHandler<T extends DomainEvent = DomainEvent> = (event: T) => Promise<void> | void;
 

package/src/engine/index.ts

@@ -17,7 +17,10 @@ import type {
   WebhookEvent,
   Workflow,
   CreateTaskInput,
-  CreateProjectInput
+  CreateProjectInput,
+  Deliverable,
+  DeliverableSummary,
+  CreateDeliverableInput
 } from '../types/index.js';
 import { StorageAdapter, InMemoryStore } from '../store/index.js';
 import { PluginRegistry } from '../plugins/index.js';
@@ -25,6 +28,7 @@ import { deriveTaskLifecycleState, type TaskLifecycleState, resolveStatusDefinit
 import {
   validateTransition,
   getAllowedNextStatuses,
+  getAllowedPreviousStatuses,
   WorkflowValidationError,
   DEFAULT_SOFTWARE_WORKFLOW
 } from '../utils/workflow.js';
@@ -44,6 +48,10 @@ import {
   IterationCompletedEvent,
   TeamCreatedEvent,
   ContainerCreatedEvent,
+  DeliverableCreatedEvent,
+  DeliverableUpdatedEvent,
+  DeliverableStatusChangedEvent,
+  DeliverableDeletedEvent,
   TaskDependencyAddedEvent,
   TimeLoggedEvent,
   CommentAddedEvent,
@@ -63,6 +71,7 @@ export class CriticalPathEngine {
   public readonly fileStorage?: FileStorageAdapter;
   public readonly plugins: PluginRegistry;
   public readonly events: DomainEventBus;
+  public readonly ready: Promise<void> = Promise.resolve();
 
   constructor(config: CriticalPathConfig = {}) {
     this.store = typeof config.store === 'object' && config.store !== null
@@ -80,7 +89,7 @@ export class CriticalPathEngine {
     }
 
     if (config.initialData) {
-      this.seedInitialData(config.initialData);
+      this.ready = this.seedInitialData(config.initialData);
     }
   }
 
@@ -105,6 +114,11 @@ export class CriticalPathEngine {
         await this.store.createContainer(c);
       }
     }
+    if (data.deliverables) {
+      for (const d of data.deliverables) {
+        await this.store.createDeliverable(d);
+      }
+    }
     if (data.iterations) {
       for (const it of data.iterations) {
         await this.store.createIteration(it);
@@ -226,6 +240,13 @@ export class CriticalPathEngine {
     return getAllowedNextStatuses(workflow || undefined, task.status);
   }
 
+  async getAllowedPreviousTaskTransitions(taskId: string): Promise<string[]> {
+    const task = await this.store.getTask(taskId);
+    if (!task) return [];
+    const workflow = await this.resolveProjectWorkflow(task.projectId);
+    return getAllowedPreviousStatuses(workflow || undefined, task.status);
+  }
+
   // --- Projects ---
   async getProjects(): Promise<Project[]> {
     return this.store.getProjects();
@@ -327,11 +348,13 @@ export class CriticalPathEngine {
       priority: processedInput.priority || taskInput.priority || 'medium',
       taskType: processedInput.taskType || taskInput.taskType || 'task',
       assigneeId: processedInput.assigneeId ?? taskInput.assigneeId,
+      assignees: processedInput.assignees ?? taskInput.assignees,
       reporterId: processedInput.reporterId ?? taskInput.reporterId,
       reviewerId: processedInput.reviewerId ?? taskInput.reviewerId,
       iterationId: processedInput.iterationId ?? taskInput.iterationId,
       teamId: processedInput.teamId ?? taskInput.teamId,
       containerId: processedInput.containerId ?? taskInput.containerId,
+      deliverableId: processedInput.deliverableId ?? taskInput.deliverableId,
       plannedStartDate: processedInput.plannedStartDate ?? taskInput.plannedStartDate,
       actualStartDate,
       actualEndDate,
@@ -937,6 +960,178 @@ export class CriticalPathEngine {
     return this.store.deleteContainer(id);
   }
 
+  // --- Deliverables ---
+  async getDeliverables(projectId: string): Promise<Deliverable[]> {
+    return this.store.getDeliverables(projectId);
+  }
+
+  async getDeliverable(id: string): Promise<Deliverable | null> {
+    return this.store.getDeliverable(id);
+  }
+
+  async createDeliverable(input: CreateDeliverableInput): Promise<Deliverable> {
+    const project = await this.store.getProject(input.projectId);
+    if (project?.customFieldDefinitions && input.customFields) {
+      validateCustomFieldValues(project.customFieldDefinitions, input.customFields);
+    }
+
+    const created = await this.store.createDeliverable({
+      ...input,
+      status: input.status || 'planned',
+      outputUrls: input.outputUrls ?? [],
+      customFields: input.customFields ?? {}
+    });
+    const now = new Date().toISOString();
+
+    const event: DeliverableCreatedEvent = {
+      id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+      name: 'deliverable.created',
+      aggregateId: created.id,
+      aggregateType: 'Deliverable',
+      occurredAt: now,
+      payload: { deliverable: created }
+    };
+    await this.events.publish(event);
+
+    await this.store.logActivity({
+      projectId: created.projectId,
+      actorId: 'system',
+      action: 'deliverable.created',
+      details: { title: created.title, format: created.format }
+    });
+    this.dispatchWebhook('deliverable.created', { deliverable: created });
+    return created;
+  }
+
+  async updateDeliverable(id: string, updates: Partial<Deliverable>): Promise<Deliverable | null> {
+    const existing = await this.store.getDeliverable(id);
+    if (!existing) return null;
+
+    if (updates.status && updates.status === 'delivered' && !existing.deliveredAt && !updates.deliveredAt) {
+      updates.deliveredAt = new Date().toISOString();
+    }
+
+    const updated = await this.store.updateDeliverable(id, updates);
+    if (updated) {
+      const now = new Date().toISOString();
+
+      if (updates.status && updates.status !== existing.status) {
+        const statusEvent: DeliverableStatusChangedEvent = {
+          id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+          name: 'deliverable.status_changed',
+          aggregateId: updated.id,
+          aggregateType: 'Deliverable',
+          occurredAt: now,
+          payload: {
+            deliverable: updated,
+            previousStatus: existing.status,
+            newStatus: updated.status
+          }
+        };
+        await this.events.publish(statusEvent);
+        this.dispatchWebhook('deliverable.status_changed', {
+          deliverable: updated,
+          previousStatus: existing.status,
+          newStatus: updated.status
+        });
+      }
+
+      const updateEvent: DeliverableUpdatedEvent = {
+        id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+        name: 'deliverable.updated',
+        aggregateId: updated.id,
+        aggregateType: 'Deliverable',
+        occurredAt: now,
+        payload: { deliverable: updated, previous: existing }
+      };
+      await this.events.publish(updateEvent);
+
+      await this.store.logActivity({
+        projectId: updated.projectId,
+        actorId: 'system',
+        action: 'deliverable.updated',
+        details: { title: updated.title, status: updated.status }
+      });
+      this.dispatchWebhook('deliverable.updated', { deliverable: updated });
+    }
+    return updated;
+  }
+
+  async deleteDeliverable(id: string): Promise<boolean> {
+    const existing = await this.store.getDeliverable(id);
+    if (!existing) return false;
+
+    const deleted = await this.store.deleteDeliverable(id);
+    if (deleted) {
+      const now = new Date().toISOString();
+      const event: DeliverableDeletedEvent = {
+        id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+        name: 'deliverable.deleted',
+        aggregateId: id,
+        aggregateType: 'Deliverable',
+        occurredAt: now,
+        payload: { deliverableId: id, projectId: existing.projectId }
+      };
+      await this.events.publish(event);
+
+      await this.store.logActivity({
+        projectId: existing.projectId,
+        actorId: 'system',
+        action: 'deliverable.deleted',
+        details: { title: existing.title }
+      });
+      this.dispatchWebhook('deliverable.deleted', { deliverableId: id, projectId: existing.projectId });
+    }
+    return deleted;
+  }
+
+  async getDeliverableSummary(deliverableId: string): Promise<DeliverableSummary | null> {
+    const deliverable = await this.store.getDeliverable(deliverableId);
+    if (!deliverable) return null;
+
+    const project = await this.store.getProject(deliverable.projectId);
+    const workflow = await this.resolveProjectWorkflow(deliverable.projectId);
+    const allTasks = await this.store.getTasks(deliverable.projectId);
+    const tasks = allTasks.filter((t) => t.deliverableId === deliverableId);
+
+    const totalTasks = tasks.length;
+    let completedTasks = 0;
+    let activeTasks = 0;
+    let estimatedHours = 0;
+    let loggedHours = 0;
+    let totalProgress = 0;
+
+    for (const task of tasks) {
+      const statusDef = resolveStatusDefinition(task.status, project?.statusDefinitions || workflow?.statuses);
+      if (statusDef.completionState === 'done') {
+        completedTasks++;
+      } else if (statusDef.executionState === 'active') {
+        activeTasks++;
+      }
+
+      if (task.estimatedHours) estimatedHours += task.estimatedHours;
+      if (task.loggedHours) loggedHours += task.loggedHours;
+
+      if (typeof task.progress === 'number') {
+        totalProgress += task.progress;
+      } else {
+        totalProgress += statusDef.completionState === 'done' ? 100 : 0;
+      }
+    }
+
+    const progressPercentage = totalTasks > 0 ? Math.round(totalProgress / totalTasks) : 0;
+
+    return {
+      deliverable,
+      totalTasks,
+      completedTasks,
+      activeTasks,
+      progressPercentage,
+      estimatedHours,
+      loggedHours
+    };
+  }
+
   // --- Iterations ---
   async getIterations(projectId: string): Promise<Iteration[]> {
     return this.store.getIterations(projectId);

package/src/index.test.ts

@@ -339,6 +339,39 @@ describe('CriticalPathEngine Core Tests', () => {
     });
     expect(updated?.mentions).toEqual(['coordinator']);
   });
+
+  it('supports multi-assignees and backward status transitions', async () => {
+    const engine = new CriticalPathEngine();
+    const proj = await engine.createProject({ key: 'TRN', name: 'Transitions Project' });
+
+    // Task with multi-assignees
+    const task = await engine.createTask({
+      projectId: proj.id,
+      title: 'Multi-assignee Task',
+      status: 'in_progress',
+      assignees: [
+        { id: 'agent_1', name: 'Agent Alpha', role: 'Planner', type: 'agent' },
+        { id: 'user_1', name: 'Alice Developer', role: 'Developer', type: 'user', avatarUrl: 'https://example.com/alice.png' }
+      ]
+    });
+
+    expect(task.assignees).toHaveLength(2);
+    expect(task.assignees?.[0].type).toBe('agent');
+    expect(task.assignees?.[1].avatarUrl).toBe('https://example.com/alice.png');
+
+    // Backward transitions
+    const previousStatuses = await engine.getAllowedPreviousTaskTransitions(task.id);
+    expect(previousStatuses).toContain('todo');
+
+    // First status (backlog) should have no previous status
+    const backlogTask = await engine.createTask({
+      projectId: proj.id,
+      title: 'Backlog Task',
+      status: 'backlog'
+    });
+    const backlogPrev = await engine.getAllowedPreviousTaskTransitions(backlogTask.id);
+    expect(backlogPrev).toEqual([]);
+  });
 });
 
 

package/src/store/firebase.ts

@@ -11,7 +11,9 @@ import type {
   Activity,
   Webhook,
   TaskDependency,
-  Workflow
+  Workflow,
+  Deliverable,
+  CreateDeliverableInput
 } from '../types/index.js';
 import { generateProjectKey } from '../utils/key.js';
 
@@ -283,6 +285,50 @@ export class FirebaseStore implements StorageAdapter {
     return true;
   }
 
+  // --- Deliverables ---
+  async getDeliverables(projectId: string): Promise<Deliverable[]> {
+    const snap = await this.db.collection('deliverables').where('projectId', '==', projectId).get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getDeliverable(id: string): Promise<Deliverable | null> {
+    const snap = await this.db.collection('deliverables').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createDeliverable(deliverable: CreateDeliverableInput): Promise<Deliverable> {
+    const docRef = this.db.collection('deliverables').doc();
+    const now = new Date().toISOString();
+    const newDeliverable: Deliverable = {
+      ...deliverable,
+      id: docRef.id,
+      status: deliverable.status || 'planned',
+      outputUrls: deliverable.outputUrls ? [...deliverable.outputUrls] : [],
+      customFields: deliverable.customFields ? { ...deliverable.customFields } : {},
+      createdAt: now,
+      updatedAt: now
+    };
+    await docRef.set(sanitizeFirestoreData(newDeliverable));
+    return newDeliverable;
+  }
+
+  async updateDeliverable(id: string, updates: Partial<Deliverable>): Promise<Deliverable | null> {
+    const existing = await this.getDeliverable(id);
+    if (!existing) return null;
+
+    const updated: Deliverable = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    await this.db.collection('deliverables').doc(id).set(sanitizeFirestoreData(updated), { merge: true });
+    return updated;
+  }
+
+  async deleteDeliverable(id: string): Promise<boolean> {
+    const existing = await this.getDeliverable(id);
+    if (!existing) return false;
+    await this.db.collection('deliverables').doc(id).delete();
+    return true;
+  }
+
   // --- Tasks ---
   async getTasks(projectId?: string): Promise<Task[]> {
     let snap;

package/src/store/index.ts

@@ -13,7 +13,9 @@ import type {
   Activity,
   Webhook,
   TaskDependency,
-  Workflow
+  Workflow,
+  Deliverable,
+  CreateDeliverableInput
 } from '../types/index.js';
 import { generateProjectKey } from '../utils/key.js';
 
@@ -102,12 +104,21 @@ export interface WebhookRepository {
   addWebhook(webhook: Omit<Webhook, 'id' | 'createdAt'>): Promise<Webhook>;
 }
 
+export interface DeliverableRepository {
+  getDeliverables(projectId: string): Promise<Deliverable[]>;
+  getDeliverable(id: string): Promise<Deliverable | null>;
+  createDeliverable(deliverable: CreateDeliverableInput): Promise<Deliverable>;
+  updateDeliverable(id: string, updates: Partial<Deliverable>): Promise<Deliverable | null>;
+  deleteDeliverable(id: string): Promise<boolean>;
+}
+
 export interface StorageAdapter
   extends ProjectRepository,
     WorkflowRepository,
     TaskRepository,
     TeamRepository,
     ContainerRepository,
+    DeliverableRepository,
     IterationRepository,
     CommentRepository,
     AttachmentRepository,
@@ -122,6 +133,7 @@ export class InMemoryStore implements StorageAdapter {
   private tasks = new Map<string, Task>();
   private teams = new Map<string, Team>();
   private containers = new Map<string, TaskContainer>();
+  private deliverables = new Map<string, Deliverable>();
   private iterations = new Map<string, Iteration>();
   private comments = new Map<string, Comment>();
   private attachments = new Map<string, Attachment>();
@@ -306,6 +318,47 @@ export class InMemoryStore implements StorageAdapter {
     return this.containers.delete(id);
   }
 
+  // Deliverables
+  async getDeliverables(projectId: string): Promise<Deliverable[]> {
+    return Array.from(this.deliverables.values()).filter((d) => d.projectId === projectId);
+  }
+
+  async getDeliverable(id: string): Promise<Deliverable | null> {
+    return this.deliverables.get(id) || null;
+  }
+
+  async createDeliverable(deliverable: CreateDeliverableInput): Promise<Deliverable> {
+    const id = (deliverable as any).id || `deliv_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newDeliverable: Deliverable = {
+      ...deliverable,
+      id,
+      status: deliverable.status || 'planned',
+      outputUrls: deliverable.outputUrls ? [...deliverable.outputUrls] : [],
+      customFields: deliverable.customFields ? { ...deliverable.customFields } : {},
+      createdAt: now,
+      updatedAt: now
+    };
+    this.deliverables.set(id, newDeliverable);
+    return newDeliverable;
+  }
+
+  async updateDeliverable(id: string, updates: Partial<Deliverable>): Promise<Deliverable | null> {
+    const existing = this.deliverables.get(id);
+    if (!existing) return null;
+    const updated: Deliverable = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+    this.deliverables.set(id, updated);
+    return updated;
+  }
+
+  async deleteDeliverable(id: string): Promise<boolean> {
+    return this.deliverables.delete(id);
+  }
+
   // Iterations
   async getIterations(projectId: string): Promise<Iteration[]> {
     return Array.from(this.iterations.values()).filter((s) => s.projectId === projectId);