@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/components/features/documentWorkspaceModel.js

@@ -0,0 +1,57 @@
+import { getReadableDocumentName } from '../../utils/documentNames';
+export function normalizeDocPath(value) {
+    let decoded = value;
+    try {
+        decoded = decodeURIComponent(value);
+    }
+    catch {
+        decoded = value;
+    }
+    const normalized = decoded
+        .trim()
+        .replace(/\\/g, '/')
+        .replace(/^\/+/, '')
+        .replace(/^\.\//, '')
+        .replace(/^\.taskforce\//, '');
+    return normalized;
+}
+export function docPathMatches(candidate, requested) {
+    if (candidate === requested)
+        return true;
+    if (candidate.endsWith(`/${requested}`))
+        return true;
+    if (requested.endsWith(`/${candidate}`))
+        return true;
+    return false;
+}
+export function extractAssetIdFromPath(value) {
+    const normalized = normalizeDocPath(String(value || ''));
+    if (!normalized)
+        return null;
+    const match = normalized.match(/(^|\/)(asset-[a-f0-9]{32})(?=[^/]*$)/i);
+    return match?.[2] ? match[2].toLowerCase() : null;
+}
+export function getEffectiveAttachmentState(doc) {
+    if (doc.attachmentState === 'attached' || doc.attachmentState === 'unattached') {
+        return doc.attachmentState;
+    }
+    const attachmentCount = typeof doc.attachmentCount === 'number' && Number.isFinite(doc.attachmentCount)
+        ? doc.attachmentCount
+        : 0;
+    if (attachmentCount > 0 || !!doc.taskId) {
+        return 'attached';
+    }
+    return 'unattached';
+}
+export function filterDocuments(documents, searchQuery, typeFilters, attachmentFilters) {
+    const normalizedQuery = searchQuery.trim().toLowerCase();
+    return documents.filter((doc) => {
+        const readableName = getReadableDocumentName(doc);
+        const haystack = `${readableName} ${doc.originalFilename || ''}`.toLowerCase();
+        const matchesSearch = normalizedQuery.length === 0 || haystack.includes(normalizedQuery);
+        const matchesType = typeFilters.length === 0 || typeFilters.includes(doc.docType);
+        const attachmentState = getEffectiveAttachmentState(doc);
+        const matchesAttachment = attachmentFilters.length === 0 || attachmentFilters.includes(attachmentState);
+        return matchesSearch && matchesType && matchesAttachment;
+    });
+}

package/dist/components/features/useDocumentWorkspaceController.d.ts

@@ -0,0 +1,34 @@
+import { type DocumentAttachmentFilter, type DocumentTypeFilter } from './documentWorkspaceFilters';
+import { type DocMeta } from './documentWorkspaceModel';
+interface Options {
+    runtimeMode?: 'local' | 'cloud';
+    apiBaseUrl?: string;
+    cloudAuthBaseUrl?: string;
+    typeFilters?: DocumentTypeFilter[];
+    attachmentFilters?: DocumentAttachmentFilter[];
+    onTypeFiltersChange?: (values: DocumentTypeFilter[]) => void;
+    onAttachmentFiltersChange?: (values: DocumentAttachmentFilter[]) => void;
+    requestedDocPath?: string | null;
+    requestedDocAssetId?: string | null;
+    onRequestedDocHandled?: () => void;
+}
+interface Result {
+    documentApiBaseUrl: string;
+    documents: DocMeta[];
+    filteredDocs: DocMeta[];
+    loading: boolean;
+    error: string | null;
+    selectedDoc: DocMeta | null;
+    searchQuery: string;
+    typeFilters: DocumentTypeFilter[];
+    attachmentFilters: DocumentAttachmentFilter[];
+    hasActiveFilters: boolean;
+    setSearchQuery: (value: string) => void;
+    handleTypeFiltersChange: (values: DocumentTypeFilter[]) => void;
+    handleAttachmentFiltersChange: (values: DocumentAttachmentFilter[]) => void;
+    fetchDocuments: () => Promise<void>;
+    selectDoc: (doc: DocMeta | null) => void;
+    handleDeleteSelected: () => Promise<void>;
+}
+export declare function useDocumentWorkspaceController({ runtimeMode, apiBaseUrl, cloudAuthBaseUrl, typeFilters: controlledTypeFilters, attachmentFilters: controlledAttachmentFilters, onTypeFiltersChange, onAttachmentFiltersChange, requestedDocPath, requestedDocAssetId, onRequestedDocHandled, }: Options): Result;
+export {};

package/dist/components/features/useDocumentWorkspaceController.js

@@ -0,0 +1,113 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { fetchTaskforceApi } from '../../utils/taskforceApiClient';
+import { logDocumentManagerDebug, resolveDocumentManagerApiBase } from '../../utils/documentManagerApi';
+import { DOCUMENT_ATTACHMENT_FILTER_OPTIONS, DOCUMENT_TYPE_FILTER_OPTIONS, } from './documentWorkspaceFilters';
+import { docPathMatches, extractAssetIdFromPath, filterDocuments, normalizeDocPath, } from './documentWorkspaceModel';
+export function useDocumentWorkspaceController({ runtimeMode = 'local', apiBaseUrl = '', cloudAuthBaseUrl = '', typeFilters: controlledTypeFilters, attachmentFilters: controlledAttachmentFilters, onTypeFiltersChange, onAttachmentFiltersChange, requestedDocPath = null, requestedDocAssetId = null, onRequestedDocHandled, }) {
+    const [documents, setDocuments] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [selectedDocId, setSelectedDocId] = useState(null);
+    const [searchQuery, setSearchQuery] = useState('');
+    const [internalTypeFilters, setInternalTypeFilters] = useState(() => DOCUMENT_TYPE_FILTER_OPTIONS.map((option) => option.value));
+    const [internalAttachmentFilters, setInternalAttachmentFilters] = useState(() => DOCUMENT_ATTACHMENT_FILTER_OPTIONS.map((option) => option.value));
+    const documentApiBaseUrl = resolveDocumentManagerApiBase({
+        runtimeMode,
+        apiBaseUrl,
+        cloudAuthBaseUrl,
+    });
+    const typeFilters = controlledTypeFilters ?? internalTypeFilters;
+    const attachmentFilters = controlledAttachmentFilters ?? internalAttachmentFilters;
+    const handleTypeFiltersChange = onTypeFiltersChange ?? setInternalTypeFilters;
+    const handleAttachmentFiltersChange = onAttachmentFiltersChange ?? setInternalAttachmentFilters;
+    const fetchDocuments = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const res = await fetchTaskforceApi('/api/taskforce/documents', {
+                credentials: 'include',
+            }, documentApiBaseUrl);
+            if (!res.ok)
+                throw new Error(`Failed to load documents (${res.status})`);
+            const data = await res.json();
+            const nextDocuments = Array.isArray(data.documents) ? data.documents : [];
+            logDocumentManagerDebug('list.loaded', {
+                runtimeMode,
+                apiBaseUrl: documentApiBaseUrl || '(same-origin)',
+                count: nextDocuments.length,
+            });
+            setDocuments(nextDocuments);
+        }
+        catch (e) {
+            setError(e?.message || 'Failed to load documents');
+            logDocumentManagerDebug('list.error', {
+                runtimeMode,
+                apiBaseUrl: documentApiBaseUrl || '(same-origin)',
+                message: e?.message || 'Failed to load documents',
+            });
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [documentApiBaseUrl, runtimeMode]);
+    useEffect(() => {
+        void fetchDocuments();
+    }, [fetchDocuments]);
+    const filteredDocs = useMemo(() => filterDocuments(documents, searchQuery, typeFilters, attachmentFilters), [attachmentFilters, documents, searchQuery, typeFilters]);
+    const selectedDoc = useMemo(() => (selectedDocId ? documents.find((doc) => doc.id === selectedDocId) ?? null : null), [documents, selectedDocId]);
+    useEffect(() => {
+        if ((!requestedDocPath && !requestedDocAssetId) || documents.length === 0)
+            return;
+        const requested = requestedDocPath ? normalizeDocPath(requestedDocPath) : '';
+        const normalizedRequestedAssetId = String(requestedDocAssetId || '').trim().toLowerCase()
+            || extractAssetIdFromPath(requestedDocPath);
+        const matched = documents.find((doc) => {
+            const candidateAssetId = extractAssetIdFromPath(doc.fsPath) || String(doc.assetId || '').trim().toLowerCase() || null;
+            if (normalizedRequestedAssetId && candidateAssetId && candidateAssetId === normalizedRequestedAssetId)
+                return true;
+            if (!requested)
+                return false;
+            return docPathMatches(normalizeDocPath(doc.fsPath), requested);
+        });
+        if (!matched)
+            return;
+        setSelectedDocId(matched.id);
+        onRequestedDocHandled?.();
+    }, [documents, onRequestedDocHandled, requestedDocAssetId, requestedDocPath]);
+    useEffect(() => {
+        if ((requestedDocPath || requestedDocAssetId) && !selectedDoc)
+            return;
+        if (filteredDocs.length === 0) {
+            if (selectedDocId !== null) {
+                setSelectedDocId(null);
+            }
+            return;
+        }
+        if (selectedDoc && filteredDocs.some((doc) => doc.id === selectedDoc.id))
+            return;
+        setSelectedDocId(filteredDocs[0].id);
+    }, [filteredDocs, requestedDocAssetId, requestedDocPath, selectedDoc, selectedDocId]);
+    const handleDeleteSelected = useCallback(async () => {
+        setSelectedDocId(null);
+        await fetchDocuments();
+    }, [fetchDocuments]);
+    const hasActiveFilters = searchQuery.trim().length > 0 || typeFilters.length > 0 || attachmentFilters.length > 0;
+    return {
+        documentApiBaseUrl,
+        documents,
+        filteredDocs,
+        loading,
+        error,
+        selectedDoc,
+        searchQuery,
+        typeFilters,
+        attachmentFilters,
+        hasActiveFilters,
+        setSearchQuery,
+        handleTypeFiltersChange,
+        handleAttachmentFiltersChange,
+        fetchDocuments,
+        selectDoc: (doc) => setSelectedDocId(doc?.id ?? null),
+        handleDeleteSelected,
+    };
+}

package/dist/components/task/TaskCard.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import * as Icons from 'lucide-react';
-const { MessageSquare, User, Bot, Gauge, X, ClipboardList, HelpCircle, File } = Icons;
+const { MessageSquare, User, Bot, Gauge, ClipboardList, HelpCircle, File } = Icons;
 import styles from '../../Taskforce.module.css';
 import cardStyles from './TaskCard.module.css';
 import { Markdown } from '../ui/Markdown';
@@ -15,7 +15,7 @@ import { getDocumentDownloadName } from '../../utils/documentNames';
 import { TaskStatusActions } from './TaskStatusActions';
 import { getTaskReferenceDisplayState } from '../../utils/taskReferences';
 import { getAssigneeKind, getAssigneeLabel } from '../../utils/assignees';
-import { getLatestTaskActivity, summarizeTaskActivity } from '../../utils/taskActivity';
+import { getLatestTaskActivity, getTaskActivityItems, summarizeTaskActivity } from '../../utils/taskActivity';
 import { DEFAULT_TYPE_VALUE } from '../../shared/taxonomyDefaults.js';
 import { getVisibleTaxonomiesForTasks } from '../../utils/taxonomyLifecycle.js';
 import { getInitiativeReferenceLabel, getWorkstreamReferenceLabel } from '../../utils/planningReferences';
@@ -51,6 +51,18 @@ const TaskCardInner = ({ task, searchQuery = '', copiedId = null, taxonomies = [
     const hasLegacyClass = !!styles[`priorityItem_${displayPriority}`];
     const assigneeKind = getAssigneeKind(task.assignee);
     const assigneeLabel = getAssigneeLabel(task.assignee, assigneeOptions);
+    const assigneeOption = React.useMemo(() => {
+        const value = String(task.assignee || '').trim();
+        return assigneeOptions.find((option) => String(option.value || '').trim() === value) || null;
+    }, [assigneeOptions, task.assignee]);
+    const assigneeAvatarUrl = assigneeKind !== 'unassigned' && typeof assigneeOption?.avatarUrl === 'string'
+        ? assigneeOption.avatarUrl.trim()
+        : '';
+    const assigneeAvatarAccent = assigneeKind === 'agent'
+        ? 'var(--color-violet-500, #8b5cf6)'
+        : assigneeKind === 'member'
+            ? 'var(--color-green-500, #22c55e)'
+            : 'var(--text-secondary, #888)';
     const latestActivity = React.useMemo(() => getLatestTaskActivity(task), [task]);
     const resolvedReadOnlyMode = readOnlyMode || (task.isDeleted ? 'deleted' : (isArchived ? 'archived' : null));
     const isReadOnly = resolvedReadOnlyMode !== null;
@@ -70,9 +82,7 @@ const TaskCardInner = ({ task, searchQuery = '', copiedId = null, taxonomies = [
         return undefined;
     }, [assigneeOptions, initiativeReferenceLabel, taskInitiative, taskWorkstream, workstreamReferenceLabel]);
     const latestActivityText = React.useMemo(() => summarizeTaskActivity(latestActivity, formatActivityFieldValue), [formatActivityFieldValue, latestActivity]);
-    const activityCount = Array.isArray(task.activity) && task.activity.length > 0
-        ? task.activity.length
-        : (task.comments?.length || 0);
+    const activityCount = React.useMemo(() => getTaskActivityItems(task).length, [task]);
     const cardClasses = [
         cardStyles.taskItem,
         task.status === 'on-hold' ? cardStyles.onHold : '',
@@ -286,29 +296,10 @@ const TaskCardInner = ({ task, searchQuery = '', copiedId = null, taxonomies = [
                                                     borderColor: `color-mix(in srgb, ${complexityColor}, transparent 72%)`,
                                                     gap: '4px',
                                                     padding: '0 8px'
-                                                }, children: [_jsx(Gauge, { size: 14 }), !compressed && _jsx("span", { children: complexityLabel })] }), _jsx("span", { className: styles.metaBadge, title: `Assigned to: ${assigneeLabel}`, "aria-label": assigneeKind === 'unassigned' ? 'Unassigned' : `Assigned to ${assigneeLabel}`, style: {
-                                                    backgroundColor: assigneeKind === 'agent'
-                                                        ? 'color-mix(in srgb, var(--color-violet-500, #8b5cf6), transparent 88%)'
-                                                        : assigneeKind === 'member'
-                                                            ? 'color-mix(in srgb, var(--color-green-500, #22c55e), transparent 88%)'
-                                                            : 'color-mix(in srgb, var(--text-secondary, #888), transparent 88%)',
-                                                    padding: '0 8px',
-                                                    color: assigneeKind === 'agent'
-                                                        ? 'var(--color-violet-500, #8b5cf6)'
-                                                        : assigneeKind === 'member'
-                                                            ? 'var(--color-green-500, #22c55e)'
-                                                            : 'var(--text-secondary, #888)',
-                                                    borderColor: assigneeKind === 'agent'
-                                                        ? 'color-mix(in srgb, var(--color-violet-500, #8b5cf6), transparent 72%)'
-                                                        : assigneeKind === 'member'
-                                                            ? 'color-mix(in srgb, var(--color-green-500, #22c55e), transparent 72%)'
-                                                            : 'color-mix(in srgb, var(--text-secondary, #888), transparent 70%)',
-                                                    display: 'flex',
-                                                    alignItems: 'center'
-                                                }, children: assigneeKind === 'agent'
-                                                    ? _jsx(Bot, { size: compressed ? 14 : 16 })
+                                                }, children: [_jsx(Gauge, { size: 14 }), !compressed && _jsx("span", { children: complexityLabel })] }), _jsx("span", { className: `${cardStyles.assigneeAvatarIndicator} ${assigneeKind === 'unassigned' ? cardStyles.assigneeAvatarEmpty : ''}`, title: `Assigned to: ${assigneeLabel}`, "aria-label": assigneeKind === 'unassigned' ? 'Unassigned' : `Assigned to ${assigneeLabel}`, style: { '--assignee-avatar-color': assigneeAvatarAccent }, children: assigneeAvatarUrl ? (_jsx("img", { src: assigneeAvatarUrl, alt: "", className: cardStyles.assigneeAvatarImage })) : assigneeKind === 'agent'
+                                                    ? _jsx(Bot, { size: compressed ? 18 : 20 })
                                                     : assigneeKind === 'member'
-                                                        ? _jsx(User, { size: compressed ? 14 : 16 })
-                                                        : _jsx(HelpCircle, { size: compressed ? 14 : 16 }) })] })] }) })) })] })] }));
+                                                        ? _jsx(User, { size: compressed ? 18 : 20 })
+                                                        : null })] })] }) })) })] })] }));
 };
 export const TaskCard = React.memo(TaskCardInner);

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

@@ -30,7 +30,7 @@ const baseInitiative = (overrides = {}) => ({
     createdAt: '2026-02-13T00:00:00.000Z',
     ...overrides,
 });
-describe('TaskCard parent/child progress', () => {
+describe('TaskCard planning hierarchy references', () => {
     it('renders initiative/workstream/task hierarchy references when planning context is provided', () => {
         const task = baseTask({
             id: 'task-hierarchy',
@@ -105,7 +105,7 @@ describe('TaskCard parent/child progress', () => {
         });
         render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
         expect(screen.getByText(/Latest Activity:/)).toBeInTheDocument();
-        expect(screen.getByText(/Status: task -> review/)).toBeInTheDocument();
+        expect(screen.getByText(/Status changed: Task -> Review/)).toBeInTheDocument();
         expect(screen.getByTitle('2 activity items')).toBeInTheDocument();
     });
     it('uses the current workstream reference in latest activity summaries', () => {
@@ -136,7 +136,7 @@ describe('TaskCard parent/child progress', () => {
             ]
         });
         render(_jsx(TaskCard, { task: task, taskWorkstream: baseWorkstream({ id: 'workstream-1', referenceNumber: 12 }), onClick: () => { }, onCopyId: () => { } }));
-        expect(screen.getByText(/Workstream: none -> WS-12/)).toBeInTheDocument();
+        expect(screen.getByText(/Workstream changed: none -> WS-12/)).toBeInTheDocument();
         expect(screen.queryByText(/workstream-1/i)).not.toBeInTheDocument();
     });
     it('renders named AI assignee labels from assignee options', () => {
@@ -151,6 +151,41 @@ describe('TaskCard parent/child progress', () => {
             ], onClick: () => { }, onCopyId: () => { } }));
         expect(screen.getByLabelText('Assigned to Codex')).toBeInTheDocument();
     });
+    it('renders AI profile photos in the assignee indicator when available', () => {
+        const task = baseTask({
+            id: 'task-ai-avatar',
+            title: 'AI-owned task',
+            assignee: 'ai-profile-123'
+        });
+        render(_jsx(TaskCard, { task: task, assigneeOptions: [
+                { value: 'ai-profile-123', label: 'Codex', icon: 'Bot', color: '#0ea5e9', kind: 'agent', avatarUrl: '/api/taskforce/context/ai-avatar.webp' }
+            ], onClick: () => { }, onCopyId: () => { } }));
+        const badge = screen.getByLabelText('Assigned to Codex');
+        expect(badge.querySelector('img')).toHaveAttribute('src', '/api/taskforce/context/ai-avatar.webp');
+    });
+    it('renders member profile photos in the assignee indicator when available', () => {
+        const task = baseTask({
+            id: 'task-member-avatar',
+            title: 'Member-owned task',
+            assignee: 'user-123'
+        });
+        render(_jsx(TaskCard, { task: task, assigneeOptions: [
+                { value: 'user-123', label: 'Ross Burke', icon: 'User', color: '#22c55e', kind: 'member', avatarUrl: '/api/taskforce/context/member-avatar.webp' }
+            ], onClick: () => { }, onCopyId: () => { } }));
+        const badge = screen.getByLabelText('Assigned to Ross Burke');
+        expect(badge.querySelector('img')).toHaveAttribute('src', '/api/taskforce/context/member-avatar.webp');
+    });
+    it('renders an empty avatar circle for unassigned tasks', () => {
+        const task = baseTask({
+            id: 'task-unassigned-avatar',
+            title: 'Unassigned task',
+            assignee: 'unassigned'
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        const indicator = screen.getByLabelText('Unassigned');
+        expect(indicator.querySelector('img')).toBeNull();
+        expect(indicator.querySelector('svg')).toBeNull();
+    });
     it('prefers provided type metadata over hardcoded defaults', () => {
         const task = baseTask({
             id: 'task-type-metadata',