collabmd 0.1.40 → 0.1.41

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

@@ -1,26 +1,18 @@
-import { watch } from 'fs';
-import { readdir, stat } from 'fs/promises';
-import { basename, dirname, join } from 'path';
+import { watch } from 'node:fs';
+import { basename } from 'node: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,
-} from '../persistence/path-utils.js';
+  deriveIncrementalWorkspaceState,
+  detectWorkspaceStateChange,
+  hasWorkspaceStatePaths,
+  readWorkspacePathSnapshot as readWorkspacePathSnapshotFromAdapter,
+} from '../../domain/workspace-state.js';
+import { isIgnoredVaultEntry } from '../persistence/path-utils.js';
+import { createWorkspaceStateFileSystemAdapter } from './workspace-state-file-system-adapter.js';
 
 const MAX_INCREMENTAL_PENDING_PATHS = 16;
 
-function entrySignature(entry = {}) {
-  return `${entry.type}:${entry.inode}:${entry.size}:${entry.mtimeMs}`;
-}
-
-function sortByPath(values = []) {
-  return [...values].sort((left, right) => left.localeCompare(right, undefined, { sensitivity: 'base' }));
-}
-
 function normalizeWatchedPath(filename) {
   if (typeof filename !== 'string' && !Buffer.isBuffer(filename)) {
     return '';
@@ -54,213 +46,6 @@ function isIgnoredWatchedPath(pathValue) {
   return basename(pathValue).includes('.collabmd-');
 }
 
-function normalizeWorkspacePath(pathValue = '') {
-  return String(pathValue ?? '').replace(/\\/g, '/').trim();
-}
-
-function getParentDirectoryPath(pathValue = '') {
-  const parentPath = dirname(normalizeWorkspacePath(pathValue)).replace(/\\/g, '/');
-  return parentPath === '.' ? '' : parentPath;
-}
-
-function createWorkspaceEntry(pathValue, nodeType) {
-  const normalizedPath = normalizeWorkspacePath(pathValue);
-  return {
-    fileKind: nodeType === 'directory' ? null : getVaultTreeNodeType(normalizedPath),
-    name: basename(normalizedPath),
-    nodeType,
-    parentPath: getParentDirectoryPath(normalizedPath),
-    path: normalizedPath,
-    type: nodeType === 'directory' ? 'directory' : getVaultTreeNodeType(normalizedPath),
-  };
-}
-
-function createWorkspaceMetadata(pathValue, type, info) {
-  return {
-    inode: Number(info.ino || 0),
-    mtimeMs: Number(info.mtimeMs || 0),
-    path: pathValue,
-    size: type === 'directory' ? 0 : Number(info.size || 0),
-    type,
-  };
-}
-
-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) => {
-    if (entry.type !== 'file' || !pathValue.startsWith(`${oldPrefix}/`)) {
-      return;
-    }
-
-    const suffix = pathValue.slice(oldPrefix.length + 1);
-    const nextPath = `${newPrefix}/${suffix}`;
-    if (nextState.metadata.get(nextPath)?.type === 'file') {
-      renames.push({ oldPath: pathValue, newPath: nextPath });
-    }
-  });
-  return renames;
-}
-
-function detectWorkspaceChange(previousState, nextState) {
-  const previousMetadata = previousState?.metadata ?? new Map();
-  const nextMetadata = nextState?.metadata ?? new Map();
-  const changedPaths = new Set();
-  const deletedPaths = new Set();
-  const addedPaths = new Set();
-  const renamedPaths = [];
-
-  previousMetadata.forEach((previousEntry, pathValue) => {
-    const nextEntry = nextMetadata.get(pathValue);
-    if (!nextEntry) {
-      if (previousEntry.type === 'file') {
-        deletedPaths.add(pathValue);
-      }
-      return;
-    }
-
-    if (entrySignature(previousEntry) !== entrySignature(nextEntry) && nextEntry.type === 'file') {
-      changedPaths.add(pathValue);
-    }
-  });
-
-  nextMetadata.forEach((nextEntry, pathValue) => {
-    if (!previousMetadata.has(pathValue) && nextEntry.type === 'file') {
-      addedPaths.add(pathValue);
-    }
-  });
-
-  const deletedBySignature = new Map();
-  deletedPaths.forEach((pathValue) => {
-    const metadata = previousMetadata.get(pathValue);
-    const signature = entrySignature(metadata);
-    const bucket = deletedBySignature.get(signature) ?? [];
-    bucket.push(pathValue);
-    deletedBySignature.set(signature, bucket);
-  });
-
-  const addedBySignature = new Map();
-  addedPaths.forEach((pathValue) => {
-    const metadata = nextMetadata.get(pathValue);
-    const signature = entrySignature(metadata);
-    const bucket = addedBySignature.get(signature) ?? [];
-    bucket.push(pathValue);
-    addedBySignature.set(signature, bucket);
-  });
-
-  Array.from(deletedBySignature.keys()).forEach((signature) => {
-    const removed = deletedBySignature.get(signature) ?? [];
-    const added = addedBySignature.get(signature) ?? [];
-    if (removed.length === 1 && added.length === 1) {
-      renamedPaths.push({ oldPath: removed[0], newPath: added[0] });
-      deletedPaths.delete(removed[0]);
-      addedPaths.delete(added[0]);
-    }
-  });
-
-  const previousDirectories = Array.from(previousMetadata.entries())
-    .filter(([, entry]) => entry.type === 'directory' && !nextMetadata.has(entry.path));
-  const nextDirectories = Array.from(nextMetadata.entries())
-    .filter(([, entry]) => entry.type === 'directory' && !previousMetadata.has(entry.path));
-
-  previousDirectories.forEach(([oldPath, oldEntry]) => {
-    const match = nextDirectories.find(([, nextEntry]) => entrySignature(oldEntry) === entrySignature(nextEntry));
-    if (!match) {
-      return;
-    }
-
-    const [newPath] = match;
-    buildPrefixRenameEntries(previousState, nextState, oldPath, newPath).forEach((entry) => {
-      renamedPaths.push(entry);
-      deletedPaths.delete(entry.oldPath);
-      addedPaths.delete(entry.newPath);
-    });
-  });
-
-  addedPaths.forEach((pathValue) => {
-    changedPaths.add(pathValue);
-  });
-
-  return createWorkspaceChange({
-    changedPaths: sortByPath(Array.from(changedPaths)),
-    deletedPaths: sortByPath(Array.from(deletedPaths)),
-    renamedPaths,
-    refreshExplorer: true,
-  });
-}
-
-function hasWorkspacePaths(workspaceChange = {}) {
-  return (
-    (workspaceChange.changedPaths?.length ?? 0) > 0
-    || (workspaceChange.deletedPaths?.length ?? 0) > 0
-    || (workspaceChange.renamedPaths?.length ?? 0) > 0
-  );
-}
-
 export class FileSystemSyncService {
   constructor({
     debounceMs = 180,
@@ -272,6 +57,9 @@ export class FileSystemSyncService {
     this.mutationCoordinator = mutationCoordinator;
     this.perfLoggingEnabled = perfLoggingEnabled;
     this.vaultFileStore = vaultFileStore;
+    this.workspaceStateAdapter = createWorkspaceStateFileSystemAdapter({
+      vaultDir: vaultFileStore?.vaultDir,
+    });
     this.watcher = null;
     this.debounceTimer = null;
     this.runningFlush = null;
@@ -368,192 +156,17 @@ export class FileSystemSyncService {
   }
 
   async readWorkspacePathSnapshot(pathValue) {
-    const normalizedPath = normalizeWorkspacePath(pathValue);
-    if (!normalizedPath) {
-      return null;
-    }
-
-    const absolutePath = sanitizeVaultPath(this.vaultFileStore.vaultDir, normalizedPath);
-    if (!absolutePath) {
-      return null;
-    }
-
-    try {
-      const info = await stat(absolutePath);
-      const entries = new Map();
-      const metadata = new Map();
-
-      if (info.isDirectory()) {
-        const visitDirectory = async (directoryPath, relativePath) => {
-          entries.set(relativePath, createWorkspaceEntry(relativePath, 'directory'));
-          metadata.set(relativePath, createWorkspaceMetadata(relativePath, 'directory', await stat(directoryPath)));
-
-          let dirEntries;
-          try {
-            dirEntries = await readdir(directoryPath, { withFileTypes: true });
-          } catch {
-            return;
-          }
-
-          for (const entry of dirEntries) {
-            if (isIgnoredVaultEntry(entry.name)) {
-              continue;
-            }
-
-            const childAbsolutePath = join(directoryPath, entry.name);
-            const childRelativePath = `${relativePath}/${entry.name}`.replace(/\\/g, '/');
-
-            if (entry.isDirectory()) {
-              await visitDirectory(childAbsolutePath, childRelativePath);
-              continue;
-            }
-
-            if (!isVaultFilePath(childRelativePath)) {
-              continue;
-            }
-
-            try {
-              const childInfo = await stat(childAbsolutePath);
-              if (!childInfo.isFile()) {
-                continue;
-              }
-
-              entries.set(childRelativePath, createWorkspaceEntry(childRelativePath, 'file'));
-              metadata.set(childRelativePath, createWorkspaceMetadata(childRelativePath, 'file', childInfo));
-            } catch (error) {
-              if (error?.code !== 'ENOENT' && error?.code !== 'ENOTDIR') {
-                throw error;
-              }
-            }
-          }
-        };
-
-        await visitDirectory(absolutePath, normalizedPath);
-        return { entries, metadata };
-      }
-
-      if (!info.isFile() || !isVaultFilePath(normalizedPath)) {
-        return { entries, metadata };
-      }
-
-      entries.set(normalizedPath, createWorkspaceEntry(normalizedPath, 'file'));
-      metadata.set(normalizedPath, createWorkspaceMetadata(normalizedPath, 'file', info));
-      return { entries, metadata };
-    } catch (error) {
-      if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') {
-        return {
-          entries: new Map(),
-          metadata: new Map(),
-        };
-      }
-
-      throw error;
-    }
-  }
-
-  async ensureAncestorDirectories(nextEntries, nextMetadata, pathValue) {
-    const parentPath = getParentDirectoryPath(pathValue);
-    if (!parentPath) {
-      return true;
-    }
-
-    const segments = parentPath.split('/').filter(Boolean);
-    let currentPath = '';
-    for (const segment of segments) {
-      currentPath = currentPath ? `${currentPath}/${segment}` : segment;
-      if (nextEntries.has(currentPath) && nextMetadata.has(currentPath)) {
-        continue;
-      }
-
-      const directorySnapshot = await this.readWorkspacePathSnapshot(currentPath);
-      if (!directorySnapshot?.entries?.has(currentPath) || !directorySnapshot.metadata?.has(currentPath)) {
-        return false;
-      }
-
-      nextEntries.set(currentPath, directorySnapshot.entries.get(currentPath));
-      nextMetadata.set(currentPath, directorySnapshot.metadata.get(currentPath));
-    }
-
-    return true;
+    return readWorkspacePathSnapshotFromAdapter(this.workspaceStateAdapter, pathValue);
   }
 
   async buildIncrementalResult() {
-    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 = collapsePendingPaths(Array.from(this.pendingEventTypesByPath.keys()));
-    if (pendingPaths.length === 0 || pendingPaths.length > MAX_INCREMENTAL_PENDING_PATHS) {
-      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();
-
-    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 { fallbackReason: 'snapshot-unavailable', incrementalResult: null };
-      }
-
-      if (!(await this.ensureAncestorDirectories(nextEntries, nextMetadata, pathValue))) {
-        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 = createWorkspaceStateSnapshot(nextEntries, nextMetadata, {
-      scannedAt: Date.now(),
+    return deriveIncrementalWorkspaceState(this.workspaceStateAdapter, {
+      forceFullScan: this.forceFullScan,
+      maxPendingPaths: MAX_INCREMENTAL_PENDING_PATHS,
+      pendingPaths: Array.from(this.pendingEventTypesByPath.keys()),
+      previousState: this.lastState,
+      readPathSnapshot: (pathValue) => this.readWorkspacePathSnapshot(pathValue),
     });
-    const workspaceChange = detectWorkspaceChange(
-      createScopedWorkspaceState(previousState, previousTouchedPaths),
-      createScopedWorkspaceState(nextState, nextTouchedPaths),
-    );
-
-    return {
-      fallbackReason: '',
-      incrementalResult: {
-        nextState,
-        workspaceChange,
-      },
-    };
   }
 
   consumePendingEvents() {
@@ -574,15 +187,15 @@ export class FileSystemSyncService {
     let effectiveMode = incrementalResult ? 'incremental' : 'full-scan';
     let effectiveFallbackReason = fallbackReason;
     let nextState = incrementalResult?.nextState ?? await this.vaultFileStore.scanWorkspaceState();
-    let workspaceChange = incrementalResult?.workspaceChange ?? detectWorkspaceChange(this.lastState, nextState);
+    let workspaceChange = incrementalResult?.workspaceChange ?? detectWorkspaceStateChange(this.lastState, nextState);
     this.lastState = nextState;
 
     let filteredChange = this.mutationCoordinator.filterManagedWorkspaceChange(workspaceChange);
     if (!filteredChange) {
-      const authoritativeChange = detectWorkspaceChange(authoritativePreviousState, nextState);
-      if (hasWorkspacePaths(authoritativeChange)) {
+      const authoritativeChange = detectWorkspaceStateChange(authoritativePreviousState, nextState);
+      if (hasWorkspaceStatePaths(authoritativeChange)) {
         nextState = await this.vaultFileStore.scanWorkspaceState();
-        workspaceChange = detectWorkspaceChange(authoritativePreviousState, nextState);
+        workspaceChange = detectWorkspaceStateChange(authoritativePreviousState, nextState);
         this.lastState = nextState;
         filteredChange = this.mutationCoordinator.filterManagedWorkspaceChange(workspaceChange);
         effectiveMode = 'full-scan';
@@ -591,7 +204,7 @@ export class FileSystemSyncService {
     }
 
     if (!filteredChange) {
-      if (this.mutationCoordinator.isGloballySuppressed?.() || hasWorkspacePaths(workspaceChange)) {
+      if (this.mutationCoordinator.isGloballySuppressed?.() || hasWorkspaceStatePaths(workspaceChange)) {
         this.mutationCoordinator.syncWorkspaceEntries(nextState, {
           previousState: previousWorkspaceState,
         });