@critical-path/core 0.15.0 → 0.15.1

package/src/index.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { CriticalPathEngine, deriveTaskLifecycleState } from './index.js';
+import { CriticalPathEngine, deriveTaskLifecycleState, DEFAULT_VFX_WORKFLOW } from './index.js';
 import type { CriticalPathPlugin } from './types/index.js';
 
 describe('CriticalPathEngine Core Tests', () => {
@@ -372,6 +372,74 @@ describe('CriticalPathEngine Core Tests', () => {
     const backlogPrev = await engine.getAllowedPreviousTaskTransitions(backlogTask.id);
     expect(backlogPrev).toEqual([]);
   });
+
+  it('automatically unblocks downstream tasks and publishes task.unblocked event when upstream task completes', async () => {
+    const engine = new CriticalPathEngine();
+    const proj = await engine.createProject({ key: 'UNBLK', name: 'Auto-Unblock Project' });
+
+    const upstream = await engine.createTask({
+      projectId: proj.id,
+      title: 'Upstream Task',
+      status: 'in_progress'
+    });
+
+    const downstream = await engine.createTask({
+      projectId: proj.id,
+      title: 'Downstream Task',
+      status: 'blocked',
+      customFields: { isBlocked: true, blockedReason: 'Waiting on upstream' }
+    });
+
+    await engine.addDependency({
+      taskId: downstream.id,
+      dependsOnTaskId: upstream.id,
+      type: 'blocking'
+    });
+
+    const unblockedEvents: any[] = [];
+    engine.events.subscribe('task.unblocked', async (evt) => {
+      unblockedEvents.push(evt);
+    });
+
+    // Complete upstream task
+    const completedUpstream = await engine.updateTask(upstream.id, { status: 'done' });
+    expect(completedUpstream?.status).toBe('done');
+
+    // Downstream task should now be unblocked
+    expect(unblockedEvents).toHaveLength(1);
+    expect(unblockedEvents[0].payload.task.id).toBe(downstream.id);
+    expect(unblockedEvents[0].payload.upstreamTaskId).toBe(upstream.id);
+
+    const refreshedDownstream = await engine.getTask(downstream.id);
+    expect(refreshedDownstream?.status).toBe('todo');
+    expect(refreshedDownstream?.customFields?.isBlocked).toBe(false);
+  });
+
+  it('allows VFX workflow transitions from revision_requested to in_production', async () => {
+    const engine = new CriticalPathEngine();
+    const vfxWorkflow = await engine.createWorkflow(DEFAULT_VFX_WORKFLOW);
+    const proj = await engine.createProject({
+      key: 'VFX',
+      name: 'VFX Film Project',
+      workflowId: vfxWorkflow.id
+    });
+
+    const task = await engine.createTask({
+      projectId: proj.id,
+      title: 'Compositing Shot 010',
+      status: 'revision_requested'
+    });
+
+    const allowed = await engine.getAllowedTaskTransitions(task.id);
+    expect(allowed).toContain('in_production');
+    expect(allowed).toContain('internal_review');
+
+    const allowedPrevious = await engine.getAllowedPreviousTaskTransitions(task.id);
+    expect(allowedPrevious).toContain('in_production');
+
+    const updated = await engine.updateTask(task.id, { status: 'in_production' });
+    expect(updated?.status).toBe('in_production');
+  });
 });
 
 

package/src/store/firebase.test.ts

@@ -91,5 +91,21 @@ describe('FirebaseStore', () => {
     expect(doc?.name).toBe('Undefined Test');
     expect('description' in (doc as any)).toBe(false);
   });
+
+  it('should retrieve dependencies when queried as taskId or dependsOnTaskId', async () => {
+    const dep = await store.addDependency({
+      taskId: 'task-downstream',
+      dependsOnTaskId: 'task-upstream',
+      type: 'blocking'
+    });
+
+    const byDownstream = await store.getDependencies('task-downstream');
+    expect(byDownstream).toHaveLength(1);
+    expect(byDownstream[0].id).toBe(dep.id);
+
+    const byUpstream = await store.getDependencies('task-upstream');
+    expect(byUpstream).toHaveLength(1);
+    expect(byUpstream[0].id).toBe(dep.id);
+  });
 });
 

package/src/store/firebase.ts

@@ -546,8 +546,18 @@ export class FirebaseStore implements StorageAdapter {
 
   // --- Dependencies ---
   async getDependencies(taskId: string): Promise<TaskDependency[]> {
-    const snap = await this.db.collection('dependencies').where('taskId', '==', taskId).get();
-    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+    const [snap1, snap2] = await Promise.all([
+      this.db.collection('dependencies').where('taskId', '==', taskId).get(),
+      this.db.collection('dependencies').where('dependsOnTaskId', '==', taskId).get()
+    ]);
+    const depMap = new Map<string, TaskDependency>();
+    for (const doc of snap1.docs) {
+      depMap.set(doc.id, { ...doc.data(), id: doc.id } as TaskDependency);
+    }
+    for (const doc of snap2.docs) {
+      depMap.set(doc.id, { ...doc.data(), id: doc.id } as TaskDependency);
+    }
+    return Array.from(depMap.values());
   }
 
   async addDependency(dep: Omit<TaskDependency, 'id'>): Promise<TaskDependency> {

package/src/types/index.ts

@@ -369,6 +369,7 @@ export type WebhookEvent =
   | 'task.updated'
   | 'task.deleted'
   | 'task.status_changed'
+  | 'task.unblocked'
   | 'comment.created'
   | 'comment.updated'
   | 'comment.deleted'

package/src/utils/workflow.ts

@@ -101,14 +101,27 @@ export const DEFAULT_VFX_WORKFLOW: Workflow = {
   ],
   transitions: [
     { name: 'Award Bid', fromStatusKey: 'bidding', toStatusKey: 'awarded' },
+    { name: 'Start Directly from Bid', fromStatusKey: 'bidding', toStatusKey: 'in_production' },
     { name: 'Start Work', fromStatusKey: 'awarded', toStatusKey: 'in_production' },
+    { name: 'Reopen Bid', fromStatusKey: 'awarded', toStatusKey: 'bidding' },
     { name: 'Submit to Lead Review', fromStatusKey: 'in_production', toStatusKey: 'internal_review' },
+    { name: 'Fast-Track Client Review', fromStatusKey: 'in_production', toStatusKey: 'client_review' },
+    { name: 'Direct Approval', fromStatusKey: 'in_production', toStatusKey: 'approved' },
     { name: 'Submit to Client Review', fromStatusKey: 'internal_review', toStatusKey: 'client_review' },
     { name: 'Request Internal Revisions', fromStatusKey: 'internal_review', toStatusKey: 'revision_requested' },
+    { name: 'Return to Production', fromStatusKey: 'internal_review', toStatusKey: 'in_production' },
+    { name: 'Approve from Lead Review', fromStatusKey: 'internal_review', toStatusKey: 'approved' },
     { name: 'Request Client Revisions', fromStatusKey: 'client_review', toStatusKey: 'revision_requested' },
-    { name: 'Address Revisions', fromStatusKey: 'revision_requested', toStatusKey: 'in_production' },
+    { name: 'Return to Lead Review', fromStatusKey: 'client_review', toStatusKey: 'internal_review' },
     { name: 'Approve Final Shot', fromStatusKey: 'client_review', toStatusKey: 'approved' },
-    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' }
+    { name: 'Address Revisions in Production', fromStatusKey: 'revision_requested', toStatusKey: 'in_production' },
+    { name: 'Resubmit to Lead Review', fromStatusKey: 'revision_requested', toStatusKey: 'internal_review' },
+    { name: 'Resubmit to Client Review', fromStatusKey: 'revision_requested', toStatusKey: 'client_review' },
+    { name: 'Reopen Shot', fromStatusKey: 'approved', toStatusKey: 'in_production' },
+    { name: 'Reopen Lead Review', fromStatusKey: 'approved', toStatusKey: 'internal_review' },
+    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' },
+    { name: 'Restore to Bidding', fromStatusKey: 'canceled', toStatusKey: 'bidding' },
+    { name: 'Restore to Production', fromStatusKey: 'canceled', toStatusKey: 'in_production' }
   ],
   taskTypes: [
     { key: 'vfx_task', label: 'VFX Task', description: 'Department task (e.g. Matchmove, Animation, FX, Comp)', icon: 'film' },
@@ -139,14 +152,23 @@ export const DEFAULT_CREATIVE_WORKFLOW: Workflow = {
   transitions: [
     { name: 'Start Concepts', fromStatusKey: 'briefing', toStatusKey: 'concept' },
     { name: 'Approve Concept for Production', fromStatusKey: 'concept', toStatusKey: 'in_production' },
+    { name: 'Return to Briefing', fromStatusKey: 'concept', toStatusKey: 'briefing' },
     { name: 'Submit for Internal Review', fromStatusKey: 'in_production', toStatusKey: 'internal_review' },
+    { name: 'Submit for Client Review', fromStatusKey: 'in_production', toStatusKey: 'client_review' },
     { name: 'Submit for Client Review', fromStatusKey: 'internal_review', toStatusKey: 'client_review' },
     { name: 'Request Revisions (Internal)', fromStatusKey: 'internal_review', toStatusKey: 'revision_requested' },
+    { name: 'Return to Production', fromStatusKey: 'internal_review', toStatusKey: 'in_production' },
+    { name: 'Approve from Lead Review', fromStatusKey: 'internal_review', toStatusKey: 'approved' },
     { name: 'Request Revisions (Client)', fromStatusKey: 'client_review', toStatusKey: 'revision_requested' },
+    { name: 'Return to Internal Review', fromStatusKey: 'client_review', toStatusKey: 'internal_review' },
     { name: 'Address Revisions', fromStatusKey: 'revision_requested', toStatusKey: 'in_production' },
+    { name: 'Resubmit to Lead Review', fromStatusKey: 'revision_requested', toStatusKey: 'internal_review' },
+    { name: 'Resubmit to Client Review', fromStatusKey: 'revision_requested', toStatusKey: 'client_review' },
     { name: 'Approve Work', fromStatusKey: 'client_review', toStatusKey: 'approved' },
     { name: 'Deliver Final Assets', fromStatusKey: 'approved', toStatusKey: 'delivered' },
-    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' }
+    { name: 'Reopen Deliverable', fromStatusKey: 'delivered', toStatusKey: 'in_production' },
+    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' },
+    { name: 'Restore', fromStatusKey: 'canceled', toStatusKey: 'briefing' }
   ],
   taskTypes: [
     { key: 'deliverable', label: 'Deliverable', description: 'Finished asset, cutdown, or packaged export', icon: 'package' },
@@ -211,6 +233,41 @@ export function getAllowedNextStatuses(
   return [allStatusKeys[currentIndex + 1]];
 }
 
+export function getAllowedTransitions(
+  workflow: Workflow | undefined,
+  currentStatus: string
+): string[] {
+  if (!workflow || !workflow.statuses || workflow.statuses.length === 0) {
+    return Object.keys(DEFAULT_STATUS_DEFINITIONS);
+  }
+
+  const allStatusKeys = workflow.statuses.map((s) => s.key);
+  if (!allStatusKeys.includes(currentStatus)) {
+    return [];
+  }
+
+  if (workflow.transitions && workflow.transitions.length > 0) {
+    const matches = workflow.transitions.filter(
+      (t) => t.fromStatusKey === '*' || t.fromStatusKey === currentStatus
+    );
+
+    const allowed = new Set<string>();
+    for (const t of matches) {
+      if (t.toStatusKey === '*') {
+        allStatusKeys.filter((k) => k !== currentStatus).forEach((k) => allowed.add(k));
+      } else if (t.toStatusKey !== currentStatus && allStatusKeys.includes(t.toStatusKey)) {
+        allowed.add(t.toStatusKey);
+      }
+    }
+
+    return Array.from(allowed);
+  }
+
+  const next = getAllowedNextStatuses(workflow, currentStatus);
+  const prev = getAllowedPreviousStatuses(workflow, currentStatus);
+  return Array.from(new Set([...next, ...prev]));
+}
+
 export function getAllowedPreviousStatuses(
   workflow: Workflow | undefined,
   currentStatus: string