@taskforcehq/taskforce 0.3.301 → 0.3.302

package/dist/sync/planningSyncPayload.d.ts

@@ -0,0 +1,9 @@
+import type { WorkspaceSyncInitiativeSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
+import type { WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
+export declare function normalizeTaxonomySyncPayload(raw: unknown): {
+    taxonomies?: unknown[];
+    taxonomyState?: WorkspaceTaxonomyState;
+    updatedAt: string;
+} | null;
+export declare function normalizeInitiativeSyncPayload(raw: unknown, sourceWatermark?: string): WorkspaceSyncInitiativeSnapshot | null;
+export declare function normalizeWorkstreamSyncPayload(raw: unknown, sourceWatermark?: string): WorkspaceSyncWorkstreamSnapshot | null;

package/dist/sync/planningSyncPayload.js

@@ -0,0 +1,82 @@
+function toOptionalTrimmedString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function toNullableTrimmedString(value) {
+    return toOptionalTrimmedString(value) ?? null;
+}
+function toOptionalPositiveInteger(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const normalized = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(normalized))
+        return null;
+    return Math.max(1, Math.floor(normalized));
+}
+function toOptionalInteger(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const normalized = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(normalized))
+        return null;
+    return Math.floor(normalized);
+}
+export function normalizeTaxonomySyncPayload(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const taxonomyState = source.taxonomyState && typeof source.taxonomyState === 'object' && !Array.isArray(source.taxonomyState)
+        ? source.taxonomyState
+        : undefined;
+    const taxonomies = Array.isArray(source.taxonomies) ? source.taxonomies : undefined;
+    if (!taxonomyState && !taxonomies)
+        return null;
+    return {
+        ...(taxonomies ? { taxonomies } : {}),
+        ...(taxonomyState ? { taxonomyState } : {}),
+        updatedAt: String(source.updatedAt || source.watermark || '').trim(),
+    };
+}
+export function normalizeInitiativeSyncPayload(raw, sourceWatermark) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const id = String(source.id || '').trim();
+    if (!id)
+        return null;
+    return {
+        id,
+        referenceNumber: toOptionalPositiveInteger(source.referenceNumber),
+        referenceLabel: toOptionalTrimmedString(source.referenceLabel),
+        title: String(source.title || '').trim(),
+        description: typeof source.description === 'string' ? source.description : null,
+        ownerId: toNullableTrimmedString(source.ownerId),
+        createdAt: String(source.createdAt || sourceWatermark || '').trim(),
+        updatedAt: String(source.updatedAt || sourceWatermark || source.createdAt || '').trim(),
+        order: toOptionalInteger(source.order),
+        isArchived: Boolean(source.isArchived),
+    };
+}
+export function normalizeWorkstreamSyncPayload(raw, sourceWatermark) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const id = String(source.id || '').trim();
+    if (!id)
+        return null;
+    return {
+        id,
+        referenceNumber: toOptionalPositiveInteger(source.referenceNumber),
+        referenceLabel: toOptionalTrimmedString(source.referenceLabel),
+        initiativeId: toNullableTrimmedString(source.initiativeId),
+        title: String(source.title || '').trim(),
+        description: typeof source.description === 'string' ? source.description : null,
+        ownerId: toNullableTrimmedString(source.ownerId),
+        createdAt: String(source.createdAt || sourceWatermark || '').trim(),
+        updatedAt: String(source.updatedAt || sourceWatermark || source.createdAt || '').trim(),
+        order: toOptionalInteger(source.order),
+        isArchived: Boolean(source.isArchived),
+    };
+}

package/dist/sync/planningSyncPayload.test.d.ts

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

package/dist/sync/planningSyncPayload.test.js

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeInitiativeSyncPayload, normalizeTaxonomySyncPayload, normalizeWorkstreamSyncPayload, } from './planningSyncPayload';
+describe('planningSyncPayload', () => {
+    it('normalizes taxonomy sync payloads', () => {
+        const payload = normalizeTaxonomySyncPayload({
+            taxonomies: [{ id: 'priority' }],
+            updatedAt: '2026-04-10T10:00:00.000Z',
+        });
+        expect(payload).toEqual({
+            taxonomies: [{ id: 'priority' }],
+            updatedAt: '2026-04-10T10:00:00.000Z',
+        });
+    });
+    it('normalizes initiative sync payloads', () => {
+        const initiative = normalizeInitiativeSyncPayload({
+            id: 'initiative-1',
+            referenceNumber: '4',
+            referenceLabel: ' IN-4 ',
+            title: ' Launch ',
+            description: ' Ship it ',
+            ownerId: ' owner-1 ',
+            createdAt: '2026-04-10T10:00:00.000Z',
+            updatedAt: '2026-04-10T11:00:00.000Z',
+            order: '2',
+            isArchived: true,
+        });
+        expect(initiative).toEqual({
+            id: 'initiative-1',
+            referenceNumber: 4,
+            referenceLabel: 'IN-4',
+            title: 'Launch',
+            description: ' Ship it ',
+            ownerId: 'owner-1',
+            createdAt: '2026-04-10T10:00:00.000Z',
+            updatedAt: '2026-04-10T11:00:00.000Z',
+            order: 2,
+            isArchived: true,
+        });
+    });
+    it('normalizes workstream sync payloads', () => {
+        const workstream = normalizeWorkstreamSyncPayload({
+            id: 'workstream-1',
+            referenceNumber: '2',
+            referenceLabel: ' WS-2 ',
+            initiativeId: ' initiative-1 ',
+            title: ' Backend ',
+            description: ' API work ',
+            ownerId: ' owner-2 ',
+            createdAt: '2026-04-10T10:00:00.000Z',
+            updatedAt: '2026-04-10T11:00:00.000Z',
+            order: '5',
+            isArchived: false,
+        });
+        expect(workstream).toEqual({
+            id: 'workstream-1',
+            referenceNumber: 2,
+            referenceLabel: 'WS-2',
+            initiativeId: 'initiative-1',
+            title: 'Backend',
+            description: ' API work ',
+            ownerId: 'owner-2',
+            createdAt: '2026-04-10T10:00:00.000Z',
+            updatedAt: '2026-04-10T11:00:00.000Z',
+            order: 5,
+            isArchived: false,
+        });
+    });
+});

package/dist/sync/syncApplyHandlers.d.ts

@@ -0,0 +1,83 @@
+import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
+import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
+import type { BinaryAssetSyncPayload, DocumentSyncPayload } from './contentSyncPayload.js';
+type SyncCore = TaskforceCore & TaskforceSyncCapable;
+type SyncRouteError = Error & {
+    code?: string;
+    statusCode?: number;
+    details?: Record<string, unknown>;
+};
+type RecordSyncDiagnostic = (workspaceId: string, eventType: 'pull' | 'push' | 'apply', errorMessage: string, details?: Record<string, unknown>) => void;
+type CreateSyncRouteError = (message: string, details: Record<string, unknown>, options?: {
+    code?: string;
+    statusCode?: number;
+}) => SyncRouteError;
+export declare function resolveSyncConflictOrdering(incomingWatermark: string, existingWatermark: string, incomingTieBreak: string, existingTieBreak: string): number;
+export declare function applyPlanningSyncChanges(input: {
+    core: SyncCore;
+    workspaceId: string;
+    incomingInitiatives: Map<string, WorkspaceSyncInitiativeSnapshot>;
+    incomingWorkstreams: Map<string, WorkspaceSyncWorkstreamSnapshot>;
+    incomingTaxonomies: unknown[] | null;
+    incomingTaxonomyState: Record<string, unknown> | null;
+    incomingTaxonomiesUpdatedAt: string;
+    workspaceTaxonomySyncMeta: Map<string, {
+        updatedAt: string;
+        hash: string;
+    }>;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+}): void;
+export declare function applyAiProfileAndMemberSyncChanges(input: {
+    core: SyncCore;
+    workspaceId: string;
+    incomingAiProfiles: Map<string, WorkspaceSyncAiProfileSnapshot>;
+    workspaceMembers?: WorkspaceSyncWorkspaceMemberSnapshot[];
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+    assertSyncedAiProfilesPersisted: (workspaceId: string, incomingAiProfiles: Map<string, WorkspaceSyncAiProfileSnapshot>) => void;
+    createSyncRouteError: CreateSyncRouteError;
+}): void;
+export declare function applyContentSyncChanges(input: {
+    core: SyncCore;
+    workspaceId: string;
+    incomingDocuments: DocumentSyncPayload[];
+    incomingDocumentDeletes: Map<string, string>;
+    incomingAssets: BinaryAssetSyncPayload[];
+    incomingAssetDeletes: Map<string, string>;
+    basePath: string;
+    hasObjectStorageClient: () => boolean;
+    hasDocumentSyncMetadataDrift: (workspaceId: string, doc: DocumentSyncPayload, options?: {
+        allowReferenceNumberReassignment?: boolean;
+    }) => boolean;
+    hasBinaryAssetSyncMetadataDrift: (workspaceId: string, asset: BinaryAssetSyncPayload, options?: {
+        allowReferenceNumberReassignment?: boolean;
+    }) => boolean;
+    writeWorkspaceSyncDocument: (basePath: string, doc: DocumentSyncPayload, workspaceId?: string, options?: {
+        allowReferenceNumberReassignment?: boolean;
+    }) => Promise<void>;
+    deleteWorkspaceSyncDocument: (basePath: string, docPath: string, workspaceId?: string) => void;
+    writeWorkspaceSyncBinaryAsset: (basePath: string, asset: BinaryAssetSyncPayload, workspaceId?: string, options?: {
+        allowReferenceNumberReassignment?: boolean;
+    }) => Promise<void>;
+    deleteWorkspaceSyncBinaryAsset: (basePath: string, assetPath: string, workspaceId?: string) => void;
+    getExistingBinaryAsset: (assetPath: string, workspaceId: string) => {
+        updatedAt?: string | null;
+        contentSha256?: string | null;
+    } | null;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+    options?: {
+        allowReferenceNumberReassignment?: boolean;
+    };
+}): Promise<void>;
+export declare function applyCollaborationSyncChanges(input: {
+    core: SyncCore;
+    workspaceId: string;
+    incomingDocumentReviewSessions: Map<string, WorkspaceSyncDocumentReviewSessionSnapshot>;
+    incomingDocumentReviewSessionDeletes: Map<string, string>;
+    incomingDocumentReviewComments: Map<string, WorkspaceSyncDocumentReviewCommentSnapshot>;
+    incomingDocumentReviewCommentDeletes: Map<string, string>;
+    incomingAnnotatedAttachmentSessions: Map<string, WorkspaceSyncAnnotatedAttachmentSessionSnapshot>;
+    incomingAnnotatedAttachmentSessionDeletes: Map<string, string>;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+    createSyncRouteError: CreateSyncRouteError;
+}): void;
+export {};