@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/components/task/TaskContextUpload.test.js

@@ -29,19 +29,19 @@ describe('TaskContextUpload drag and drop', () => {
     const onAddContextFile = vi.fn();
     const onRemoveContextFile = vi.fn();
     const onUpdateContextCaption = vi.fn();
-    const onBrowseLinkPath = vi.fn();
-    const renderUpload = (contextFiles = []) => render(_jsx(TaskContextUpload, { contextFiles: contextFiles, onBrowseLinkPath: onBrowseLinkPath, onAddContextFile: onAddContextFile, onRemoveContextFile: onRemoveContextFile, onUpdateContextCaption: onUpdateContextCaption }));
-    const openSection = async () => {
-        const user = userEvent.setup();
+    const renderUpload = (contextFiles = [], taskId, extraProps) => render(_jsx(TaskContextUpload, { taskId: taskId, contextFiles: contextFiles, onAddContextFile: onAddContextFile, onRemoveContextFile: onRemoveContextFile, onUpdateContextCaption: onUpdateContextCaption, ...extraProps }));
+    const openSection = async (user) => {
+        const localUser = user ?? userEvent.setup();
         const showToggle = screen.queryByTitle('Show context documents');
         if (showToggle) {
-            await user.click(showToggle);
+            await localUser.click(showToggle);
         }
-        return screen.getByText('Drop files, URLs, or file paths here');
+        return screen.getByText('Drop files or URLs here');
     };
     beforeEach(() => {
         vi.clearAllMocks();
         vi.stubGlobal('FileReader', MockFileReader);
+        vi.spyOn(window, 'open').mockImplementation(() => null);
         window.localStorage.removeItem(CONTEXT_UPLOAD_OPEN_STORAGE_KEY);
     });
     afterEach(() => {
@@ -62,7 +62,7 @@ describe('TaskContextUpload drag and drop', () => {
             caption: 'spec'
         }));
     });
-    it('converts dropped file:// URLs to linked filesystem paths', async () => {
+    it('rejects dropped file:// URLs and instructs the user to upload files instead', async () => {
         renderUpload();
         const dropzone = await openSection();
         fireEvent.drop(dropzone, {
@@ -71,12 +71,9 @@ describe('TaskContextUpload drag and drop', () => {
                 getData: (type) => type === 'text/uri-list' ? 'file:///Users/rossburke/Documents/spec.pdf' : ''
             }
         });
-        expect(onAddContextFile).toHaveBeenCalledTimes(1);
-        expect(onAddContextFile).toHaveBeenCalledWith(expect.objectContaining({
-            path: '/api/taskforce/context-link?path=%2FUsers%2Frossburke%2FDocuments%2Fspec.pdf',
-            fsPath: '/Users/rossburke/Documents/spec.pdf',
-            caption: 'spec.pdf'
-        }));
+        expect(onAddContextFile).not.toHaveBeenCalled();
+        expect(screen.getByText(/local path/i)).toBeInTheDocument();
+        expect(screen.getByText(/upload files to attach them/i)).toBeInTheDocument();
     });
     it('shows an error for empty drops', async () => {
         renderUpload();
@@ -87,7 +84,7 @@ describe('TaskContextUpload drag and drop', () => {
                 getData: () => ''
             }
         });
-        expect(screen.getByText('Drop a file, URL, or file path.')).toBeInTheDocument();
+        expect(screen.getByText('Drop a file or URL.')).toBeInTheDocument();
     });
     it('skips duplicate dropped links and shows notice', async () => {
         renderUpload();
@@ -125,6 +122,78 @@ describe('TaskContextUpload drag and drop', () => {
         });
         expect(screen.getByText('1 duplicate file skipped.')).toBeInTheDocument();
     });
+    it('uploads task attachments same-origin even when a cloud api base url is configured', async () => {
+        const dispatchSpy = vi.spyOn(window, 'dispatchEvent');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                uploadUrl: 'https://uploads.example.com/put',
+                method: 'PUT',
+                headers: { 'Content-Type': 'text/markdown' },
+                path: '/api/taskforce/documents/asset-doc-1/content',
+                relativePath: 'workspaces/workspace-230/assets/documents/asset-doc-1-notes.md'
+            })
+        })
+            .mockResolvedValueOnce({
+            ok: true
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                path: '/api/taskforce/documents/asset-doc-1/content',
+                fsPath: 'workspaces/workspace-230/assets/documents/asset-doc-1-notes.md',
+                assetId: 'asset-doc-1',
+                taskId: 'task-230',
+                caption: 'notes.md'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        renderUpload([], 'task-230', {
+            workspaceId: 'workspace-230',
+            apiBaseUrl: 'https://api.taskforcehq.test'
+        });
+        const dropzone = await openSection();
+        const file = new File(['# Notes'], 'notes.md', { type: 'text/markdown' });
+        fireEvent.drop(dropzone, {
+            dataTransfer: {
+                files: createFileList([file]),
+                getData: () => ''
+            }
+        });
+        await waitFor(() => {
+            expect(onAddContextFile).toHaveBeenCalledTimes(1);
+        });
+        expect(fetchMock).toHaveBeenNthCalledWith(1, '/api/taskforce/context-upload/init', expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({
+                'Content-Type': 'application/json',
+                'x-taskforce-workspace-id': 'workspace-230'
+            })
+        }));
+        expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body || '{}'))).toEqual(expect.objectContaining({
+            workspaceId: 'workspace-230',
+            taskId: 'task-230',
+            originalName: 'notes.md'
+        }));
+        expect(fetchMock).toHaveBeenNthCalledWith(3, '/api/taskforce/context-upload/finalize', expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({
+                'Content-Type': 'application/json',
+                'x-taskforce-workspace-id': 'workspace-230'
+            })
+        }));
+        expect(JSON.parse(String(fetchMock.mock.calls[2]?.[1]?.body || '{}'))).toEqual(expect.objectContaining({
+            workspaceId: 'workspace-230',
+            taskId: 'task-230',
+            relativePath: 'workspaces/workspace-230/assets/documents/asset-doc-1-notes.md'
+        }));
+        expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'taskforce:context-assets-mutated'
+        }));
+    });
     it('validates unsupported file types before upload', async () => {
         const fetchMock = vi.fn();
         vi.stubGlobal('fetch', fetchMock);
@@ -186,4 +255,252 @@ describe('TaskContextUpload drag and drop', () => {
         expect(fetchMock).toHaveBeenCalledTimes(1);
         expect(screen.getByText(/local duplicate file/i)).toBeInTheDocument();
     });
+    it('sends taskId to finalize and uses canonical finalize payload', async () => {
+        const uploadFetch = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                uploadUrl: 'https://example.r2/upload',
+                method: 'PUT',
+                headers: { 'Content-Type': 'text/markdown' },
+                relativePath: 'workspaces/workspace-1/assets/documents/asset-1-notes.md',
+                path: '/api/taskforce/documents/asset-1/content',
+                fsPath: '.taskforce/workspaces/workspace-1/assets/documents/asset-1-notes.md'
+            })
+        })
+            .mockResolvedValueOnce({
+            ok: true
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                path: '/api/taskforce/documents/asset-1/content',
+                fsPath: 'workspaces/workspace-1/assets/documents/asset-1-notes.md',
+                caption: 'notes.md',
+                assetId: 'asset-1',
+                taskId: 'task-1'
+            })
+        });
+        vi.stubGlobal('fetch', uploadFetch);
+        renderUpload([], 'task-1');
+        const dropzone = await openSection();
+        const file = new File(['# Hello'], 'notes.md', { type: 'text/markdown' });
+        fireEvent.drop(dropzone, {
+            dataTransfer: {
+                files: createFileList([file]),
+                getData: () => ''
+            }
+        });
+        await waitFor(() => {
+            expect(onAddContextFile).toHaveBeenCalledTimes(1);
+        });
+        const finalizeCall = uploadFetch.mock.calls[2];
+        expect(finalizeCall?.[0]).toBe('/api/taskforce/context-upload/finalize');
+        const finalizeBody = JSON.parse(String(finalizeCall?.[1]?.body || '{}'));
+        expect(finalizeBody.taskId).toBe('task-1');
+        expect(onAddContextFile).toHaveBeenCalledWith(expect.objectContaining({
+            path: '/api/taskforce/documents/asset-1/content',
+            fsPath: 'workspaces/workspace-1/assets/documents/asset-1-notes.md'
+        }));
+    });
+    it('renders image attachments as preview tiles and document attachments as rows', async () => {
+        renderUpload([
+            '/uploads/mockup.png',
+            {
+                path: '/api/taskforce/context/spec.pdf',
+                fsPath: 'context/spec.pdf',
+                caption: 'Product spec',
+                originalFilename: 'product-spec.pdf'
+            }
+        ]);
+        await openSection();
+        expect(screen.getByRole('img', { name: /context file 0/i })).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: /product-spec\.pdf pdf/i })).toBeInTheDocument();
+        expect(screen.getByDisplayValue('Product spec')).toBeInTheDocument();
+    });
+    it('dispatches annotated attachment open events from image preview tiles with canonical metadata', async () => {
+        const dispatchSpy = vi.spyOn(window, 'dispatchEvent').mockReturnValue(false);
+        const user = userEvent.setup();
+        renderUpload([
+            {
+                path: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-1-ui.png',
+                fsPath: 'workspaces/workspace-1/assets/images/asset-image-1-ui.png',
+                assetId: 'asset-image-1',
+                taskId: 'task-1',
+                displayName: 'UI Screenshot',
+                originalFilename: 'ui.png',
+                caption: 'UI Screenshot',
+            }
+        ], 'task-1', { taskReferenceLabel: 'T-230' });
+        await openSection(user);
+        await user.click(screen.getByRole('img', { name: /ui screenshot/i }));
+        expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'taskforce:open-annotated-attachment',
+            detail: expect.objectContaining({
+                taskId: 'task-1',
+                taskReferenceLabel: 'T-230',
+                assetId: 'asset-image-1',
+                path: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-1-ui.png',
+                displayName: 'UI Screenshot'
+            })
+        }));
+        dispatchSpy.mockRestore();
+    });
+    it('shows an annotate action for canonical image attachments and dispatches the open event', async () => {
+        const dispatchSpy = vi.spyOn(window, 'dispatchEvent').mockReturnValue(false);
+        const user = userEvent.setup();
+        renderUpload([
+            {
+                path: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-2-ui.png',
+                fsPath: 'workspaces/workspace-1/assets/images/asset-image-2-ui.png',
+                assetId: 'asset-image-2',
+                taskId: 'task-1',
+                displayName: 'Settings screen',
+                originalFilename: 'settings.png',
+                caption: 'Settings screen',
+            }
+        ], 'task-1', { taskReferenceLabel: 'T-230' });
+        await openSection(user);
+        await user.click(screen.getByTitle('Annotate'));
+        expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'taskforce:open-annotated-attachment',
+            detail: expect.objectContaining({
+                taskId: 'task-1',
+                taskReferenceLabel: 'T-230',
+                assetId: 'asset-image-2',
+                displayName: 'Settings screen'
+            })
+        }));
+        dispatchSpy.mockRestore();
+    });
+    it('prefers the attachment caption over the raw image filename for image notes launches', async () => {
+        const dispatchSpy = vi.spyOn(window, 'dispatchEvent').mockReturnValue(false);
+        const user = userEvent.setup();
+        renderUpload([
+            {
+                path: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-3-ui.png',
+                fsPath: 'workspaces/workspace-1/assets/images/asset-image-3-ui.png',
+                assetId: 'asset-image-3',
+                taskId: 'task-1',
+                displayName: 'pasted-image-1774497398365.png',
+                originalFilename: 'pasted-image-1774497398365.png',
+                caption: 'Image Notes',
+            }
+        ], 'task-1', { taskReferenceLabel: 'T-230' });
+        await openSection(user);
+        await user.click(screen.getByTitle('Annotate'));
+        expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'taskforce:open-annotated-attachment',
+            detail: expect.objectContaining({
+                taskId: 'task-1',
+                taskReferenceLabel: 'T-230',
+                assetId: 'asset-image-3',
+                displayName: 'Image Notes'
+            })
+        }));
+        dispatchSpy.mockRestore();
+    });
+    it('does not show annotate for non-editable gif attachments', async () => {
+        const user = userEvent.setup();
+        renderUpload([
+            {
+                path: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-anim.gif',
+                fsPath: 'workspaces/workspace-1/assets/images/asset-image-anim.gif',
+                assetId: 'asset-image-anim',
+                taskId: 'task-1',
+                displayName: 'Animated preview',
+                originalFilename: 'animated.gif',
+                caption: 'Animated preview',
+            }
+        ], 'task-1');
+        await openSection(user);
+        expect(screen.queryByTitle('Annotate')).not.toBeInTheDocument();
+    });
+    it('shows inline document actions and keeps caption editing working', async () => {
+        const user = userEvent.setup();
+        renderUpload([
+            {
+                path: 'https://example.com/files/briefing.md',
+                caption: 'Briefing',
+                originalFilename: 'briefing.md'
+            }
+        ]);
+        await openSection();
+        await user.click(screen.getByTitle('briefing.md'));
+        expect(window.open).toHaveBeenCalledWith('https://example.com/files/briefing.md', '_blank');
+        const captionInput = screen.getByDisplayValue('Briefing');
+        fireEvent.change(captionInput, { target: { value: 'Briefing v2' } });
+        expect(onUpdateContextCaption).toHaveBeenLastCalledWith(0, 'Briefing v2');
+        await user.click(screen.getByTitle('Delete'));
+        expect(onRemoveContextFile).toHaveBeenCalledWith(0);
+    });
+    it('renders D- references for canonical document attachments in the task form surface', async () => {
+        renderUpload([
+            {
+                path: '/api/taskforce/documents/asset-doc-1/content',
+                fsPath: 'workspaces/workspace-1/assets/documents/asset-doc-1-briefing.md',
+                caption: 'Briefing',
+                displayName: 'Briefing',
+                originalFilename: 'briefing.md',
+                assetId: 'asset-doc-1',
+                referenceNumber: 7,
+                referenceLabel: 'D-7'
+            }
+        ]);
+        await openSection();
+        expect(screen.getByText('D-7')).toBeInTheDocument();
+        expect(screen.getByText('Briefing')).toBeInTheDocument();
+    });
+    it('renders local document actions without hover-only dependence', async () => {
+        const user = userEvent.setup();
+        renderUpload([
+            {
+                path: '/api/taskforce/context/notes.json',
+                fsPath: 'context/notes.json',
+                caption: '',
+                originalFilename: 'notes.json'
+            }
+        ]);
+        await openSection();
+        expect(screen.getByTitle('Copy path: context/notes.json')).toBeInTheDocument();
+        await user.click(screen.getByTitle('Download'));
+        expect(window.open).toHaveBeenCalledWith(expect.stringContaining('/api/taskforce/context/notes.json?download=1&filename=notes.json'), '_blank');
+    });
+    it('pastes an image from the clipboard into task context', async () => {
+        const user = userEvent.setup();
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                success: true,
+                path: '/api/taskforce/context/workspaces%2Fworkspace-230%2Fassets%2Fimages%2Fasset-image-1-ui.png',
+                fsPath: 'workspaces/workspace-230/assets/images/asset-image-1-ui.png',
+                assetId: 'asset-image-1',
+                taskId: 'task-230',
+                caption: 'pasted-image.png'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        Object.defineProperty(navigator, 'clipboard', {
+            configurable: true,
+            value: {
+                read: vi.fn().mockResolvedValue([
+                    {
+                        types: ['image/png'],
+                        getType: vi.fn().mockResolvedValue(new Blob(['fake-image'], { type: 'image/png' }))
+                    }
+                ])
+            }
+        });
+        renderUpload([], 'task-230', { workspaceId: 'workspace-230' });
+        await openSection(user);
+        await user.click(screen.getByRole('button', { name: /paste image from clipboard/i }));
+        await waitFor(() => {
+            expect(onAddContextFile).toHaveBeenCalledWith(expect.objectContaining({
+                assetId: 'asset-image-1',
+                taskId: 'task-230'
+            }));
+        });
+    });
 });

package/dist/components/task/TaskForm.d.ts

@@ -1,6 +1,8 @@
 import React from 'react';
-import type { TaskItem, CategoryConfig, Comment, ScreenshotItem, TaskAssignee } from '../../types';
+import type { TaskItem, CategoryConfig, Comment, AttachmentItem, TaskAssignee, ChecklistItem } from '../../types';
 import type { TaxonomyDefinition } from '../../types';
+import { type TaskAssigneeOption } from '../../utils/assignees';
+import type { WorkstreamItem } from '../../types';
 interface TaskFormProps {
     editingTaskId: string | null;
     error: string;
@@ -15,24 +17,26 @@ interface TaskFormProps {
     assignee: TaskAssignee;
     scheduledDate: string;
     dueDate: string;
-    selectedSpecialists: string[];
+    workstreamInput?: string;
+    checklistItems: ChecklistItem[];
     comments: Comment[];
     newCommentText: string;
-    contextFiles: Array<string | ScreenshotItem>;
-    contextLinkBrowsePath?: string;
+    contextFiles: Array<string | AttachmentItem>;
+    currentWorkspaceId?: string | null;
+    apiBaseUrl?: string;
     formTaxonomies: Record<string, string | number | string[] | number[]>;
     descriptionFocused: boolean;
     showMarkdownHelp: boolean;
-    showSpecialists: boolean;
     showChecklist?: boolean;
     checklistEnabled?: boolean;
-    showTaskRelationships?: boolean;
     showComments: boolean;
-    showChildTasks?: boolean;
     categories: CategoryConfig[];
     types: {
         value: string;
         label: string;
+        color?: string;
+        icon?: string;
+        status?: 'active' | 'retired';
     }[];
     priorities: Array<{
         value: number;
@@ -40,17 +44,20 @@ interface TaskFormProps {
         color?: string;
         icon?: string;
     }>;
-    approaches: Array<{
+    taxonomyDisplayLabels?: {
+        category?: string;
+        type?: string;
+        priority?: string;
+    };
+    approaches?: Array<{
         value: string;
         label: string;
         color?: string;
         icon?: string;
     }>;
-    availableSpecialists: {
-        value: string;
-        label: string;
-    }[];
+    assigneeOptions: TaskAssigneeOption[];
     taxonomies: TaxonomyDefinition[];
+    workstreams?: WorkstreamItem[];
     copiedId: string | null;
     onTitleChange: (value: string) => void;
     onDescriptionChange: (value: string) => void;
@@ -62,23 +69,18 @@ interface TaskFormProps {
     onAssigneeChange: (value: TaskAssignee) => void;
     onScheduledDateChange: (value: string) => void;
     onDueDateChange: (value: string) => void;
-    onSelectedSpecialistsChange: (value: string[]) => void;
+    onWorkstreamInputChange?: (value: string) => void;
+    onChecklistItemsChange: (value: ChecklistItem[]) => void;
     onNewCommentTextChange: (value: string) => void;
     onTaxonomyChange: (id: string, value: string | number | string[] | number[]) => void;
-    onParentTaskIdInputChange?: (value: string) => void;
-    onAddChildTaskIdInputChange?: (value: string) => void;
     onDescriptionFocusedChange: (value: boolean) => void;
     onShowMarkdownHelpChange: (value: boolean) => void;
-    onShowSpecialistsChange: (value: boolean) => void;
     onShowChecklistChange?: (value: boolean) => void;
-    onShowTaskRelationshipsChange?: (value: boolean) => void;
     onShowCommentsChange: (value: boolean) => void;
-    onShowChildTasksChange?: (value: boolean) => void;
     onOpenSettings?: (section: 'categories' | 'types') => void;
     onSubmit: (e: React.FormEvent) => void;
     onAddComment: () => void;
-    onAddContextFile: (file: ScreenshotItem) => void;
-    onBrowseContextLinkPath?: () => void;
+    onAddContextFile: (file: AttachmentItem) => void;
     onRemoveContextFile: (index: number) => void;
     onUpdateContextCaption: (index: number, caption: string) => void;
     onCopyId: (e: React.MouseEvent, id: string) => void;
@@ -86,19 +88,11 @@ interface TaskFormProps {
     onToggleReview?: (task: TaskItem) => void;
     onToggleComplete?: (task: TaskItem) => void;
     onToggleCancel?: (task: TaskItem) => void;
+    onSetStatus?: (task: TaskItem, status: TaskItem['status']) => void;
     onArchiveTask?: (task: TaskItem) => void;
     onUnarchive?: (taskId: string) => void;
-    onSetParentForCurrentTask?: (parentTaskIdOverride?: string | null) => void;
-    onAddChildToCurrentTask?: () => void;
-    onCreateChildForCurrentTask?: () => void;
-    onUnlinkChildTask?: (childId: string) => void;
-    onReorderChildTasks?: (parentTaskId: string, orderedChildIds: string[]) => void;
     onOpenTaskById?: (taskId: string) => void;
     currentTask?: TaskItem;
-    currentTaskParent?: TaskItem;
-    currentTaskChildren?: TaskItem[];
-    parentTaskIdInput?: string;
-    addChildTaskIdInput?: string;
     commentsEndRef: React.RefObject<HTMLDivElement | null>;
 }
 export declare function TaskForm(props: TaskFormProps): import("react/jsx-runtime").JSX.Element;