@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/utils/taskActivity.js

@@ -1,16 +1,35 @@
 function getActivityFieldLabel(field) {
+    if (field === 'taskId')
+        return 'Task';
     if (field === 'title')
-        return 'TITLE';
+        return 'Title';
     if (field === 'description')
-        return 'DESCRIPTION';
+        return 'Description';
     if (field === 'assignee')
-        return 'ASSIGNED TO';
+        return 'Assigned to';
+    if (field === 'ownerId')
+        return 'Owner';
+    if (field === 'status')
+        return 'Status';
+    if (field === 'scheduledDate')
+        return 'Scheduled date';
+    if (field === 'dueDate')
+        return 'Due date';
     if (field === 'workstreamId')
-        return 'WORKSTREAM';
+        return 'Workstream';
     if (field === 'initiativeId')
-        return 'INITIATIVE';
+        return 'Initiative';
     return field;
 }
+function formatStatusValue(value) {
+    if (value === 'task')
+        return 'Task';
+    return value
+        .replace(/[-_]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
 function formatValue(value, field, formatter) {
     const formatted = formatter?.(field, value);
     if (typeof formatted === 'string')
@@ -23,6 +42,8 @@ function formatValue(value, field, formatter) {
     }
     if (typeof value === 'object')
         return 'updated';
+    if (field === 'status')
+        return formatStatusValue(String(value));
     return String(value);
 }
 function normalizeChecklistItems(value) {
@@ -75,10 +96,131 @@ function summarizeChecklistChange(change) {
     }
     return 'Checklist updated';
 }
+function stripQueryAndHash(value) {
+    return value.split(/[?#]/, 1)[0] || value;
+}
+function basenameFromPath(value) {
+    const normalized = stripQueryAndHash(value).replace(/\\/g, '/');
+    const segments = normalized.split('/').filter(Boolean);
+    return segments[segments.length - 1] || normalized;
+}
+function isImageAttachmentCandidate(value) {
+    return /\.(png|jpe?g|webp|gif)$/i.test(stripQueryAndHash(value));
+}
+function isDocumentAttachmentCandidate(value) {
+    if (value.includes('/api/taskforce/documents/'))
+        return true;
+    return /\.(pdf|txt|md|markdown|csv|json|docx?|html?|js|jsx|ts|tsx|css|py|java|go|rs|sh)$/i.test(stripQueryAndHash(value));
+}
+function normalizeAttachmentList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry, index) => {
+        const attachment = (entry && typeof entry === 'object' ? entry : null);
+        const path = typeof entry === 'string'
+            ? entry
+            : String(attachment?.path || '').trim();
+        const fsPath = String(attachment?.fsPath || '').trim();
+        const assetId = String(attachment?.assetId || '').trim();
+        const referenceLabel = String(attachment?.referenceLabel || '').trim();
+        const label = [
+            attachment?.displayName,
+            attachment?.originalFilename,
+            attachment?.caption,
+            referenceLabel,
+            fsPath ? basenameFromPath(fsPath) : '',
+            path ? basenameFromPath(path) : '',
+        ]
+            .map((candidate) => String(candidate || '').trim())
+            .find(Boolean) || `Attachment ${index + 1}`;
+        const key = assetId || fsPath || path || `${label}:${index}`;
+        const kindCandidates = [
+            path,
+            fsPath,
+            String(attachment?.originalFilename || '').trim(),
+            String(attachment?.displayName || '').trim(),
+            referenceLabel,
+        ].filter(Boolean);
+        const kind = kindCandidates.some((candidate) => isImageAttachmentCandidate(candidate))
+            ? 'image'
+            : (referenceLabel.startsWith('D-') || kindCandidates.some((candidate) => isDocumentAttachmentCandidate(candidate)))
+                ? 'document'
+                : 'attachment';
+        return [{ key, label, kind }];
+    });
+}
+function pluralizeAttachmentKind(kind, count) {
+    if (count === 1)
+        return kind;
+    if (kind === 'image')
+        return 'images';
+    if (kind === 'document')
+        return 'documents';
+    return 'attachments';
+}
+function describeAttachmentCollection(entries) {
+    if (entries.length === 0)
+        return 'attachments';
+    const counts = entries.reduce((acc, entry) => {
+        acc[entry.kind] += 1;
+        return acc;
+    }, { image: 0, document: 0, attachment: 0 });
+    const nonZeroParts = Object.entries(counts)
+        .filter(([, count]) => count > 0)
+        .map(([kind, count]) => count === 1 ? kind : `${count} ${pluralizeAttachmentKind(kind, count)}`);
+    if (nonZeroParts.length === 1)
+        return nonZeroParts[0];
+    if (entries.length <= 3 && nonZeroParts.length <= 2)
+        return nonZeroParts.join(' and ');
+    return `${entries.length} attachments`;
+}
+function capitalizeLeading(value) {
+    if (!value)
+        return value;
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function summarizeAttachmentChange(change) {
+    const before = normalizeAttachmentList(change?.from);
+    const after = normalizeAttachmentList(change?.to);
+    const beforeByKey = new Map(before.map((entry) => [entry.key, entry]));
+    const afterByKey = new Map(after.map((entry) => [entry.key, entry]));
+    const added = after.filter((entry) => !beforeByKey.has(entry.key));
+    const removed = before.filter((entry) => !afterByKey.has(entry.key));
+    if (added.length === 1 && removed.length === 0) {
+        return `${capitalizeLeading(added[0].kind)} attached: ${added[0].label}`;
+    }
+    if (removed.length === 1 && added.length === 0) {
+        return `${capitalizeLeading(removed[0].kind)} removed: ${removed[0].label}`;
+    }
+    if (added.length > 0 && removed.length === 0) {
+        return `${capitalizeLeading(describeAttachmentCollection(added))} attached`;
+    }
+    if (removed.length > 0 && added.length === 0) {
+        return `${capitalizeLeading(describeAttachmentCollection(removed))} removed`;
+    }
+    if (added.length === 1 && removed.length === 1) {
+        return `${capitalizeLeading(added[0].kind)} replaced: ${removed[0].label} -> ${added[0].label}`;
+    }
+    if (added.length > 0 || removed.length > 0) {
+        return `${capitalizeLeading(describeAttachmentCollection(added))} attached, ${describeAttachmentCollection(removed)} removed`;
+    }
+    const relabeled = after.filter((entry) => {
+        const previous = beforeByKey.get(entry.key);
+        return previous && previous.label !== entry.label;
+    });
+    if (relabeled.length === 1 && before.length === 1 && after.length === 1) {
+        const previous = beforeByKey.get(relabeled[0].key);
+        return `${capitalizeLeading(relabeled[0].kind)} renamed: ${previous?.label || 'Attachment'} -> ${relabeled[0].label}`;
+    }
+    return 'Attachment details updated';
+}
 export function summarizeTaskChange(field, change, formatter) {
     if (field === 'checklistItems') {
         return summarizeChecklistChange(change);
     }
+    if (field === 'attachments') {
+        return summarizeAttachmentChange(change);
+    }
     const label = getActivityFieldLabel(field);
     if (field === 'title') {
         return `${label}: updated`;
@@ -108,22 +250,28 @@ export function summarizeTaskEvent(event, formatter) {
     if (event.action === 'task-unarchived')
         return 'Task restored';
     if (event.action === 'task-status-changed' && changes.status) {
-        return `Status: ${formatValue(changes.status.from, 'status', formatter)} -> ${formatValue(changes.status.to, 'status', formatter)}`;
+        return `Status changed: ${formatValue(changes.status.from, 'status', formatter)} -> ${formatValue(changes.status.to, 'status', formatter)}`;
     }
     if (event.action === 'task-schedule-changed') {
         if (changes.scheduledDate) {
-            return `Scheduled: ${formatValue(changes.scheduledDate.from, 'scheduledDate', formatter)} -> ${formatValue(changes.scheduledDate.to, 'scheduledDate', formatter)}`;
+            return `Scheduled date changed: ${formatValue(changes.scheduledDate.from, 'scheduledDate', formatter)} -> ${formatValue(changes.scheduledDate.to, 'scheduledDate', formatter)}`;
         }
         if (changes.dueDate) {
-            return `Due: ${formatValue(changes.dueDate.from, 'dueDate', formatter)} -> ${formatValue(changes.dueDate.to, 'dueDate', formatter)}`;
+            return `Due date changed: ${formatValue(changes.dueDate.from, 'dueDate', formatter)} -> ${formatValue(changes.dueDate.to, 'dueDate', formatter)}`;
         }
         return 'Schedule updated';
     }
     if (event.action === 'task-relationship-changed' && changes.workstreamId) {
-        return `Workstream: ${formatValue(changes.workstreamId.from, 'workstreamId', formatter)} -> ${formatValue(changes.workstreamId.to, 'workstreamId', formatter)}`;
+        return `Workstream changed: ${formatValue(changes.workstreamId.from, 'workstreamId', formatter)} -> ${formatValue(changes.workstreamId.to, 'workstreamId', formatter)}`;
+    }
+    if (event.action === 'task-relationship-changed' && changes.initiativeId) {
+        return `Initiative changed: ${formatValue(changes.initiativeId.from, 'initiativeId', formatter)} -> ${formatValue(changes.initiativeId.to, 'initiativeId', formatter)}`;
+    }
+    if (event.action === 'task-attachments-changed') {
+        return changes.attachments
+            ? summarizeTaskChange('attachments', changes.attachments, formatter)
+            : 'Attachments updated';
     }
-    if (event.action === 'task-attachments-changed')
-        return 'Attachments updated';
     if (fields.length === 1) {
         const field = fields[0];
         const change = changes[field];
@@ -133,25 +281,145 @@ export function summarizeTaskEvent(event, formatter) {
         return `${fields.length} fields updated`;
     return 'Task updated';
 }
-export function getLatestTaskActivity(task) {
-    const items = Array.isArray(task.activity) && task.activity.length > 0
-        ? task.activity
-        : Array.isArray(task.comments)
-            ? task.comments.map((comment) => ({
-                id: `comment:${comment.id}`,
+export function summarizeEntityEvent(event, formatter) {
+    if (event.taskId || event.entityType === 'task') {
+        return summarizeTaskEvent(event, formatter);
+    }
+    const changes = event.details?.changes || {};
+    const fields = Object.keys(changes);
+    const entityLabel = event.entityType === 'initiative' ? 'Initiative' : 'Workstream';
+    const taskTitle = typeof event.details?.taskTitle === 'string' && event.details.taskTitle.trim().length > 0
+        ? event.details.taskTitle.trim()
+        : null;
+    if (event.action === 'initiative-created')
+        return 'Initiative created';
+    if (event.action === 'initiative-archived')
+        return 'Initiative archived';
+    if (event.action === 'initiative-unarchived')
+        return 'Initiative restored';
+    if (event.action === 'workstream-created')
+        return 'Workstream created';
+    if (event.action === 'workstream-archived')
+        return 'Workstream archived';
+    if (event.action === 'workstream-unarchived')
+        return 'Workstream restored';
+    if (event.action === 'workstream-task-added')
+        return taskTitle ? `Task added: ${taskTitle}` : 'Task added';
+    if (event.action === 'workstream-task-removed')
+        return taskTitle ? `Task removed: ${taskTitle}` : 'Task removed';
+    if (event.action === 'workstream-relationship-changed' && changes.initiativeId) {
+        return `Initiative changed: ${formatValue(changes.initiativeId.from, 'initiativeId', formatter)} -> ${formatValue(changes.initiativeId.to, 'initiativeId', formatter)}`;
+    }
+    if ((event.action === 'initiative-attachments-changed' || event.action === 'workstream-attachments-changed') && changes.attachments) {
+        return summarizeTaskChange('attachments', changes.attachments, formatter);
+    }
+    if (fields.length === 1) {
+        return summarizeTaskChange(fields[0], changes[fields[0]], formatter);
+    }
+    if (fields.length > 1)
+        return `${fields.length} fields updated`;
+    if (event.action === 'initiative-updated' || event.action === 'workstream-updated')
+        return `${entityLabel} updated`;
+    return `${entityLabel} activity updated`;
+}
+function activityTimestamp(item) {
+    const parsed = Date.parse(String(item.timestamp || ''));
+    return Number.isFinite(parsed) ? parsed : null;
+}
+export function getTaskEventPrimaryChangeField(event) {
+    const changes = event.details?.changes || {};
+    const fields = Object.keys(changes);
+    if (event.action === 'task-status-changed' && changes.status)
+        return 'status';
+    if (event.action === 'task-schedule-changed') {
+        if (changes.scheduledDate)
+            return 'scheduledDate';
+        if (changes.dueDate)
+            return 'dueDate';
+    }
+    if (event.action === 'task-relationship-changed') {
+        if (changes.workstreamId)
+            return 'workstreamId';
+        if (changes.initiativeId)
+            return 'initiativeId';
+    }
+    if (event.action === 'task-attachments-changed' && changes.attachments)
+        return 'attachments';
+    return fields.length === 1 ? fields[0] : null;
+}
+export function getEntityEventPrimaryChangeField(event) {
+    if (event.taskId || event.entityType === 'task') {
+        return getTaskEventPrimaryChangeField(event);
+    }
+    const changes = event.details?.changes || {};
+    const fields = Object.keys(changes);
+    if ((event.action === 'workstream-task-added' || event.action === 'workstream-task-removed') && event.details?.taskId)
+        return 'taskId';
+    if (event.action === 'workstream-relationship-changed' && changes.initiativeId)
+        return 'initiativeId';
+    if ((event.action === 'initiative-attachments-changed' || event.action === 'workstream-attachments-changed') && changes.attachments)
+        return 'attachments';
+    return fields.length === 1 ? fields[0] : null;
+}
+export function getEntityActivityItems(task) {
+    const deduped = new Map();
+    const commentIds = new Set();
+    const addItem = (item) => {
+        if (item.type === 'event' && item.event.action === 'task-comment-added')
+            return;
+        const key = item.type === 'comment'
+            ? `comment:${String(item.comment.id || item.id).replace(/^comment:/, '')}`
+            : `event:${String(item.event.id || item.id).replace(/^event:/, '')}`;
+        deduped.set(key, { ...item, id: key });
+        if (item.type === 'comment') {
+            commentIds.add(String(item.comment.id || item.id).replace(/^comment:/, ''));
+        }
+    };
+    if (Array.isArray(task.activity)) {
+        task.activity.forEach(addItem);
+    }
+    if (Array.isArray(task.comments)) {
+        task.comments.forEach((comment) => {
+            const commentId = String(comment.id || '').trim();
+            if (!commentId || commentIds.has(commentId))
+                return;
+            addItem({
+                id: `comment:${commentId}`,
                 type: 'comment',
                 timestamp: comment.timestamp,
                 comment
-            }))
-            : [];
+            });
+        });
+    }
+    return [...deduped.values()].sort((left, right) => {
+        const leftTs = activityTimestamp(left);
+        const rightTs = activityTimestamp(right);
+        if (leftTs !== null && rightTs !== null && leftTs !== rightTs)
+            return leftTs - rightTs;
+        if (leftTs !== null && rightTs === null)
+            return -1;
+        if (leftTs === null && rightTs !== null)
+            return 1;
+        return String(left.id || '').localeCompare(String(right.id || ''));
+    });
+}
+export function getTaskActivityItems(task) {
+    return getEntityActivityItems(task);
+}
+export function getLatestTaskActivity(task) {
+    const items = getTaskActivityItems(task);
     if (items.length === 0)
         return null;
     return [...items].sort((left, right) => {
-        const leftTs = Date.parse(String(left.timestamp || ''));
-        const rightTs = Date.parse(String(right.timestamp || ''));
-        if (Number.isFinite(leftTs) && Number.isFinite(rightTs) && leftTs !== rightTs) {
+        const leftTs = activityTimestamp(left);
+        const rightTs = activityTimestamp(right);
+        if (leftTs !== null && rightTs !== null && leftTs !== rightTs) {
             return rightTs - leftTs;
         }
+        if (leftTs !== null && rightTs === null)
+            return -1;
+        if (leftTs === null && rightTs !== null)
+            return 1;
         return String(right.id || '').localeCompare(String(left.id || ''));
     })[0] || null;
 }

package/dist/utils/taskActivity.test.js

@@ -1,32 +1,32 @@
 import { describe, expect, it } from 'vitest';
-import { summarizeTaskChange, summarizeTaskEvent } from './taskActivity';
+import { getTaskActivityItems, summarizeEntityEvent, summarizeTaskChange, summarizeTaskEvent } from './taskActivity';
 describe('summarizeTaskChange', () => {
     it('summarizes title edits without dumping before and after text', () => {
         expect(summarizeTaskChange('title', {
             from: 'Old title',
             to: 'New title',
-        })).toBe('TITLE: updated');
+        })).toBe('Title: updated');
     });
-    it('summarizes assignee changes with uppercase labels and formatted values', () => {
+    it('summarizes assignee changes with sentence-case labels and formatted values', () => {
         expect(summarizeTaskChange('assignee', { from: 'unassigned', to: 'member-1' }, (_field, value) => {
             if (value === 'unassigned')
                 return 'Unassigned';
             if (value === 'member-1')
                 return 'Emma Peel';
             return undefined;
-        })).toBe('ASSIGNED TO: Unassigned -> Emma Peel');
+        })).toBe('Assigned to: Unassigned -> Emma Peel');
     });
     it('summarizes description additions without rendering the body text', () => {
         expect(summarizeTaskChange('description', {
             from: '',
             to: 'Line one\n\nLine two',
-        })).toBe('DESCRIPTION: added');
+        })).toBe('Description: added');
     });
     it('summarizes description clears without rendering the old body text', () => {
         expect(summarizeTaskChange('description', {
             from: 'Old body',
             to: '',
-        })).toBe('DESCRIPTION: cleared');
+        })).toBe('Description: cleared');
     });
     it('summarizes checklist completion clearly', () => {
         expect(summarizeTaskChange('checklistItems', {
@@ -59,7 +59,49 @@ describe('summarizeTaskChange', () => {
         })).toBe('Checklist reordered');
     });
     it('uses readable labels for workstream relationship changes', () => {
-        expect(summarizeTaskChange('workstreamId', { from: null, to: 'workstream-1' }, (_field, value) => value === 'workstream-1' ? 'WS-12' : undefined)).toBe('WORKSTREAM: none -> WS-12');
+        expect(summarizeTaskChange('workstreamId', { from: null, to: 'workstream-1' }, (_field, value) => value === 'workstream-1' ? 'WS-12' : undefined)).toBe('Workstream: none -> WS-12');
+    });
+    it('summarizes image attachment additions clearly', () => {
+        expect(summarizeTaskChange('attachments', {
+            from: [],
+            to: [{
+                    path: '/api/taskforce/context/workspaces/default/assets/images/homepage-proof.png',
+                    caption: 'Homepage proof',
+                }],
+        })).toBe('Image attached: Homepage proof');
+    });
+    it('summarizes document attachment removals clearly', () => {
+        expect(summarizeTaskChange('attachments', {
+            from: [{
+                    path: '/api/taskforce/documents/asset-doc-1/content',
+                    originalFilename: 'spec.md',
+                    assetId: 'asset-doc-1',
+                }],
+            to: [],
+        })).toBe('Document removed: spec.md');
+    });
+    it('summarizes multiple document attachments concisely', () => {
+        expect(summarizeTaskChange('attachments', {
+            from: [],
+            to: [
+                { path: '/api/taskforce/documents/asset-doc-1/content', originalFilename: 'spec.md', assetId: 'asset-doc-1' },
+                { path: '/api/taskforce/documents/asset-doc-2/content', originalFilename: 'notes.pdf', assetId: 'asset-doc-2' },
+            ],
+        })).toBe('2 documents attached');
+    });
+    it('summarizes attachment renames when the same asset remains attached', () => {
+        expect(summarizeTaskChange('attachments', {
+            from: [{
+                    path: '/api/taskforce/documents/asset-doc-1/content',
+                    assetId: 'asset-doc-1',
+                    caption: 'Draft spec',
+                }],
+            to: [{
+                    path: '/api/taskforce/documents/asset-doc-1/content',
+                    assetId: 'asset-doc-1',
+                    caption: 'Final spec',
+                }],
+        })).toBe('Document renamed: Draft spec -> Final spec');
     });
 });
 describe('summarizeTaskEvent', () => {
@@ -80,6 +122,97 @@ describe('summarizeTaskEvent', () => {
                     },
                 },
             },
-        }, (_field, value) => value === 'workstream-1' ? 'WS-12' : undefined)).toBe('Workstream: none -> WS-12');
+        }, (_field, value) => value === 'workstream-1' ? 'WS-12' : undefined)).toBe('Workstream changed: none -> WS-12');
+    });
+    it('uses attachment-specific summaries for attachment activity events', () => {
+        expect(summarizeTaskEvent({
+            id: 'event-2',
+            taskId: 'task-1',
+            workspaceId: 'default',
+            action: 'task-attachments-changed',
+            actor: 'user',
+            actorType: 'human',
+            createdAt: '2026-04-12T21:42:00.000Z',
+            details: {
+                changes: {
+                    attachments: {
+                        from: [{
+                                path: '/api/taskforce/context/workspaces/default/assets/images/old-proof.png',
+                                caption: 'Old proof',
+                            }],
+                        to: [{
+                                path: '/api/taskforce/context/workspaces/default/assets/images/new-proof.png',
+                                caption: 'New proof',
+                            }],
+                    },
+                },
+            },
+        })).toBe('Image replaced: Old proof -> New proof');
+    });
+    it('uses task-focused summaries for workstream task relationship events', () => {
+        expect(summarizeEntityEvent({
+            id: 'event-3',
+            workspaceId: 'default',
+            entityType: 'workstream',
+            entityId: 'workstream-1',
+            action: 'workstream-task-added',
+            actor: 'user',
+            actorType: 'human',
+            createdAt: '2026-04-12T21:42:00.000Z',
+            details: {
+                taskId: 'task-1',
+                taskTitle: 'Ship launch checklist',
+                changes: {
+                    workstreamId: {
+                        from: null,
+                        to: 'workstream-1',
+                    },
+                },
+            },
+        })).toBe('Task added: Ship launch checklist');
+    });
+});
+describe('getTaskActivityItems', () => {
+    it('combines comments and audit events while hiding duplicate comment-added events', () => {
+        const items = getTaskActivityItems({
+            comments: [{
+                    id: 'comment-1',
+                    author: 'user',
+                    text: 'Captured comment',
+                    timestamp: '2026-03-22T10:00:00.000Z',
+                }],
+            activity: [
+                {
+                    id: 'event:event-1',
+                    type: 'event',
+                    timestamp: '2026-03-22T09:00:00.000Z',
+                    event: {
+                        id: 'event-1',
+                        taskId: 'task-1',
+                        workspaceId: 'default',
+                        action: 'task-status-changed',
+                        actor: 'user',
+                        actorType: 'human',
+                        createdAt: '2026-03-22T09:00:00.000Z',
+                        details: { changes: { status: { from: 'task', to: 'in-progress' } } },
+                    },
+                },
+                {
+                    id: 'event:comment-event-1',
+                    type: 'event',
+                    timestamp: '2026-03-22T10:00:00.000Z',
+                    event: {
+                        id: 'comment-event-1',
+                        taskId: 'task-1',
+                        workspaceId: 'default',
+                        action: 'task-comment-added',
+                        actor: 'user',
+                        actorType: 'human',
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                    },
+                },
+            ],
+        });
+        expect(items.map((item) => item.id)).toEqual(['event:event-1', 'comment:comment-1']);
     });
 });

package/dist/utils/taskSearch.d.ts

@@ -0,0 +1,22 @@
+import type { CategoryConfig, PriorityDefinition, TaskItem, TaxonomyDefinition } from '../types';
+import type { TaskAssigneeOption } from './assignees';
+export interface NormalizedTaskSearchQuery {
+    raw: string;
+    tokens: string[];
+    referenceToken: string | null;
+}
+export interface TaskSearchContext {
+    categories?: CategoryConfig[];
+    types?: Array<{
+        value: string | number;
+        label: string;
+    }>;
+    priorities?: PriorityDefinition[];
+    assigneeOptions?: TaskAssigneeOption[];
+    taxonomies?: TaxonomyDefinition[];
+}
+export declare function normalizeSearchText(value: unknown): string;
+export declare function normalizeTaskReferenceToken(value: unknown): string | null;
+export declare function normalizeTaskSearchQuery(query: string): NormalizedTaskSearchQuery;
+export declare function getTaskSearchFields(task: TaskItem, context?: TaskSearchContext): string[];
+export declare function taskMatchesSearch(task: TaskItem, query: string | NormalizedTaskSearchQuery, context?: TaskSearchContext): boolean;

package/dist/utils/taskSearch.js

@@ -0,0 +1,87 @@
+import { STATUS_OPTIONS } from './constants';
+import { getTaskReferenceLabel } from './taskReferences';
+const DASH_LIKE_PATTERN = /[\u2010-\u2015\u2212]/g;
+export function normalizeSearchText(value) {
+    return String(value ?? '')
+        .trim()
+        .replace(DASH_LIKE_PATTERN, '-')
+        .replace(/\s+/g, ' ')
+        .toLowerCase();
+}
+export function normalizeTaskReferenceToken(value) {
+    const normalized = normalizeSearchText(value);
+    if (!normalized)
+        return null;
+    const match = normalized.match(/^(l\s*t|t)\s*(?:-\s*)?(\d+)$/i);
+    if (!match)
+        return null;
+    const prefix = match[1].replace(/\s+/g, '').toLowerCase();
+    return `${prefix}-${match[2]}`;
+}
+export function normalizeTaskSearchQuery(query) {
+    const raw = normalizeSearchText(query);
+    return {
+        raw,
+        tokens: raw ? raw.split(' ').filter(Boolean) : [],
+        referenceToken: normalizeTaskReferenceToken(query)
+    };
+}
+function addValue(values, value) {
+    const normalized = String(value ?? '').trim();
+    if (normalized)
+        values.push(normalized);
+}
+function addMappedLabel(values, options, targetValue) {
+    const target = String(targetValue ?? '').trim();
+    if (!target)
+        return;
+    const option = options?.find((entry) => String(entry.value) === target);
+    addValue(values, option?.label);
+}
+export function getTaskSearchFields(task, context = {}) {
+    const values = [];
+    addValue(values, task.title);
+    addValue(values, task.description);
+    addValue(values, task.id);
+    addValue(values, getTaskReferenceLabel(task));
+    addValue(values, task.category);
+    addValue(values, task.type);
+    addValue(values, task.priority);
+    addValue(values, task.status);
+    addValue(values, task.assignee || 'unassigned');
+    addValue(values, task.canceledReason);
+    addMappedLabel(values, context.categories, task.category);
+    addMappedLabel(values, context.types, task.type);
+    addMappedLabel(values, context.priorities, task.priority);
+    addMappedLabel(values, STATUS_OPTIONS, task.status);
+    addMappedLabel(values, context.assigneeOptions, task.assignee || 'unassigned');
+    Object.entries(task.taxonomies || {}).forEach(([taxonomyId, taskValue]) => {
+        const taxonomy = context.taxonomies?.find((entry) => entry.id === taxonomyId);
+        addValue(values, taxonomy?.label);
+        const taskValues = Array.isArray(taskValue) ? taskValue : [taskValue];
+        taskValues.forEach((value) => {
+            addValue(values, value);
+            addMappedLabel(values, taxonomy?.options, value);
+        });
+    });
+    return values;
+}
+export function taskMatchesSearch(task, query, context = {}) {
+    const normalizedQuery = typeof query === 'string' ? normalizeTaskSearchQuery(query) : query;
+    if (!normalizedQuery.raw)
+        return true;
+    const fields = getTaskSearchFields(task, context);
+    const normalizedFields = fields.map(normalizeSearchText).filter(Boolean);
+    const joinedFields = normalizedFields.join(' ');
+    if (joinedFields.includes(normalizedQuery.raw))
+        return true;
+    if (normalizedQuery.referenceToken) {
+        const referenceMatches = fields
+            .map(normalizeTaskReferenceToken)
+            .some((referenceToken) => referenceToken?.includes(normalizedQuery.referenceToken));
+        if (referenceMatches)
+            return true;
+    }
+    return normalizedQuery.tokens.length > 0
+        && normalizedQuery.tokens.every((token) => joinedFields.includes(token));
+}

package/dist/utils/taskSearch.test.d.ts

@@ -0,0 +1 @@
+export {};