collabmd 0.1.29 → 0.1.31

package/src/server/infrastructure/workspace/file-system-sync-service.js

@@ -4,6 +4,8 @@ import { basename, dirname, join } from 'path';
 
 import { createWorkspaceChange } from '../../../domain/workspace-change.js';
 import { getVaultTreeNodeType, isVaultFilePath } from '../../../domain/file-kind.js';
+import { logPerfEvent } from '../../config/perf-logging.js';
+import { createWorkspaceStateSnapshot } from '../../domain/workspace-state.js';
 import {
   isIgnoredVaultEntry,
   sanitizeVaultPath,
@@ -87,6 +89,67 @@ function isPathWithinPrefix(pathValue, prefix) {
   return pathValue === prefix || pathValue.startsWith(`${prefix}/`);
 }
 
+function collectAncestorPaths(pathValue = '') {
+  const normalizedPath = normalizeWorkspacePath(pathValue);
+  if (!normalizedPath) {
+    return [];
+  }
+
+  const segments = normalizedPath.split('/').filter(Boolean);
+  const ancestors = [];
+  let currentPath = '';
+  for (let index = 0; index < Math.max(segments.length - 1, 0); index += 1) {
+    currentPath = currentPath ? `${currentPath}/${segments[index]}` : segments[index];
+    ancestors.push(currentPath);
+  }
+
+  return ancestors;
+}
+
+function collapsePendingPaths(paths = []) {
+  const collapsed = [];
+  for (const pathValue of sortByPath(paths.filter(Boolean))) {
+    if (collapsed.some((existingPath) => isPathWithinPrefix(pathValue, existingPath))) {
+      continue;
+    }
+
+    collapsed.push(pathValue);
+  }
+
+  return collapsed;
+}
+
+function collectPathsWithinPrefixes(paths = [], prefixes = []) {
+  const collected = new Set();
+  for (const pathValue of paths) {
+    if (prefixes.some((prefix) => isPathWithinPrefix(pathValue, prefix))) {
+      collected.add(pathValue);
+    }
+  }
+  return collected;
+}
+
+function createScopedWorkspaceState(sourceState, scopedPaths = new Set()) {
+  const entries = new Map();
+  const metadata = new Map();
+
+  scopedPaths.forEach((pathValue) => {
+    const entry = sourceState?.entries?.get(pathValue);
+    const entryMetadata = sourceState?.metadata?.get(pathValue);
+    if (entry) {
+      entries.set(pathValue, entry);
+    }
+    if (entryMetadata) {
+      metadata.set(pathValue, entryMetadata);
+    }
+  });
+
+  return {
+    entries,
+    metadata,
+  };
+}
+
 function buildPrefixRenameEntries(previousState, nextState, oldPrefix, newPrefix) {
   const renames = [];
   previousState.metadata.forEach((entry, pathValue) => {
@@ -194,10 +257,12 @@ export class FileSystemSyncService {
   constructor({
     debounceMs = 180,
     mutationCoordinator,
+    perfLoggingEnabled = false,
     vaultFileStore,
   }) {
     this.debounceMs = debounceMs;
     this.mutationCoordinator = mutationCoordinator;
+    this.perfLoggingEnabled = perfLoggingEnabled;
     this.vaultFileStore = vaultFileStore;
     this.watcher = null;
     this.debounceTimer = null;
@@ -208,8 +273,8 @@ export class FileSystemSyncService {
     this.suspendWatchEventsUntil = 0;
   }
 
-  async start() {
-    this.lastState = this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
+  async start({ snapshot = null } = {}) {
+    this.lastState = snapshot ?? this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
     this.watcher = watch(this.vaultFileStore.vaultDir, { recursive: true }, (eventType, filename) => {
       this.handleWatchEvent(eventType, filename);
     });
@@ -253,7 +318,7 @@ export class FileSystemSyncService {
     this.debounceTimer.unref?.();
   }
 
-  async resetForExternalStateChange() {
+  async resetForExternalStateChange({ snapshot = null } = {}) {
     this.suspendWatchEventsUntil = Math.max(this.suspendWatchEventsUntil, Date.now() + 750);
     clearTimeout(this.debounceTimer);
     this.debounceTimer = null;
@@ -268,7 +333,26 @@ export class FileSystemSyncService {
 
     this.pendingEventTypesByPath.clear();
     this.forceFullScan = false;
-    this.lastState = this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
+    this.lastState = snapshot ?? this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
+  }
+
+  async flushPendingChanges() {
+    clearTimeout(this.debounceTimer);
+    this.debounceTimer = null;
+
+    if (this.runningFlush) {
+      await this.runningFlush;
+      return;
+    }
+
+    if (this.pendingEventTypesByPath.size === 0 && !this.forceFullScan) {
+      return;
+    }
+
+    this.runningFlush = this.flush().finally(() => {
+      this.runningFlush = null;
+    });
+    await this.runningFlush;
   }
 
   async readWorkspacePathSnapshot(pathValue) {
@@ -382,62 +466,83 @@ export class FileSystemSyncService {
   }
 
   async buildIncrementalResult() {
-    if (this.forceFullScan || this.pendingEventTypesByPath.size === 0 || !this.lastState) {
-      return null;
+    if (this.forceFullScan) {
+      return { fallbackReason: 'forced-full-scan', incrementalResult: null };
+    }
+
+    if (this.pendingEventTypesByPath.size === 0) {
+      return { fallbackReason: 'no-pending-paths', incrementalResult: null };
+    }
+
+    if (!this.lastState) {
+      return { fallbackReason: 'missing-last-state', incrementalResult: null };
     }
 
-    const pendingPaths = Array.from(this.pendingEventTypesByPath.keys())
-      .filter(Boolean)
-      .sort((left, right) => left.localeCompare(right, undefined, { sensitivity: 'base' }));
+    const pendingPaths = collapsePendingPaths(Array.from(this.pendingEventTypesByPath.keys()));
     if (pendingPaths.length === 0 || pendingPaths.length > MAX_INCREMENTAL_PENDING_PATHS) {
-      return null;
+      return { fallbackReason: 'too-many-pending-paths', incrementalResult: null };
     }
 
     const nextEntries = new Map(this.lastState.entries);
     const nextMetadata = new Map(this.lastState.metadata);
     const previousState = this.lastState;
+    const previousTouchedPaths = collectPathsWithinPrefixes(previousState.entries.keys(), pendingPaths);
+    const nextTouchedPaths = new Set();
 
-    for (const pathValue of pendingPaths) {
-      Array.from(previousState.entries.keys())
-        .filter((candidatePath) => isPathWithinPrefix(candidatePath, pathValue))
-        .forEach((candidatePath) => {
-          nextEntries.delete(candidatePath);
-        });
-      Array.from(previousState.metadata.keys())
-        .filter((candidatePath) => isPathWithinPrefix(candidatePath, pathValue))
-        .forEach((candidatePath) => {
-          nextMetadata.delete(candidatePath);
-        });
+    pendingPaths.forEach((pathValue) => {
+      collectAncestorPaths(pathValue).forEach((ancestorPath) => {
+        if (previousState.entries.has(ancestorPath)) {
+          previousTouchedPaths.add(ancestorPath);
+        }
+      });
+    });
 
+    previousTouchedPaths.forEach((pathValue) => {
+      nextEntries.delete(pathValue);
+      nextMetadata.delete(pathValue);
+    });
+
+    for (const pathValue of pendingPaths) {
       const snapshot = await this.readWorkspacePathSnapshot(pathValue);
       if (!snapshot) {
-        return null;
+        return { fallbackReason: 'snapshot-unavailable', incrementalResult: null };
       }
 
       if (snapshot.entries.size > 0) {
         if (!(await this.ensureAncestorDirectories(nextEntries, nextMetadata, pathValue))) {
-          return null;
+          return { fallbackReason: 'ancestor-missing', incrementalResult: null };
         }
+
+        collectAncestorPaths(pathValue).forEach((ancestorPath) => {
+          if (nextEntries.has(ancestorPath)) {
+            nextTouchedPaths.add(ancestorPath);
+          }
+        });
       }
 
       snapshot.entries.forEach((entry, entryPath) => {
         nextEntries.set(entryPath, entry);
+        nextTouchedPaths.add(entryPath);
       });
       snapshot.metadata.forEach((metadata, metadataPath) => {
         nextMetadata.set(metadataPath, metadata);
       });
     }
 
-    const nextState = {
-      entries: nextEntries,
-      metadata: nextMetadata,
+    const nextState = createWorkspaceStateSnapshot(nextEntries, nextMetadata, {
       scannedAt: Date.now(),
-    };
-    const workspaceChange = detectWorkspaceChange(this.lastState, nextState);
+    });
+    const workspaceChange = detectWorkspaceChange(
+      createScopedWorkspaceState(previousState, previousTouchedPaths),
+      createScopedWorkspaceState(nextState, nextTouchedPaths),
+    );
 
     return {
-      nextState,
-      workspaceChange,
+      fallbackReason: '',
+      incrementalResult: {
+        nextState,
+        workspaceChange,
+      },
     };
   }
 
@@ -449,7 +554,9 @@ export class FileSystemSyncService {
   }
 
   async flush() {
-    const incrementalResult = await this.buildIncrementalResult();
+    const startedAt = Date.now();
+    const pendingPathCount = this.pendingEventTypesByPath.size;
+    const { fallbackReason, incrementalResult } = await this.buildIncrementalResult();
     this.consumePendingEvents();
 
     const previousWorkspaceState = this.mutationCoordinator.workspaceState;
@@ -463,6 +570,15 @@ export class FileSystemSyncService {
         previousState: previousWorkspaceState,
       });
       this.mutationCoordinator.replaceWorkspaceState(nextState);
+      logPerfEvent(this.perfLoggingEnabled, 'filesystem-sync', {
+        changedPathCount: workspaceChange.changedPaths?.length ?? 0,
+        deletedPathCount: workspaceChange.deletedPaths?.length ?? 0,
+        durationMs: Date.now() - startedAt,
+        fallbackReason,
+        mode: incrementalResult ? 'incremental' : 'full-scan',
+        pendingPathCount,
+        renamedPathCount: workspaceChange.renamedPaths?.length ?? 0,
+      });
       return;
     }
 
@@ -472,6 +588,15 @@ export class FileSystemSyncService {
       nextState,
       workspaceChange: filteredChange,
     });
+    logPerfEvent(this.perfLoggingEnabled, 'filesystem-sync', {
+      changedPathCount: filteredChange.changedPaths?.length ?? 0,
+      deletedPathCount: filteredChange.deletedPaths?.length ?? 0,
+      durationMs: Date.now() - startedAt,
+      fallbackReason,
+      mode: incrementalResult ? 'incremental' : 'full-scan',
+      pendingPathCount,
+      renamedPathCount: filteredChange.renamedPaths?.length ?? 0,
+    });
   }
 
   async close() {

package/src/server/infrastructure/workspace/workspace-mutation-coordinator.js

@@ -8,6 +8,7 @@ import {
   normalizeWorkspaceEvent,
 } from '../../../domain/workspace-change.js';
 import { WORKSPACE_ROOM_NAME } from '../../../domain/workspace-room.js';
+import { createWorkspaceStateSnapshot } from '../../domain/workspace-state.js';
 import { sanitizeVaultPath } from '../persistence/path-utils.js';
 
 function createEventId() {
@@ -26,6 +27,31 @@ function countWorkspacePaths(workspaceChange = {}) {
   );
 }
 
+function countBacklinkAffectedPaths(workspaceChange = {}) {
+  const affectedPaths = new Set();
+
+  (workspaceChange.changedPaths ?? []).forEach((pathValue) => {
+    if (supportsBacklinksForFilePath(pathValue)) {
+      affectedPaths.add(pathValue);
+    }
+  });
+  (workspaceChange.deletedPaths ?? []).forEach((pathValue) => {
+    if (supportsBacklinksForFilePath(pathValue)) {
+      affectedPaths.add(pathValue);
+    }
+  });
+  (workspaceChange.renamedPaths ?? []).forEach((entry) => {
+    if (supportsBacklinksForFilePath(entry?.oldPath)) {
+      affectedPaths.add(entry.oldPath);
+    }
+    if (supportsBacklinksForFilePath(entry?.newPath)) {
+      affectedPaths.add(entry.newPath);
+    }
+  });
+
+  return affectedPaths.size;
+}
+
 function normalizePaths(paths = []) {
   return Array.from(new Set((paths ?? []).filter(Boolean)));
 }
@@ -168,11 +194,13 @@ function diffWorkspaceEntries(previousEntries = new Map(), nextEntries = new Map
 export class WorkspaceMutationCoordinator {
   constructor({
     backlinkIndex,
+    baseQueryService = null,
     roomRegistry,
     vaultFileStore,
     managedWriteWindowMs = 1200,
   }) {
     this.backlinkIndex = backlinkIndex ?? null;
+    this.baseQueryService = baseQueryService ?? null;
     this.roomRegistry = roomRegistry;
     this.vaultFileStore = vaultFileStore;
     this.managedWriteWindowMs = managedWriteWindowMs;
@@ -358,11 +386,9 @@ export class WorkspaceMutationCoordinator {
       nextMetadata.set(pathValue, nextPathState.metadata);
     }
 
-    return {
-      entries: nextEntries,
-      metadata: nextMetadata,
+    return createWorkspaceStateSnapshot(nextEntries, nextMetadata, {
       scannedAt: Date.now(),
-    };
+    });
   }
 
   getWorkspaceRoom() {
@@ -386,13 +412,14 @@ export class WorkspaceMutationCoordinator {
     });
   }
 
-  async initialize() {
-    const snapshot = await this.vaultFileStore.scanWorkspaceState();
-    this.replaceWorkspaceState(snapshot);
-    this.getWorkspaceRoom()?.replaceWorkspaceEntries(snapshot.entries, {
-      generatedAt: snapshot.scannedAt,
+  async initialize({ snapshot = null } = {}) {
+    const effectiveSnapshot = snapshot ?? await this.vaultFileStore.scanWorkspaceState();
+    this.replaceWorkspaceState(effectiveSnapshot);
+    await this.baseQueryService?.initializeFromWorkspaceState?.(effectiveSnapshot);
+    this.getWorkspaceRoom()?.replaceWorkspaceEntries(effectiveSnapshot.entries, {
+      generatedAt: effectiveSnapshot.scannedAt,
     });
-    return snapshot;
+    return effectiveSnapshot;
   }
 
   markManagedPaths(paths = [], { durationMs = this.managedWriteWindowMs } = {}) {
@@ -529,52 +556,17 @@ export class WorkspaceMutationCoordinator {
       return;
     }
 
-    const previousEntries = this.workspaceState?.entries ?? new Map();
     if (
       forceRebuild
-      || countWorkspacePaths(workspaceChange) > 25
+      || countBacklinkAffectedPaths(workspaceChange) > 25
     ) {
-      this.backlinkIndex.scheduleBuild?.();
+      this.backlinkIndex.scheduleBuild?.({ workspaceState: nextState });
       return;
     }
-
-    for (const pathValue of workspaceChange.deletedPaths ?? []) {
-      if (supportsBacklinksForFilePath(pathValue)) {
-        this.backlinkIndex.onFileDeleted(pathValue);
-      }
-    }
-
-    for (const entry of workspaceChange.renamedPaths ?? []) {
-      if (supportsBacklinksForFilePath(entry.oldPath) || supportsBacklinksForFilePath(entry.newPath)) {
-        this.backlinkIndex.onFileRenamed(entry.oldPath, entry.newPath);
-      }
-    }
-
-    for (const pathValue of workspaceChange.changedPaths ?? []) {
-      if (!supportsBacklinksForFilePath(pathValue)) {
-        continue;
-      }
-
-      const existsNow = nextState.entries.has(pathValue);
-      const existedBefore = previousEntries.has(pathValue);
-      if (!existsNow) {
-        if (existedBefore) {
-          this.backlinkIndex.onFileDeleted(pathValue);
-        }
-        continue;
-      }
-
-      const content = await this.vaultFileStore.readMarkdownFile(pathValue);
-      if (content === null) {
-        continue;
-      }
-
-      if (existedBefore) {
-        this.backlinkIndex.updateFile(pathValue, content);
-      } else {
-        this.backlinkIndex.onFileCreated(pathValue, content);
-      }
-    }
+    await this.backlinkIndex.applyWorkspaceChange?.(workspaceChange, {
+      nextState,
+      previousState: this.workspaceState,
+    });
   }
 
   async apply({
@@ -599,6 +591,10 @@ export class WorkspaceMutationCoordinator {
     await this.reconcileBacklinks(normalizedChange, resolvedState, {
       forceRebuild: forceBacklinkRebuild,
     });
+    await this.baseQueryService?.applyWorkspaceChange?.(normalizedChange, {
+      nextState: resolvedState,
+      previousState,
+    });
 
     const roomEffects = await this.roomRegistry?.reconcileWorkspaceChange?.(normalizedChange) ?? {};
     const highlightRanges = normalizePaths(

package/src/server/shared/async-utils.js

@@ -0,0 +1,25 @@
+export async function mapWithConcurrency(values, concurrency, iteratee) {
+  const items = Array.from(values ?? []);
+  const limit = Math.max(1, Number(concurrency) || 1);
+
+  if (items.length === 0) {
+    return [];
+  }
+
+  const results = new Array(items.length);
+  let nextIndex = 0;
+
+  async function worker() {
+    while (nextIndex < items.length) {
+      const currentIndex = nextIndex;
+      nextIndex += 1;
+      results[currentIndex] = await iteratee(items[currentIndex], currentIndex);
+    }
+  }
+
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => worker()),
+  );
+
+  return results;
+}

package/dist/client/assets/architecture-PBZL5I3N-iRyVT2GQ.js

@@ -1 +0,0 @@
-import"./chunk-XZSTWKYB-DDkpyNVE.js";import{n as e}from"./chunk-R5LLSJPH-BjSMFnTi.js";export{e as createArchitectureServices};