@critical-path/svelte 0.13.1 → 0.15.0

package/dist/task-metrics-state.svelte.d.ts

@@ -0,0 +1,24 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import type { TaskMetrics, TaskProgressHistory, TaskInferredActuals, RealityDelta, TaskProgressInference, TaskEVM, ProgressCurveProfile } from '@critical-path/core';
+export declare class TaskMetricsState {
+    private client;
+    taskId: string;
+    metrics: TaskMetrics | null;
+    history: TaskProgressHistory | null;
+    loading: boolean;
+    error: Error | null;
+    inferredActuals: TaskInferredActuals | null;
+    realityDelta: RealityDelta | null;
+    progress: TaskProgressInference | null;
+    evm: TaskEVM | null;
+    curveProfile: ProgressCurveProfile | null;
+    constructor(client: CriticalPathClient, taskId: string);
+    fetchMetrics(): Promise<TaskMetrics | null>;
+    fetchHistory(): Promise<TaskProgressHistory | null>;
+    fetchAll(): Promise<{
+        metrics: TaskMetrics | null;
+        history: TaskProgressHistory | null;
+    }>;
+}
+export declare function createTaskMetricsState(client: CriticalPathClient, taskId: string): TaskMetricsState;
+//# sourceMappingURL=task-metrics-state.svelte.d.ts.map

package/dist/task-metrics-state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-metrics-state.svelte.d.ts","sourceRoot":"","sources":["../src/task-metrics-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,mBAAmB,EACnB,YAAY,EACZ,qBAAqB,EACrB,OAAO,EACP,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,gBAAgB;IAazB,OAAO,CAAC,MAAM;IACP,MAAM,EAAE,MAAM;IAbvB,OAAO,qBAAoC;IAC3C,OAAO,6BAA4C;IACnD,OAAO,UAA0B;IACjC,KAAK,eAA8B;IAEnC,eAAe,6BAA+E;IAC9F,YAAY,sBAAqE;IACjF,QAAQ,+BAA0E;IAClF,GAAG,iBAAuD;IAC1D,YAAY,8BAA6E;gBAG/E,MAAM,EAAE,kBAAkB,EAC3B,MAAM,EAAE,MAAM;IAGjB,YAAY,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAc3C,YAAY,IAAI,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAcnD,QAAQ,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;QAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAA;KAAE,CAAC;CAkBhG;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,MAAM,GACb,gBAAgB,CAElB"}

package/dist/workload-state.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import type { WorkloadDistribution, WorkloadDistributionOptions, WorkloadInterval, WorkloadGroupBy, WorkloadMetric, WorkloadBucket } from '@critical-path/core';
+export declare class WorkloadState {
+    private client;
+    projectId?: string | undefined;
+    initialOptions?: WorkloadDistributionOptions | undefined;
+    data: WorkloadDistribution | null;
+    interval: WorkloadInterval;
+    groupBy: WorkloadGroupBy;
+    metric: WorkloadMetric;
+    loading: boolean;
+    error: Error | null;
+    buckets: WorkloadBucket[];
+    seriesKeys: string[];
+    seriesLabels: Record<string, string>;
+    totalHours: number;
+    totalCapacity: number;
+    averageUtilization: number | undefined;
+    constructor(client: CriticalPathClient, projectId?: string | undefined, initialOptions?: WorkloadDistributionOptions | undefined);
+    setInterval(newInterval: WorkloadInterval): Promise<void>;
+    setGroupBy(newGroupBy: WorkloadGroupBy): Promise<void>;
+    setMetric(newMetric: WorkloadMetric): Promise<void>;
+    fetch(options?: WorkloadDistributionOptions): Promise<void>;
+}
+export declare function createWorkloadState(client: CriticalPathClient, projectId?: string, initialOptions?: WorkloadDistributionOptions): WorkloadState;
+//# sourceMappingURL=workload-state.svelte.d.ts.map

package/dist/workload-state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workload-state.svelte.d.ts","sourceRoot":"","sources":["../src/workload-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EACV,oBAAoB,EACpB,2BAA2B,EAC3B,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,cAAc,EACf,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,aAAa;IAgBtB,OAAO,CAAC,MAAM;IACP,SAAS,CAAC,EAAE,MAAM;IAClB,cAAc,CAAC,EAAE,2BAA2B;IAjBrD,IAAI,8BAA6C;IACjD,QAAQ,mBAAoC;IAC5C,OAAO,kBAAuC;IAC9C,MAAM,iBAAqC;IAC3C,OAAO,UAA0B;IACjC,KAAK,eAA8B;IAEnC,OAAO,mBAAwD;IAC/D,UAAU,WAAmD;IAC7D,YAAY,yBAAmE;IAC/E,UAAU,SAAgD;IAC1D,aAAa,SAAmD;IAChE,kBAAkB,qBAA+D;gBAGvE,MAAM,EAAE,kBAAkB,EAC3B,SAAS,CAAC,EAAE,MAAM,YAAA,EAClB,cAAc,CAAC,EAAE,2BAA2B,YAAA;IAa/C,WAAW,CAAC,WAAW,EAAE,gBAAgB;IAKzC,UAAU,CAAC,UAAU,EAAE,eAAe;IAKtC,SAAS,CAAC,SAAS,EAAE,cAAc;IAKnC,KAAK,CAAC,OAAO,CAAC,EAAE,2BAA2B;CAiBlD;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,kBAAkB,EAC1B,SAAS,CAAC,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,2BAA2B,GAC3C,aAAa,CAEf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@critical-path/svelte",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "description": "Svelte 5 Runes state and reactive integrations for Critical Path headless project management framework",
   "author": "Jack James",
   "license": "MIT",
@@ -18,9 +18,9 @@
     }
   },
   "dependencies": {
-    "@critical-path/core": "0.16.0",
-    "@critical-path/mcp": "0.3.1",
-    "@critical-path/client": "0.10.0"
+    "@critical-path/client": "0.12.0",
+    "@critical-path/core": "0.18.0",
+    "@critical-path/mcp": "0.5.0"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"

package/src/index.test.ts

@@ -26,7 +26,11 @@ import {
   CriticalPathState,
   createCriticalPathState,
   TimelineLadderState,
-  createTimelineLadderState
+  createTimelineLadderState,
+  TaskMetricsState,
+  createTaskMetricsState,
+  WorkloadState,
+  createWorkloadState
 } from './index.js';
 import type { CriticalPathClient } from '@critical-path/client';
 import type {
@@ -38,7 +42,8 @@ import type {
   Deliverable,
   DeliverableSummary,
   CriticalPathAnalysis,
-  TimelineLadder
+  TimelineLadder,
+  WorkloadDistribution
 } from '@critical-path/core';
 
 describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
@@ -660,6 +665,159 @@ describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
       expect(mockClient.getTimelineLadder).toHaveBeenCalledWith('proj_ladder', { level: 'macro' });
     });
   });
+
+  describe('TaskMetricsState', () => {
+    it('fetches metrics and progress history and derives subfields', async () => {
+      const mockMetrics = {
+        taskId: 'task_1',
+        inferredActuals: {
+          actualStartDate: '2026-09-01T00:00:00Z',
+          actualEndDate: '2026-09-05T00:00:00Z',
+          isStartDateInferred: false,
+          isEndDateInferred: true,
+          activeWorkingHours: 96
+        },
+        realityDelta: {
+          estimatedHours: 20,
+          loggedHours: 15,
+          varianceHours: -5,
+          effortVarianceHours: -5,
+          accuracyRatio: 0.75,
+          isOverdue: false,
+          isOverEstimate: false
+        },
+        progress: {
+          progressPercentage: 75,
+          source: 'explicit' as const,
+          isExplicit: true,
+          breakdown: { explicitProgress: 75 }
+        },
+        evm: {
+          plannedValue: 20,
+          earnedValue: 15,
+          actualCost: 15,
+          costVariance: 0,
+          scheduleVariance: -5,
+          costPerformanceIndex: 1.0,
+          schedulePerformanceIndex: 0.75
+        }
+      };
+
+      const mockHistory = {
+        taskId: 'task_1',
+        points: [
+          { timestamp: '2026-09-01T00:00:00Z', progress: 0, status: 'todo', semanticStatus: 'not_started' as const, action: 'task.created' },
+          { timestamp: '2026-09-05T00:00:00Z', progress: 75, status: 'in_progress', semanticStatus: 'in_progress' as const, action: 'task.updated' }
+        ],
+        curveProfile: 'linear' as const
+      };
+
+      const mockClient = {
+        getTaskMetrics: vi.fn().mockResolvedValue(mockMetrics),
+        getTaskProgressHistory: vi.fn().mockResolvedValue(mockHistory)
+      } as unknown as CriticalPathClient;
+
+      const state = createTaskMetricsState(mockClient, 'task_1');
+      expect(state.metrics).toBeNull();
+      expect(state.history).toBeNull();
+      expect(state.inferredActuals).toBeNull();
+      expect(state.realityDelta).toBeNull();
+      expect(state.progress).toBeNull();
+      expect(state.evm).toBeNull();
+      expect(state.curveProfile).toBeNull();
+
+      await state.fetchAll();
+      expect(mockClient.getTaskMetrics).toHaveBeenCalledWith('task_1');
+      expect(mockClient.getTaskProgressHistory).toHaveBeenCalledWith('task_1');
+      expect(state.metrics).toEqual(mockMetrics);
+      expect(state.history).toEqual(mockHistory);
+      expect(state.inferredActuals?.activeWorkingHours).toBe(96);
+      expect(state.realityDelta?.effortVarianceHours).toBe(-5);
+      expect(state.progress?.progressPercentage).toBe(75);
+      expect(state.evm?.costPerformanceIndex).toBe(1.0);
+      expect(state.curveProfile).toBe('linear');
+    });
+  });
+
+  describe('WorkloadState & createWorkloadState', () => {
+    it('initializes with default options and fetches workload distribution', async () => {
+      const mockDistribution: WorkloadDistribution = {
+        projectId: 'proj_wl',
+        startDate: '2026-09-01',
+        endDate: '2026-09-14',
+        interval: 'week',
+        groupBy: 'assignee',
+        metric: 'blended',
+        seriesKeys: ['u1', 'u2'],
+        seriesLabels: { u1: 'Alice', u2: 'Bob' },
+        buckets: [
+          {
+            date: '2026-09-01',
+            timestamp: 1788220800000,
+            totalHours: 40,
+            values: { u1: 25, u2: 15 },
+            capacity: { u1: 35, u2: 40 },
+            totalCapacity: 75,
+            utilizationRatio: 0.533
+          }
+        ],
+        totalHours: 40,
+        totalCapacity: 75,
+        averageUtilization: 0.533
+      };
+
+      const mockClient = {
+        getWorkloadDistribution: vi.fn().mockResolvedValue(mockDistribution)
+      } as unknown as CriticalPathClient;
+
+      const state = createWorkloadState(mockClient, 'proj_wl', {
+        interval: 'week',
+        groupBy: 'assignee',
+        metric: 'blended'
+      });
+
+      expect(state.data).toBeNull();
+      expect(state.buckets).toEqual([]);
+      expect(state.seriesKeys).toEqual([]);
+      expect(state.totalHours).toBe(0);
+
+      await state.fetch();
+
+      expect(mockClient.getWorkloadDistribution).toHaveBeenCalledWith('proj_wl', {
+        interval: 'week',
+        groupBy: 'assignee',
+        metric: 'blended'
+      });
+      expect(state.data).toEqual(mockDistribution);
+      expect(state.buckets).toHaveLength(1);
+      expect(state.seriesKeys).toEqual(['u1', 'u2']);
+      expect(state.totalHours).toBe(40);
+      expect(state.totalCapacity).toBe(75);
+      expect(state.averageUtilization).toBe(0.533);
+    });
+
+    it('updates interval and re-fetches', async () => {
+      const mockClient = {
+        getWorkloadDistribution: vi.fn().mockResolvedValue({
+          buckets: [],
+          seriesKeys: [],
+          seriesLabels: {},
+          totalHours: 0,
+          totalCapacity: 0
+        })
+      } as unknown as CriticalPathClient;
+
+      const state = new WorkloadState(mockClient, 'proj_wl');
+      expect(state.interval).toBe('week');
+
+      await state.setInterval('day');
+      expect(state.interval).toBe('day');
+      expect(mockClient.getWorkloadDistribution).toHaveBeenCalledWith(
+        'proj_wl',
+        expect.objectContaining({ interval: 'day' })
+      );
+    });
+  });
 });
 
 

package/src/index.ts

@@ -17,5 +17,7 @@ export * from './task-transitions-state.svelte.js';
 export * from './webmcp-state.svelte.js';
 export * from './critical-path-state.svelte.js';
 export * from './timeline-ladder-state.svelte.js';
+export * from './task-metrics-state.svelte.js';
+export * from './workload-state.svelte.js';
 
 

package/src/task-metrics-state.svelte.ts

@@ -0,0 +1,83 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type {
+  TaskMetrics,
+  TaskProgressHistory,
+  TaskInferredActuals,
+  RealityDelta,
+  TaskProgressInference,
+  TaskEVM,
+  ProgressCurveProfile
+} from '@critical-path/core';
+
+export class TaskMetricsState {
+  metrics = $state<TaskMetrics | null>(null);
+  history = $state<TaskProgressHistory | null>(null);
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  inferredActuals = $derived<TaskInferredActuals | null>(this.metrics?.inferredActuals ?? null);
+  realityDelta = $derived<RealityDelta | null>(this.metrics?.realityDelta ?? null);
+  progress = $derived<TaskProgressInference | null>(this.metrics?.progress ?? null);
+  evm = $derived<TaskEVM | null>(this.metrics?.evm ?? null);
+  curveProfile = $derived<ProgressCurveProfile | null>(this.history?.curveProfile ?? null);
+
+  constructor(
+    private client: CriticalPathClient,
+    public taskId: string
+  ) {}
+
+  async fetchMetrics(): Promise<TaskMetrics | null> {
+    this.loading = true;
+    this.error = null;
+    try {
+      this.metrics = await this.client.getTaskMetrics(this.taskId);
+      return this.metrics;
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+      return null;
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  async fetchHistory(): Promise<TaskProgressHistory | null> {
+    this.loading = true;
+    this.error = null;
+    try {
+      this.history = await this.client.getTaskProgressHistory(this.taskId);
+      return this.history;
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+      return null;
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  async fetchAll(): Promise<{ metrics: TaskMetrics | null; history: TaskProgressHistory | null }> {
+    this.loading = true;
+    this.error = null;
+    try {
+      const [m, h] = await Promise.all([
+        this.client.getTaskMetrics(this.taskId),
+        this.client.getTaskProgressHistory(this.taskId)
+      ]);
+      this.metrics = m;
+      this.history = h;
+      return { metrics: m, history: h };
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+      return { metrics: null, history: null };
+    } finally {
+      this.loading = false;
+    }
+  }
+}
+
+export function createTaskMetricsState(
+  client: CriticalPathClient,
+  taskId: string
+): TaskMetricsState {
+  return new TaskMetricsState(client, taskId);
+}

package/src/workload-state.svelte.ts

@@ -0,0 +1,83 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type {
+  WorkloadDistribution,
+  WorkloadDistributionOptions,
+  WorkloadInterval,
+  WorkloadGroupBy,
+  WorkloadMetric,
+  WorkloadBucket
+} from '@critical-path/core';
+
+export class WorkloadState {
+  data = $state<WorkloadDistribution | null>(null);
+  interval = $state<WorkloadInterval>('week');
+  groupBy = $state<WorkloadGroupBy>('assignee');
+  metric = $state<WorkloadMetric>('blended');
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  buckets = $derived<WorkloadBucket[]>(this.data?.buckets ?? []);
+  seriesKeys = $derived<string[]>(this.data?.seriesKeys ?? []);
+  seriesLabels = $derived<Record<string, string>>(this.data?.seriesLabels ?? {});
+  totalHours = $derived<number>(this.data?.totalHours ?? 0);
+  totalCapacity = $derived<number>(this.data?.totalCapacity ?? 0);
+  averageUtilization = $derived<number | undefined>(this.data?.averageUtilization);
+
+  constructor(
+    private client: CriticalPathClient,
+    public projectId?: string,
+    public initialOptions?: WorkloadDistributionOptions
+  ) {
+    if (initialOptions?.interval) {
+      this.interval = initialOptions.interval;
+    }
+    if (initialOptions?.groupBy) {
+      this.groupBy = initialOptions.groupBy;
+    }
+    if (initialOptions?.metric) {
+      this.metric = initialOptions.metric;
+    }
+  }
+
+  async setInterval(newInterval: WorkloadInterval) {
+    this.interval = newInterval;
+    await this.fetch();
+  }
+
+  async setGroupBy(newGroupBy: WorkloadGroupBy) {
+    this.groupBy = newGroupBy;
+    await this.fetch();
+  }
+
+  async setMetric(newMetric: WorkloadMetric) {
+    this.metric = newMetric;
+    await this.fetch();
+  }
+
+  async fetch(options?: WorkloadDistributionOptions) {
+    this.loading = true;
+    this.error = null;
+    try {
+      this.data = await this.client.getWorkloadDistribution(this.projectId, {
+        ...this.initialOptions,
+        interval: this.interval,
+        groupBy: this.groupBy,
+        metric: this.metric,
+        ...options
+      });
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      this.loading = false;
+    }
+  }
+}
+
+export function createWorkloadState(
+  client: CriticalPathClient,
+  projectId?: string,
+  initialOptions?: WorkloadDistributionOptions
+): WorkloadState {
+  return new WorkloadState(client, projectId, initialOptions);
+}