@taskforcehq/taskforce 0.3.305 → 0.3.306

package/dist/utils/syncEventPresentation.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { areSyncEventListsEqual, formatSyncEventLine, getSyncEventStableKey, mergeRecentSyncEvents, } from './syncEventPresentation';
+describe('syncEventPresentation', () => {
+    it('formats blocked manual retry events with the local reason and phase', () => {
+        const line = formatSyncEventLine({
+            occurredAt: '2026-04-18T18:00:00.000Z',
+            eventType: 'pull',
+            status: 'error',
+            errorMessage: 'Manual sync retry blocked: sign in is required.',
+            details: {
+                source: 'retry.blocked',
+                reason: 'auth-required',
+                phase: 'active'
+            }
+        });
+        expect(line).toBe('2026-04-18T18:00:00.000Z manual retry blocked: sign in required during active sync');
+    });
+    it('formats manual repair start events with the chosen repair phase', () => {
+        const line = formatSyncEventLine({
+            occurredAt: '2026-04-18T18:05:00.000Z',
+            eventType: 'bootstrap',
+            status: 'success',
+            errorMessage: 'Manual sync repair started.',
+            details: {
+                source: 'repair.started',
+                phase: 'error',
+                repairPhase: 'attach-cloud'
+            }
+        });
+        expect(line).toBe('2026-04-18T18:05:00.000Z manual repair started: initial cloud pull selected');
+    });
+    it('falls back to the generic event formatter for normal sync events', () => {
+        const line = formatSyncEventLine({
+            occurredAt: '2026-04-18T18:10:00.000Z',
+            eventType: 'push',
+            status: 'success',
+            changeCount: 3,
+            requestMs: 42
+        });
+        expect(line).toBe('2026-04-18T18:10:00.000Z push succeeded (3 changes) in 42ms');
+    });
+    it('deduplicates and compares event lists using stable keys', () => {
+        const event = {
+            occurredAt: '2026-04-18T18:10:00.000Z',
+            eventType: 'push',
+            status: 'success',
+            changeCount: 1
+        };
+        const merged = mergeRecentSyncEvents([event], [event], 15);
+        expect(merged).toHaveLength(1);
+        expect(areSyncEventListsEqual(merged, [event])).toBe(true);
+        expect(getSyncEventStableKey(event)).toContain('2026-04-18T18:10:00.000Z');
+    });
+    it('builds stable keys even when event details contain circular or bigint values', () => {
+        const circular = { count: 3n };
+        circular.self = circular;
+        expect(() => getSyncEventStableKey({
+            occurredAt: '2026-04-18T18:10:00.000Z',
+            eventType: 'apply',
+            status: 'error',
+            details: circular
+        })).not.toThrow();
+    });
+});

package/dist/utils/syncStatusPresentation.d.ts

@@ -0,0 +1,72 @@
+import type { HeaderWorkspaceSyncStatus } from './workspaceSyncPresentation';
+import { type SyncEventRecord } from './syncEventPresentation';
+export interface SyncStatusMeta {
+    label: string;
+    icon: 'off' | 'cloud';
+    color: string;
+    border: string;
+    background: string;
+}
+export interface ReferenceMismatchSummary {
+    key: string;
+    pathLabel: string;
+    refsLabel?: string | null;
+}
+export interface SyncSummaryItem {
+    label: string;
+    value: string;
+}
+export interface SyncEventRow {
+    key: string;
+    text: string;
+    tone?: 'error' | 'muted' | 'default';
+}
+export interface WorkspaceSyncDiagnosticsPresentation {
+    lastErrorAt?: string | null;
+    pushBlockedReason?: string | null;
+    pullBlockedReason?: string | null;
+    retryBlockedReason?: string | null;
+    repairActive?: boolean;
+    pushInFlight?: boolean;
+    pullInFlight?: boolean;
+    retryPending?: boolean;
+    aiProfileSnapshotCount: number;
+    aiProfileSnapshotRawCount: number;
+    lastPushedAiProfileCount: number;
+    lastPushedAiProfileWatermarkCount: number;
+    aiProfileSnapshotLastFetchAt?: string | null;
+    aiProfileSnapshotLastFetchError?: string | null;
+    aiProfileSnapshotLastSkipReason?: string | null;
+    documentSnapshotCount: number;
+    assetSnapshotCount: number;
+    forceFullAiProfilePushQueued?: boolean;
+}
+interface BuildSyncEventRowsInput {
+    syncRecentEvents: SyncEventRecord[];
+    syncRecentEventsError: string | null;
+    syncRecentEventsLoading: boolean;
+}
+interface BuildCopySyncDetailsTextInput {
+    currentWorkspaceId: string;
+    syncStatusLabel: string;
+    workspaceSyncSummary: string;
+    workspaceSyncRecommendedAction: string;
+    formattedLastSyncTime: string;
+    formattedLastPullTime: string;
+    formattedLastPushTime: string;
+    workspaceSyncDiagnostics: WorkspaceSyncDiagnosticsPresentation;
+    workspaceSyncPendingChanges: string | number;
+    syncLastError: string;
+    syncStageLabel: string;
+    referenceMismatchCount: number;
+    syncRecentEvents: SyncEventRecord[];
+}
+export declare function resolveSyncStatusMeta(status: HeaderWorkspaceSyncStatus): SyncStatusMeta;
+export declare function resolveSyncStageLabel(workspaceSyncPhase: string, workspaceSyncRepairBusy: boolean, workspaceSyncBusy: boolean): string;
+export declare function buildSyncDiagnosticsSummary(workspaceSyncDiagnostics: WorkspaceSyncDiagnosticsPresentation): SyncSummaryItem[];
+export declare function buildSyncEventRows({ syncRecentEvents, syncRecentEventsError, syncRecentEventsLoading, }: BuildSyncEventRowsInput): SyncEventRow[];
+export declare function getActiveReferenceMismatchEvents(events: SyncEventRecord[]): SyncEventRecord[];
+export declare function getActiveReferenceMismatchCount(events: SyncEventRecord[]): number;
+export declare function buildReferenceMismatchSummaries(events: SyncEventRecord[]): ReferenceMismatchSummary[];
+export declare function buildCopySyncDetailsText({ currentWorkspaceId, syncStatusLabel, workspaceSyncSummary, workspaceSyncRecommendedAction, formattedLastSyncTime, formattedLastPullTime, formattedLastPushTime, workspaceSyncDiagnostics, workspaceSyncPendingChanges, syncLastError, syncStageLabel, referenceMismatchCount, syncRecentEvents, }: BuildCopySyncDetailsTextInput): string;
+export {};

package/dist/utils/syncStatusPresentation.js

@@ -0,0 +1,217 @@
+import { formatSyncEventLine, getSyncEventStableKey, } from './syncEventPresentation';
+function formatDiagnosticsTimestamp(value) {
+    if (!value)
+        return 'Never';
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()))
+        return 'Never';
+    return parsed.toLocaleString();
+}
+export function resolveSyncStatusMeta(status) {
+    switch (status) {
+        case 'off':
+            return {
+                label: 'Off',
+                icon: 'off',
+                color: '#94a3b8',
+                border: 'rgba(148, 163, 184, 0.35)',
+                background: 'rgba(148, 163, 184, 0.12)',
+            };
+        case 'syncing':
+            return {
+                label: 'Syncing',
+                icon: 'cloud',
+                color: '#60a5fa',
+                border: 'rgba(96, 165, 250, 0.35)',
+                background: 'rgba(59, 130, 246, 0.12)',
+            };
+        case 'attention':
+            return {
+                label: 'Needs Attention',
+                icon: 'cloud',
+                color: '#fda4af',
+                border: 'rgba(253, 164, 175, 0.4)',
+                background: 'rgba(239, 68, 68, 0.12)',
+            };
+        default:
+            return {
+                label: 'Healthy',
+                icon: 'cloud',
+                color: '#86efac',
+                border: 'rgba(134, 239, 172, 0.4)',
+                background: 'rgba(34, 197, 94, 0.12)',
+            };
+    }
+}
+export function resolveSyncStageLabel(workspaceSyncPhase, workspaceSyncRepairBusy, workspaceSyncBusy) {
+    if (workspaceSyncRepairBusy) {
+        return 'Repairing';
+    }
+    if (workspaceSyncBusy && workspaceSyncPhase === 'error') {
+        return 'Recovering';
+    }
+    switch (workspaceSyncPhase) {
+        case 'provision-local':
+            return 'Initial cloud upload';
+        case 'attach-cloud':
+            return 'Initial cloud pull';
+        case 'active':
+            return 'Active';
+        case 'error':
+            return 'Error';
+        default:
+            return 'Idle';
+    }
+}
+export function buildSyncDiagnosticsSummary(workspaceSyncDiagnostics) {
+    return [
+        {
+            label: 'AI profile snapshot',
+            value: `${workspaceSyncDiagnostics.aiProfileSnapshotCount} local profile${workspaceSyncDiagnostics.aiProfileSnapshotCount === 1 ? '' : 's'}`,
+        },
+        {
+            label: 'AI profile raw response',
+            value: `${workspaceSyncDiagnostics.aiProfileSnapshotRawCount} from route`,
+        },
+        {
+            label: 'Last pushed AI profiles',
+            value: `${workspaceSyncDiagnostics.lastPushedAiProfileCount} tracked`,
+        },
+        {
+            label: 'AI watermark map',
+            value: `${workspaceSyncDiagnostics.lastPushedAiProfileWatermarkCount} tracked`,
+        },
+        {
+            label: 'Document snapshot',
+            value: `${workspaceSyncDiagnostics.documentSnapshotCount} local doc${workspaceSyncDiagnostics.documentSnapshotCount === 1 ? '' : 's'}`,
+        },
+        {
+            label: 'Asset snapshot',
+            value: `${workspaceSyncDiagnostics.assetSnapshotCount} local asset${workspaceSyncDiagnostics.assetSnapshotCount === 1 ? '' : 's'}`,
+        },
+        {
+            label: 'Queued full AI sync',
+            value: workspaceSyncDiagnostics.forceFullAiProfilePushQueued ? 'Yes' : 'No',
+        },
+        {
+            label: 'AI snapshot last fetch',
+            value: formatDiagnosticsTimestamp(workspaceSyncDiagnostics.aiProfileSnapshotLastFetchAt),
+        },
+        {
+            label: 'AI snapshot fetch error',
+            value: workspaceSyncDiagnostics.aiProfileSnapshotLastFetchError || 'None',
+        },
+        {
+            label: 'AI snapshot skip reason',
+            value: workspaceSyncDiagnostics.aiProfileSnapshotLastSkipReason || 'None',
+        },
+    ];
+}
+export function buildSyncEventRows({ syncRecentEvents, syncRecentEventsError, syncRecentEventsLoading, }) {
+    if (syncRecentEventsLoading && syncRecentEvents.length === 0) {
+        return [{
+                key: 'loading',
+                text: 'Loading recent sync events...',
+                tone: 'muted',
+            }];
+    }
+    if (syncRecentEventsError) {
+        return [{
+                key: 'error',
+                text: syncRecentEventsError,
+                tone: 'error',
+            }];
+    }
+    if (syncRecentEvents.length === 0) {
+        return [{
+                key: 'empty',
+                text: 'No recent sync events recorded.',
+                tone: 'muted',
+            }];
+    }
+    return syncRecentEvents.map((event, index) => ({
+        key: getSyncEventStableKey(event, index),
+        text: formatSyncEventLine(event),
+        tone: event.status === 'error' ? 'error' : 'default',
+    }));
+}
+export function getActiveReferenceMismatchEvents(events) {
+    const mismatches = [];
+    for (const event of events) {
+        const message = String(event.errorMessage || '').toLowerCase();
+        if (message.includes('reference number mismatch')) {
+            mismatches.push(event);
+            continue;
+        }
+        if (String(event.status || '').toLowerCase() === 'success') {
+            break;
+        }
+    }
+    return mismatches;
+}
+export function getActiveReferenceMismatchCount(events) {
+    return getActiveReferenceMismatchEvents(events).length;
+}
+export function buildReferenceMismatchSummaries(events) {
+    return getActiveReferenceMismatchEvents(events).map((event, index) => {
+        const details = event.details && typeof event.details === 'object' ? event.details : null;
+        const pathValue = String(details?.path || '').trim();
+        const referenceLabelValue = String(details?.referenceLabel || '').trim();
+        const taskTitleValue = String(details?.taskTitle || details?.existingTaskTitle || '').trim();
+        const existingRefValue = Number(details?.existingReferenceNumber);
+        const incomingRefValue = Number(details?.incomingReferenceNumber);
+        const pathLabel = pathValue || taskTitleValue || referenceLabelValue || `Mismatch ${index + 1}`;
+        const refsLabel = (Number.isFinite(existingRefValue)
+            || Number.isFinite(incomingRefValue))
+            ? `Existing ${Number.isFinite(existingRefValue) ? existingRefValue : '?'} vs incoming ${Number.isFinite(incomingRefValue) ? incomingRefValue : '?'}`
+            : referenceLabelValue
+                ? `Both claimed ${referenceLabelValue}`
+                : null;
+        return {
+            key: getSyncEventStableKey(event, index),
+            pathLabel,
+            refsLabel,
+        };
+    });
+}
+export function buildCopySyncDetailsText({ currentWorkspaceId, syncStatusLabel, workspaceSyncSummary, workspaceSyncRecommendedAction, formattedLastSyncTime, formattedLastPullTime, formattedLastPushTime, workspaceSyncDiagnostics, workspaceSyncPendingChanges, syncLastError, syncStageLabel, referenceMismatchCount, syncRecentEvents, }) {
+    const details = [
+        'Taskforce Sync Manager',
+        `Workspace ID: ${currentWorkspaceId}`,
+        `Status: ${syncStatusLabel}`,
+        `Summary: ${workspaceSyncSummary}`,
+        `Recommended action: ${workspaceSyncRecommendedAction}`,
+        `Last successful sync: ${formattedLastSyncTime}`,
+        `Last pull from cloud: ${formattedLastPullTime}`,
+        `Last push to cloud: ${formattedLastPushTime}`,
+        `Last error at: ${formatDiagnosticsTimestamp(workspaceSyncDiagnostics.lastErrorAt)}`,
+        `Pending local changes: ${workspaceSyncPendingChanges}`,
+        `Last error: ${syncLastError}`,
+        `Sync stage: ${syncStageLabel}`,
+        `Push blocked reason: ${workspaceSyncDiagnostics.pushBlockedReason || 'None'}`,
+        `Pull blocked reason: ${workspaceSyncDiagnostics.pullBlockedReason || 'None'}`,
+        `Retry blocked reason: ${workspaceSyncDiagnostics.retryBlockedReason || 'None'}`,
+        `Repair active: ${workspaceSyncDiagnostics.repairActive ? 'Yes' : 'No'}`,
+        `Push in flight: ${workspaceSyncDiagnostics.pushInFlight ? 'Yes' : 'No'}`,
+        `Pull in flight: ${workspaceSyncDiagnostics.pullInFlight ? 'Yes' : 'No'}`,
+        `Retry pending: ${workspaceSyncDiagnostics.retryPending ? 'Yes' : 'No'}`,
+        `AI profile snapshot: ${workspaceSyncDiagnostics.aiProfileSnapshotCount}`,
+        `AI profile raw response: ${workspaceSyncDiagnostics.aiProfileSnapshotRawCount}`,
+        `Last pushed AI profiles tracked: ${workspaceSyncDiagnostics.lastPushedAiProfileCount}`,
+        `AI profile watermarks tracked: ${workspaceSyncDiagnostics.lastPushedAiProfileWatermarkCount}`,
+        `AI snapshot last fetch: ${formatDiagnosticsTimestamp(workspaceSyncDiagnostics.aiProfileSnapshotLastFetchAt)}`,
+        `AI snapshot fetch error: ${workspaceSyncDiagnostics.aiProfileSnapshotLastFetchError || 'None'}`,
+        `AI snapshot skip reason: ${workspaceSyncDiagnostics.aiProfileSnapshotLastSkipReason || 'None'}`,
+        `Document snapshot: ${workspaceSyncDiagnostics.documentSnapshotCount}`,
+        `Asset snapshot: ${workspaceSyncDiagnostics.assetSnapshotCount}`,
+        `Reference mismatches detected: ${referenceMismatchCount}`,
+        `Queued full AI sync: ${workspaceSyncDiagnostics.forceFullAiProfilePushQueued ? 'Yes' : 'No'}`,
+    ];
+    const recentEventLines = syncRecentEvents.map((event) => formatSyncEventLine(event));
+    return [
+        ...details,
+        '',
+        'Recent sync events',
+        ...(recentEventLines.length > 0 ? recentEventLines : ['No recent sync events recorded.']),
+    ].join('\n');
+}

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

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

package/dist/utils/syncStatusPresentation.test.js

@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest';
+import { buildCopySyncDetailsText, buildReferenceMismatchSummaries, buildSyncDiagnosticsSummary, buildSyncEventRows, getActiveReferenceMismatchCount, resolveSyncStageLabel, resolveSyncStatusMeta, } from './syncStatusPresentation';
+describe('syncStatusPresentation', () => {
+    it('resolves sync status badges for visible header states', () => {
+        expect(resolveSyncStatusMeta('healthy')).toMatchObject({
+            label: 'Healthy',
+            icon: 'cloud',
+        });
+        expect(resolveSyncStatusMeta('attention')).toMatchObject({
+            label: 'Needs Attention',
+            icon: 'cloud',
+        });
+        expect(resolveSyncStatusMeta('off')).toMatchObject({
+            label: 'Off',
+            icon: 'off',
+        });
+    });
+    it('describes startup and repair stages for the sync manager', () => {
+        expect(resolveSyncStageLabel('attach-cloud', false, true)).toBe('Initial cloud pull');
+        expect(resolveSyncStageLabel('error', true, true)).toBe('Repairing');
+        expect(resolveSyncStageLabel('error', false, true)).toBe('Recovering');
+    });
+    it('builds the diagnostics summary from sync snapshot counts', () => {
+        const summary = buildSyncDiagnosticsSummary({
+            aiProfileSnapshotCount: 2,
+            aiProfileSnapshotRawCount: 4,
+            lastPushedAiProfileCount: 3,
+            lastPushedAiProfileWatermarkCount: 5,
+            documentSnapshotCount: 1,
+            assetSnapshotCount: 2,
+            forceFullAiProfilePushQueued: true,
+            aiProfileSnapshotLastFetchAt: null,
+            aiProfileSnapshotLastFetchError: '',
+            aiProfileSnapshotLastSkipReason: null,
+        });
+        expect(summary).toContainEqual({
+            label: 'AI profile snapshot',
+            value: '2 local profiles',
+        });
+        expect(summary).toContainEqual({
+            label: 'Document snapshot',
+            value: '1 local doc',
+        });
+        expect(summary).toContainEqual({
+            label: 'Queued full AI sync',
+            value: 'Yes',
+        });
+    });
+    it('keeps only active reference mismatches until the next successful sync event', () => {
+        const events = [
+            {
+                occurredAt: '2026-04-18T10:00:00.000Z',
+                status: 'error',
+                errorMessage: 'Detected task reference number mismatch during normal sync.',
+                details: {
+                    path: 'docs/spec.md',
+                    existingReferenceNumber: 14,
+                    incomingReferenceNumber: 8,
+                },
+            },
+            {
+                occurredAt: '2026-04-18T09:59:00.000Z',
+                status: 'success',
+                errorMessage: '',
+            },
+            {
+                occurredAt: '2026-04-18T09:58:00.000Z',
+                status: 'error',
+                errorMessage: 'Detected task reference number mismatch during normal sync.',
+            },
+        ];
+        expect(getActiveReferenceMismatchCount(events)).toBe(1);
+        expect(buildReferenceMismatchSummaries(events)).toEqual([
+            expect.objectContaining({
+                pathLabel: 'docs/spec.md',
+                refsLabel: 'Existing 14 vs incoming 8',
+            }),
+        ]);
+    });
+    it('builds readable sync event rows for loading, errors, and structured events', () => {
+        expect(buildSyncEventRows({
+            syncRecentEvents: [],
+            syncRecentEventsError: null,
+            syncRecentEventsLoading: true,
+        })).toEqual([{
+                key: 'loading',
+                text: 'Loading recent sync events...',
+                tone: 'muted',
+            }]);
+        expect(buildSyncEventRows({
+            syncRecentEvents: [],
+            syncRecentEventsError: 'Unable to load events.',
+            syncRecentEventsLoading: false,
+        })).toEqual([{
+                key: 'error',
+                text: 'Unable to load events.',
+                tone: 'error',
+            }]);
+        expect(buildSyncEventRows({
+            syncRecentEvents: [{
+                    occurredAt: '2026-04-18T10:00:00.000Z',
+                    status: 'error',
+                    details: {
+                        source: 'retry.blocked',
+                        reason: 'lease-held',
+                        phase: 'active',
+                    },
+                }],
+            syncRecentEventsError: null,
+            syncRecentEventsLoading: false,
+        })[0]).toMatchObject({
+            tone: 'error',
+            text: '2026-04-18T10:00:00.000Z manual retry blocked: another window is already syncing during active sync',
+        });
+    });
+    it('assembles the sync manager report text from the current view model', () => {
+        const report = buildCopySyncDetailsText({
+            currentWorkspaceId: 'workspace-123',
+            syncStatusLabel: 'Needs Attention',
+            workspaceSyncSummary: 'Sync is paused until you sign in again.',
+            workspaceSyncRecommendedAction: 'Sign in, then press Sync to retry.',
+            formattedLastSyncTime: '4/17/2026, 10:32:47 PM',
+            formattedLastPullTime: '4/17/2026, 10:32:47 PM',
+            formattedLastPushTime: '4/17/2026, 10:31:45 PM',
+            workspaceSyncDiagnostics: {
+                lastErrorAt: '2026-04-18T01:33:05.980Z',
+                pushBlockedReason: 'attach-cloud',
+                pullBlockedReason: null,
+                retryBlockedReason: 'auth-required',
+                repairActive: false,
+                pushInFlight: false,
+                pullInFlight: true,
+                retryPending: false,
+                aiProfileSnapshotCount: 14,
+                aiProfileSnapshotRawCount: 14,
+                lastPushedAiProfileCount: 14,
+                lastPushedAiProfileWatermarkCount: 14,
+                aiProfileSnapshotLastFetchAt: '2026-04-18T11:15:52.000Z',
+                aiProfileSnapshotLastFetchError: null,
+                aiProfileSnapshotLastSkipReason: null,
+                documentSnapshotCount: 127,
+                assetSnapshotCount: 56,
+                forceFullAiProfilePushQueued: false,
+            },
+            workspaceSyncPendingChanges: 31,
+            syncLastError: 'Detected task reference number mismatch during normal sync.',
+            syncStageLabel: 'Active',
+            referenceMismatchCount: 3,
+            syncRecentEvents: [{
+                    occurredAt: '2026-04-18T01:33:06.044Z',
+                    eventType: 'apply',
+                    status: 'success',
+                    changeCount: 200,
+                    requestMs: 167,
+                    statusCode: 0,
+                }],
+        });
+        expect(report).toContain('Workspace ID: workspace-123');
+        expect(report).toContain('Push blocked reason: attach-cloud');
+        expect(report).toContain('Retry blocked reason: auth-required');
+        expect(report).toContain('Reference mismatches detected: 3');
+        expect(report).toContain('2026-04-18T01:33:06.044Z apply succeeded (200 changes) in 167ms [0]');
+    });
+});

package/dist/utils/taskActivity.d.ts

@@ -5,5 +5,7 @@ export declare function summarizeTaskChange(field: string, change: {
     to?: unknown;
 } | undefined, formatter?: TaskEventValueFormatter): string;
 export declare function summarizeTaskEvent(event: TaskEvent, formatter?: TaskEventValueFormatter): string;
+export declare function getTaskEventPrimaryChangeField(event: TaskEvent): string | null;
+export declare function getTaskActivityItems(task: Pick<TaskItem, 'activity' | 'comments'>): TaskActivityItem[];
 export declare function getLatestTaskActivity(task: Pick<TaskItem, 'activity' | 'comments'>): TaskActivityItem | null;
 export declare function summarizeTaskActivity(item: TaskActivityItem | null, formatter?: TaskEventValueFormatter): string;