@critical-path/client 0.20.5 → 0.20.6

package/src/index.test.ts

@@ -1,415 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CriticalPathClient } from './index.js';
-
-describe('@critical-path/client Tests', () => {
-  it('instantiates client and accepts custom mock fetch', async () => {
-    const mockFetch = async (url: string | URL | Request, init?: RequestInit) => {
-      const urlStr = url.toString();
-      if (urlStr.endsWith('/projects') && (!init?.method || init.method.toUpperCase() === 'GET')) {
-        return new Response(JSON.stringify({ projects: [{ id: 'p1', key: 'TEST', name: 'Mock Proj' }] }), { status: 200 });
-      }
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 });
-    };
-
-    const client = new CriticalPathClient({
-      baseUrl: 'http://localhost:3000/api/critical-path',
-      fetch: mockFetch as typeof fetch
-    });
-
-    const projects = await client.getProjects();
-    expect(projects.length).toBe(1);
-    expect(projects[0].name).toBe('Mock Proj');
-  });
-
-  it('fetches workflows and task allowed transitions via client SDK', async () => {
-    const mockFetch = async (url: string | URL | Request, init?: RequestInit) => {
-      const urlStr = url.toString();
-      if (urlStr.endsWith('/workflows')) {
-        return new Response(JSON.stringify({ workflows: [{ id: 'wf1', name: 'SDK Workflow' }] }), { status: 200 });
-      }
-      if (urlStr.endsWith('/tasks/t1/transitions')) {
-        return new Response(JSON.stringify({
-          allowedNextStatuses: ['in_progress', 'canceled'],
-          allowedPreviousStatuses: ['backlog']
-        }), { status: 200 });
-      }
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 });
-    };
-
-    const client = new CriticalPathClient({
-      baseUrl: 'http://localhost:3000/api/critical-path',
-      fetch: mockFetch as typeof fetch
-    });
-
-    const workflows = await client.getWorkflows();
-    expect(workflows).toHaveLength(1);
-    expect(workflows[0].name).toBe('SDK Workflow');
-
-    const transitions = await client.getAllowedTaskTransitions('t1');
-    expect(transitions).toEqual(['in_progress', 'canceled']);
-
-    const previousTransitions = await client.getAllowedPreviousTaskTransitions('t1');
-    expect(previousTransitions).toEqual(['backlog']);
-  });
-
-  it('handles comments and attachments through client SDK methods', async () => {
-    const mockFetch = async (url: string | URL | Request, init?: RequestInit) => {
-      const urlStr = url.toString();
-      const method = init?.method?.toUpperCase() || 'GET';
-
-      if (urlStr.includes('/comments?taskId=t1') && method === 'GET') {
-        return new Response(JSON.stringify({ comments: [{ id: 'c1', taskId: 't1', content: 'SDK Comment', authorId: 'u1', authorType: 'user' }] }), { status: 200 });
-      }
-      if (urlStr.endsWith('/comments') && method === 'POST') {
-        const body = JSON.parse(init?.body as string);
-        return new Response(JSON.stringify({ comment: { id: 'c2', ...body } }), { status: 201 });
-      }
-      if (urlStr.endsWith('/comments/c1') && method === 'PATCH') {
-        const body = JSON.parse(init?.body as string);
-        return new Response(JSON.stringify({ comment: { id: 'c1', content: body.content } }), { status: 200 });
-      }
-      if (urlStr.endsWith('/comments/c1/reactions') && method === 'POST') {
-        const body = JSON.parse(init?.body as string);
-        return new Response(JSON.stringify({ comment: { id: 'c1', reactions: [body] } }), { status: 200 });
-      }
-      if (urlStr.split('?')[0].endsWith('/comments/c1/reactions') && method === 'DELETE') {
-        return new Response(JSON.stringify({ comment: { id: 'c1', reactions: [] } }), { status: 200 });
-      }
-      if (urlStr.endsWith('/comments/c1') && method === 'DELETE') {
-        return new Response(JSON.stringify({ success: true }), { status: 200 });
-      }
-      if (urlStr.includes('/attachments?taskId=t1') && method === 'GET') {
-        return new Response(JSON.stringify({ attachments: [{ id: 'a1', filename: 'SDK Doc', mimeType: 'text/plain', sizeBytes: 50, url: 'https://cdn.example.com/a1' }] }), { status: 200 });
-      }
-      if (urlStr.endsWith('/attachments') && method === 'POST') {
-        const body = JSON.parse(init?.body as string);
-        return new Response(JSON.stringify({ attachment: { id: 'a2', ...body } }), { status: 201 });
-      }
-      if (urlStr.endsWith('/attachments/upload') && method === 'POST') {
-        const body = JSON.parse(init?.body as string);
-        return new Response(JSON.stringify({ attachment: { id: 'a_up', ...body, url: 'https://cdn.example.com/uploaded.png' } }), { status: 201 });
-      }
-      if (urlStr.endsWith('/attachments/a1') && method === 'DELETE') {
-        return new Response(JSON.stringify({ success: true }), { status: 200 });
-      }
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 });
-    };
-
-    const client = new CriticalPathClient({
-      baseUrl: 'http://localhost:3000/api/critical-path',
-      fetch: mockFetch as typeof fetch
-    });
-
-    const comments = await client.getComments('t1');
-    expect(comments).toHaveLength(1);
-    expect(comments[0].content).toBe('SDK Comment');
-
-    const createdComment = await client.addComment({ taskId: 't1', content: 'New comment' });
-    expect(createdComment.id).toBe('c2');
-
-    const updatedComment = await client.updateComment('c1', { content: 'Updated' });
-    expect(updatedComment.content).toBe('Updated');
-
-    const reacted = await client.addCommentReaction('c1', { emoji: '🙌' });
-    expect(reacted.reactions).toHaveLength(1);
-    expect(reacted.reactions?.[0].emoji).toBe('🙌');
-
-    const unreacted = await client.removeCommentReaction('c1', { emoji: '🙌' });
-    expect(unreacted.reactions).toHaveLength(0);
-
-    const deletedComment = await client.deleteComment('c1');
-    expect(deletedComment).toBe(true);
-
-    const attachments = await client.getAttachments({ taskId: 't1' });
-    expect(attachments).toHaveLength(1);
-    expect(attachments[0].filename).toBe('SDK Doc');
-
-    const createdAtt = await client.createAttachment({ filename: 'file.txt', mimeType: 'text/plain', sizeBytes: 12, url: 'https://example.com/file.txt' });
-    expect(createdAtt.id).toBe('a2');
-
-    const uploadedAtt = await client.uploadAttachmentFile({ filename: 'uploaded.png', data: 'base64data' });
-    expect(uploadedAtt.id).toBe('a_up');
-    expect(uploadedAtt.url).toBe('https://cdn.example.com/uploaded.png');
-
-    const deletedAtt = await client.deleteAttachment('a1');
-    expect(deletedAtt).toBe(true);
-  });
-
-  it('handles deliverables CRUD and summary rollups via client SDK', async () => {
-    const mockDeliverable = {
-      id: 'd1',
-      projectId: 'p1',
-      title: 'Hero Cut 30s',
-      status: 'planned' as const,
-      format: 'ProRes 422',
-      outputUrls: [],
-      createdAt: '2026-09-04T00:00:00Z',
-      updatedAt: '2026-09-04T00:00:00Z'
-    };
-
-    const mockSummary = {
-      deliverable: mockDeliverable,
-      totalTasks: 4,
-      completedTasks: 2,
-      activeTasks: 2,
-      progressPercentage: 50,
-      estimatedHours: 20,
-      loggedHours: 12
-    };
-
-    const mockFetch = async (url: string | URL | Request, init?: RequestInit) => {
-      const urlStr = url.toString();
-      const method = init?.method?.toUpperCase() || 'GET';
-
-      if (urlStr.includes('/deliverables?projectId=p1') && method === 'GET') {
-        return new Response(JSON.stringify({ deliverables: [mockDeliverable] }), { status: 200 });
-      }
-      if (urlStr.endsWith('/deliverables/d1/summary') && method === 'GET') {
-        return new Response(JSON.stringify({ summary: mockSummary }), { status: 200 });
-      }
-      if (urlStr.endsWith('/deliverables/d1') && method === 'GET') {
-        return new Response(JSON.stringify({ deliverable: mockDeliverable }), { status: 200 });
-      }
-      if (urlStr.endsWith('/deliverables') && method === 'POST') {
-        const body = JSON.parse(init?.body as string);
-        return new Response(JSON.stringify({ deliverable: { id: 'd2', ...body } }), { status: 201 });
-      }
-      if (urlStr.endsWith('/deliverables/d1') && method === 'PATCH') {
-        const body = JSON.parse(init?.body as string);
-        return new Response(JSON.stringify({ deliverable: { ...mockDeliverable, ...body } }), { status: 200 });
-      }
-      if (urlStr.endsWith('/deliverables/d1') && method === 'DELETE') {
-        return new Response(JSON.stringify({ success: true }), { status: 200 });
-      }
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 });
-    };
-
-    const client = new CriticalPathClient({
-      baseUrl: 'http://localhost:3000/api/critical-path',
-      fetch: mockFetch as typeof fetch
-    });
-
-    const list = await client.getDeliverables('p1');
-    expect(list).toHaveLength(1);
-    expect(list[0].title).toBe('Hero Cut 30s');
-
-    const single = await client.getDeliverable('d1');
-    expect(single.id).toBe('d1');
-
-    const summary = await client.getDeliverableSummary('d1');
-    expect(summary.totalTasks).toBe(4);
-    expect(summary.progressPercentage).toBe(50);
-
-    const created = await client.createDeliverable({
-      projectId: 'p1',
-      title: 'Hero Cut 15s',
-      format: 'ProRes 422'
-    });
-    expect(created.id).toBe('d2');
-
-    const updated = await client.updateDeliverable('d1', { status: 'delivered' });
-    expect(updated.status).toBe('delivered');
-
-    const deleted = await client.deleteDeliverable('d1');
-    expect(deleted).toBe(true);
-  });
-
-  it('retrieves task lifecycle state and dependencies via client SDK', async () => {
-    const mockState = {
-      semanticStatus: 'not_started' as const,
-      isReady: false,
-      isBlocked: true,
-      blockingTaskIds: ['task_upstream'],
-      isOverdue: false,
-      isUpcoming: false,
-      isUnplanned: true,
-      isUnassigned: false,
-      isStalled: false,
-      isOverEstimate: false,
-      isPaceWarning: false,
-      isDone: false,
-      isActive: false,
-      isCancelled: false
-    };
-
-    const mockFetch = async (url: string | URL | Request) => {
-      const urlStr = url.toString();
-      if (urlStr.endsWith('/tasks/t1/lifecycle')) {
-        return new Response(JSON.stringify({ state: mockState }), { status: 200 });
-      }
-      if (urlStr.endsWith('/tasks/t1/dependencies')) {
-        return new Response(JSON.stringify({
-          graph: {
-            taskId: 't1',
-            upstreamTasks: [{ id: 'task_upstream', title: 'API', status: 'in_progress' }],
-            downstreamTasks: [],
-            dependencies: [{ id: 'dep1', taskId: 't1', dependsOnTaskId: 'task_upstream', type: 'blocking' }]
-          }
-        }), { status: 200 });
-      }
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 });
-    };
-
-    const client = new CriticalPathClient({
-      baseUrl: 'http://localhost:3000/api/critical-path',
-      fetch: mockFetch as typeof fetch
-    });
-
-    const lifecycle = await client.getTaskLifecycleState('t1');
-    expect(lifecycle.isBlocked).toBe(true);
-    expect(lifecycle.isReady).toBe(false);
-    expect(lifecycle.blockingTaskIds).toEqual(['task_upstream']);
-
-    const deps = await client.getTaskDependencies('t1');
-    expect(deps.upstreamTasks).toHaveLength(1);
-    expect(deps.upstreamTasks[0].id).toBe('task_upstream');
-    expect(deps.dependencies).toHaveLength(1);
-  });
-
-  it('fetches critical path and timeline ladder through client SDK', async () => {
-    const mockFetch = async (url: string | URL | Request) => {
-      const urlStr = url.toString();
-
-      if (urlStr.endsWith('/projects/p1/critical-path')) {
-        return new Response(JSON.stringify({
-          analysis: {
-            projectId: 'p1',
-            calculatedAt: '2026-09-11T10:00:00Z',
-            totalDurationHours: 18,
-            criticalTaskIds: ['t1', 't2'],
-            tasks: []
-          }
-        }), { status: 200 });
-      }
-
-      if (urlStr.includes('/projects/p1/ladder?level=macro')) {
-        return new Response(JSON.stringify({
-          ladder: {
-            projectId: 'p1',
-            generatedAt: '2026-09-11T10:00:00Z',
-            level: 'macro',
-            macro: {
-              projectId: 'p1',
-              projectName: 'Client Project',
-              totalDurationHours: 18,
-              criticalPathDurationHours: 18,
-              overallProgressPercentage: 50,
-              health: 'on_track',
-              totalTasks: 2,
-              completedTasks: 1,
-              inProgressTasks: 1,
-              blockedTasks: 0,
-              totalEstimatedHours: 18,
-              totalLoggedHours: 9,
-              phases: []
-            }
-          }
-        }), { status: 200 });
-      }
-
-      if (urlStr.endsWith('/tasks/t2/ladder')) {
-        return new Response(JSON.stringify({
-          taskLadder: {
-            taskId: 't2',
-            standard: { id: 't2', title: 'Task 2', status: 'in_progress', priority: 'high' },
-            concrete: { taskId: 't2', attachments: [], deliverables: [], todos: [], timeEntries: [], dailyEffortDistribution: [], activities: [] }
-          }
-        }), { status: 200 });
-      }
-
-      if (urlStr.includes('/projects/p1/workload')) {
-        return new Response(JSON.stringify({
-          workload: {
-            projectId: 'p1',
-            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: 20, values: { u1: 12, u2: 8 } }
-            ],
-            totalHours: 20
-          }
-        }), { status: 200 });
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 });
-    };
-
-    const client = new CriticalPathClient({
-      baseUrl: 'http://localhost:3000/api/critical-path',
-      fetch: mockFetch as typeof fetch
-    });
-
-    const cpm = await client.calculateCriticalPath('p1');
-    expect(cpm.totalDurationHours).toBe(18);
-    expect(cpm.criticalTaskIds).toEqual(['t1', 't2']);
-
-    const ladder = await client.getTimelineLadder('p1', { level: 'macro' });
-    expect(ladder.macro?.projectName).toBe('Client Project');
-    expect(ladder.level).toBe('macro');
-
-    const taskLadder = await client.getTaskLadder('t2');
-    expect(taskLadder.taskId).toBe('t2');
-    expect(taskLadder.standard.title).toBe('Task 2');
-
-    const workload = await client.getWorkloadDistribution('p1', { interval: 'week', metric: 'blended' });
-    expect(workload.projectId).toBe('p1');
-    expect(workload.totalHours).toBe(20);
-    expect(workload.seriesKeys).toEqual(['u1', 'u2']);
-    expect(workload.buckets[0].values.u1).toBe(12);
-  });
-
-  it('posts agent status updates via client.updateStatus', async () => {
-    let capturedBody: any = null;
-    const mockFetch = async (url: string | URL | Request, init?: RequestInit) => {
-      const urlStr = url.toString();
-      if (urlStr.endsWith('/status') && init?.method === 'POST') {
-        capturedBody = JSON.parse(init.body as string);
-        return new Response(JSON.stringify({ success: true, status: capturedBody.status, timestamp: 123456789 }), { status: 200 });
-      }
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 });
-    };
-
-    const client = new CriticalPathClient({
-      baseUrl: 'http://localhost:3000/api/critical-path',
-      fetch: mockFetch as typeof fetch
-    });
-
-    const result = await client.updateStatus('Running unit tests', {
-      taskId: 't1',
-      projectId: 'p1',
-      details: 'vitest run 15 passed'
-    });
-
-    expect(result.success).toBe(true);
-    expect(result.status).toBe('Running unit tests');
-    expect(capturedBody).toEqual({
-      status: 'Running unit tests',
-      taskId: 't1',
-      projectId: 'p1',
-      details: 'vitest run 15 passed',
-      isEngaged: true
-    });
-  });
-
-  it('resolves delete methods to false on 404 and still throws other errors', async () => {
-    let status = 404;
-    const mockFetch = async () =>
-      new Response(JSON.stringify({ error: status === 404 ? 'Not found' : 'Internal Server Error' }), {
-        status,
-        headers: { 'Content-Type': 'application/json' }
-      });
-    const client = new CriticalPathClient({ baseUrl: 'http://localhost/api', fetch: mockFetch as typeof fetch });
-
-    expect(await client.deleteTask('missing')).toBe(false);
-    expect(await client.deleteComment('missing')).toBe(false);
-
-    status = 500;
-    await expect(client.deleteTask('t1')).rejects.toThrow('Internal Server Error');
-  });
-});
-