collabmd 0.1.19 → 0.1.21

package/src/server/infrastructure/git/git-service.js

@@ -6,6 +6,7 @@ import { parseNameStatusOutput } from './parsers.js';
 import { createEmptyWorkspaceChange, createWorkspaceChange } from './responses.js';
 import { GitStatusService } from './status-service.js';
 import { GitUntrackedFileService } from './untracked-files.js';
+import { PullBackupStore } from '../persistence/pull-backup-store.js';
 
 export class GitService {
   constructor({
@@ -36,6 +37,7 @@ export class GitService {
       statusService: this.statusService,
       untrackedFileService: this.untrackedFileService,
     });
+    this.pullBackupStore = new PullBackupStore({ vaultDir });
   }
 
   async isGitRepo() {
@@ -55,6 +57,14 @@ export class GitService {
     return this.statusService.getStatus(options);
   }
 
+  async listPullBackups() {
+    if (!(await this.isGitRepo())) {
+      return [];
+    }
+
+    return this.pullBackupStore.listBackups();
+  }
+
   async stageFile(path) {
     const normalizedPath = normalizeRelativeGitPath(path);
     await this.commandRunner.execGit(['add', '-A', '--', normalizedPath]);
@@ -131,7 +141,45 @@ export class GitService {
     }
 
     const beforeRef = await this.getHeadRef();
-    const output = await this.commandRunner.execGit(['pull', '--ff-only']);
+    await this.fetchUpstream(status.branch.upstream);
+
+    const targetRef = await this.resolveRef(status.branch.upstream);
+    if (!targetRef) {
+      throw createGitRequestError(409, 'Unable to resolve upstream branch for pull');
+    }
+
+    if (!(await this.canFastForwardTo(targetRef))) {
+      throw createGitRequestError(
+        409,
+        'Cannot pull because local and remote commits have diverged; fast-forward only pull is not possible.',
+        'pull_diverged_ff_only',
+      );
+    }
+
+    const dirtyEntries = this.collectDirtyEntries(status);
+    const upstreamWorkspaceChange = await this.createWorkspaceChangeFromRefs(beforeRef, targetRef);
+    const overlappingEntries = this.findOverlappingDirtyEntries({
+      dirtyEntries,
+      workspaceChange: upstreamWorkspaceChange,
+    });
+
+    let pullBackup = null;
+    if (overlappingEntries.length > 0) {
+      pullBackup = await this.backupAndClearOverlappingEntries({
+        beforeRef,
+        branchName: status.branch?.name ?? null,
+        entries: overlappingEntries,
+        targetRef,
+      });
+    }
+
+    let output;
+    try {
+      output = await this.commandRunner.execGit(['pull', '--ff-only', '--autostash']);
+    } catch (error) {
+      throw await this.classifyPullError(error);
+    }
+
     const afterRef = await this.getHeadRef();
     this.invalidateStatusCache();
     return {
@@ -139,6 +187,7 @@ export class GitService {
       beforeRef,
       ok: true,
       output: output.trim(),
+      pullBackup,
       workspaceChange: await this.createWorkspaceChangeFromRefs(beforeRef, afterRef),
     };
   }
@@ -202,6 +251,171 @@ export class GitService {
     }
   }
 
+  async resolveRef(ref) {
+    try {
+      const output = await this.commandRunner.execGit(['rev-parse', ref]);
+      return output.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+
+  async fetchUpstream(upstreamRef) {
+    const remoteName = String(upstreamRef ?? '').split('/')[0] || null;
+    await this.commandRunner.execGit(remoteName
+      ? ['fetch', '--prune', remoteName]
+      : ['fetch', '--prune']);
+  }
+
+  async canFastForwardTo(targetRef) {
+    const headRef = await this.getHeadRef();
+    if (!headRef || !targetRef || headRef === targetRef) {
+      return true;
+    }
+
+    try {
+      await this.commandRunner.execGit(['merge-base', '--is-ancestor', headRef, targetRef]);
+      return true;
+    } catch (error) {
+      if (error?.code === 1) {
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  collectDirtyEntries(status = {}) {
+    const entries = new Map();
+    for (const section of status.sections ?? []) {
+      for (const file of section.files ?? []) {
+        if (!file?.path) {
+          continue;
+        }
+
+        const existing = entries.get(file.path) ?? {
+          hasStagedChanges: false,
+          hasWorkingTreeChanges: false,
+          hasTrackedChanges: false,
+          isUntracked: false,
+          oldPath: null,
+          path: file.path,
+          touchPaths: new Set(),
+        };
+
+        existing.isUntracked = existing.isUntracked || file.scope === 'untracked';
+        existing.hasStagedChanges = existing.hasStagedChanges || file.scope === 'staged';
+        existing.hasWorkingTreeChanges = existing.hasWorkingTreeChanges || file.scope === 'working-tree';
+        existing.hasTrackedChanges = existing.hasTrackedChanges || file.scope === 'staged' || file.scope === 'working-tree';
+        if (!existing.oldPath && file.oldPath) {
+          existing.oldPath = file.oldPath;
+        }
+        existing.touchPaths.add(file.path);
+        if (file.oldPath) {
+          existing.touchPaths.add(file.oldPath);
+        }
+        entries.set(file.path, existing);
+      }
+    }
+
+    return Array.from(entries.values());
+  }
+
+  findOverlappingDirtyEntries({ dirtyEntries = [], workspaceChange = createEmptyWorkspaceChange() } = {}) {
+    const upstreamTouchedPaths = new Set([
+      ...(workspaceChange.changedPaths ?? []),
+      ...(workspaceChange.deletedPaths ?? []),
+      ...((workspaceChange.renamedPaths ?? []).flatMap((entry) => [entry.oldPath, entry.newPath])),
+    ].filter(Boolean));
+
+    return dirtyEntries.filter((entry) => Array.from(entry.touchPaths).some((path) => upstreamTouchedPaths.has(path)));
+  }
+
+  async createPatchForEntry(entry, { cached = false } = {}) {
+    const pathspecs = Array.from(entry?.touchPaths ?? []).filter(Boolean);
+    if (pathspecs.length === 0) {
+      return null;
+    }
+
+    const output = await this.commandRunner.execGit([
+      'diff',
+      '--binary',
+      '--find-renames',
+      ...(cached ? ['--cached'] : []),
+      '--',
+      ...pathspecs,
+    ]);
+
+    return output || null;
+  }
+
+  async backupAndClearOverlappingEntries({
+    beforeRef,
+    branchName = null,
+    entries = [],
+    targetRef = null,
+  } = {}) {
+    const backupEntries = await Promise.all(entries.map(async (entry) => ({
+      ...entry,
+      stagedPatchContent: entry.hasStagedChanges
+        ? await this.createPatchForEntry(entry, { cached: true })
+        : null,
+      worktreePatchContent: entry.hasWorkingTreeChanges
+        ? await this.createPatchForEntry(entry, { cached: false })
+        : null,
+    })));
+
+    const pullBackup = await this.pullBackupStore.createBackup({
+      branch: branchName,
+      entries: backupEntries,
+      headRef: beforeRef,
+      targetRef,
+    });
+
+    for (const entry of backupEntries) {
+      if (entry.isUntracked && !entry.hasTrackedChanges) {
+        await this.commandRunner.execGit(['clean', '-f', '--', entry.path]);
+        continue;
+      }
+
+      await this.restorePathToHead(entry.path);
+    }
+
+    return pullBackup;
+  }
+
+  async restorePathToHead(path) {
+    const normalizedPath = normalizeRelativeGitPath(path);
+    const sourceRef = 'HEAD';
+    const existsOnSource = await this.pathExistsAtRef(sourceRef, normalizedPath);
+
+    if (existsOnSource) {
+      await this.commandRunner.execGit(['restore', '--source', sourceRef, '--staged', '--worktree', '--', normalizedPath]);
+      return;
+    }
+
+    await this.commandRunner.execGit(['rm', '-f', '--ignore-unmatch', '--', normalizedPath]);
+    await this.commandRunner.execGit(['clean', '-f', '--', normalizedPath]);
+  }
+
+  async hasConflictedStatus() {
+    const status = await this.getStatus({ force: true });
+    return (status.sections ?? [])
+      .flatMap((section) => section.files ?? [])
+      .some((file) => file?.status === 'conflicted');
+  }
+
+  async classifyPullError(error) {
+    if (await this.hasConflictedStatus()) {
+      return createGitRequestError(
+        409,
+        'Pull applied remote updates, but reapplying local changes caused conflicts. Review the conflicted files and the pull backup summary.',
+        'pull_conflicted_after_autostash',
+      );
+    }
+
+    return error;
+  }
+
   async createWorkspaceChangeFromRefs(beforeRef, afterRef) {
     if (!afterRef || beforeRef === afterRef) {
       return createEmptyWorkspaceChange();

package/src/server/infrastructure/git/responses.js

@@ -1,3 +1,8 @@
+import {
+  createEmptyWorkspaceChange as createSharedEmptyWorkspaceChange,
+  createWorkspaceChange as createSharedWorkspaceChange,
+} from '../../../domain/workspace-change.js';
+
 const STATUS_MAP = {
   A: { code: 'A', label: 'added', status: 'added' },
   C: { code: 'C', label: 'copied', status: 'copied' },
@@ -43,12 +48,7 @@ export function createEmptyBranchStatus() {
 }
 
 export function createEmptyWorkspaceChange() {
-  return {
-    changedPaths: [],
-    deletedPaths: [],
-    refreshExplorer: true,
-    renamedPaths: [],
-  };
+  return createSharedEmptyWorkspaceChange();
 }
 
 export function createEmptyStatusResponse() {
@@ -92,17 +92,10 @@ export function createWorkspaceChange({
   refreshExplorer = true,
   renamedPaths = [],
 } = {}) {
-  return {
-    changedPaths: Array.from(new Set((changedPaths ?? []).filter(Boolean))),
-    deletedPaths: Array.from(new Set((deletedPaths ?? []).filter(Boolean))),
-    refreshExplorer: Boolean(refreshExplorer),
-    renamedPaths: Array.from(new Map(
-      (renamedPaths ?? [])
-        .filter((entry) => entry?.oldPath && entry?.newPath && entry.oldPath !== entry.newPath)
-        .map((entry) => [`${entry.oldPath}:${entry.newPath}`, {
-          newPath: entry.newPath,
-          oldPath: entry.oldPath,
-        }]),
-    ).values()),
-  };
+  return createSharedWorkspaceChange({
+    changedPaths,
+    deletedPaths,
+    refreshExplorer,
+    renamedPaths,
+  });
 }

package/src/server/infrastructure/http/create-git-api-command-handler.js

@@ -1,7 +1,7 @@
 import { getRequestErrorStatusCode } from './http-errors.js';
 import { jsonResponse } from './http-response.js';
 import { parseJsonBody } from './request-body.js';
-import { createEmptyWorkspaceChange } from '../git/responses.js';
+import { createEmptyWorkspaceChange, hasWorkspaceMutation } from '../../../domain/workspace-change.js';
 
 async function parseRequiredBody(req, res, fieldName) {
   const body = await parseJsonBody(req);
@@ -16,7 +16,11 @@ async function parseRequiredBody(req, res, fieldName) {
 function handleGitError(req, res, error, logMessage, fallbackMessage) {
   const statusCode = getRequestErrorStatusCode(error);
   if (statusCode) {
-    jsonResponse(req, res, statusCode, { error: error.message });
+    const payload = { error: error.message };
+    if (typeof error?.requestCode === 'string') {
+      payload.code = error.requestCode;
+    }
+    jsonResponse(req, res, statusCode, payload);
     return true;
   }
 
@@ -25,19 +29,16 @@ function handleGitError(req, res, error, logMessage, fallbackMessage) {
   return true;
 }
 
-function hasWorkspaceMutation(workspaceChange = {}) {
-  return Boolean(
-    (workspaceChange.changedPaths?.length ?? 0) > 0
-    || (workspaceChange.deletedPaths?.length ?? 0) > 0
-    || (workspaceChange.renamedPaths?.length ?? 0) > 0,
-  );
+function readRequestId(req) {
+  const value = String(req.headers['x-collabmd-request-id'] || '').trim();
+  return value ? value.slice(0, 120) : null;
 }
 
 async function applyWorkspaceMutationEffects({
-  backlinkIndex,
+  action,
+  req,
   responsePayload,
-  roomRegistry,
-  vaultFileStore,
+  workspaceMutationCoordinator,
 }) {
   const workspaceChange = responsePayload?.workspaceChange ?? createEmptyWorkspaceChange();
   responsePayload.workspaceChange = workspaceChange;
@@ -46,17 +47,19 @@ async function applyWorkspaceMutationEffects({
     return responsePayload;
   }
 
-  await vaultFileStore?.reconcileSidecars?.(workspaceChange);
-  await backlinkIndex?.build?.();
-  await roomRegistry?.reconcileWorkspaceChange?.(workspaceChange);
+  await workspaceMutationCoordinator?.apply?.({
+    action,
+    origin: 'git',
+    requestId: readRequestId(req),
+    sourceRef: responsePayload?.sourceRef ?? null,
+    workspaceChange,
+  });
   return responsePayload;
 }
 
 export function createGitApiCommandHandler({
-  backlinkIndex = null,
   gitService,
-  roomRegistry = null,
-  vaultFileStore = null,
+  workspaceMutationCoordinator = null,
 }) {
   return async function handleGitApiCommand(req, res, requestUrl) {
     if (requestUrl.pathname === '/api/git/stage' && req.method === 'POST') {
@@ -67,10 +70,12 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.stageFile(body.path),
-          roomRegistry,
-          vaultFileStore,
+          action: 'stage',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.stageFile(body.path),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to stage git file:', 'Failed to stage git file');
@@ -86,10 +91,12 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.unstageFile(body.path),
-          roomRegistry,
-          vaultFileStore,
+          action: 'unstage',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.unstageFile(body.path),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to unstage git file:', 'Failed to unstage git file');
@@ -105,12 +112,14 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.commitStaged({
-            message: body.message,
-          }),
-          roomRegistry,
-          vaultFileStore,
+          action: 'commit',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.commitStaged({
+              message: body.message,
+            }),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to commit staged changes:', 'Failed to commit staged changes');
@@ -121,10 +130,12 @@ export function createGitApiCommandHandler({
     if (requestUrl.pathname === '/api/git/push' && req.method === 'POST') {
       try {
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.pushBranch(),
-          roomRegistry,
-          vaultFileStore,
+          action: 'push',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.pushBranch(),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to push git branch:', 'Failed to push git branch');
@@ -135,10 +146,12 @@ export function createGitApiCommandHandler({
     if (requestUrl.pathname === '/api/git/pull' && req.method === 'POST') {
       try {
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.pullBranch(),
-          roomRegistry,
-          vaultFileStore,
+          action: 'pull',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.pullBranch(),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to pull git branch:', 'Failed to pull git branch');
@@ -154,10 +167,12 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.resetFileToHead(body.path),
-          roomRegistry,
-          vaultFileStore,
+          action: 'reset-file',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.resetFileToHead(body.path),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to reset git file:', 'Failed to reset git file');

package/src/server/infrastructure/http/create-git-api-handler.js

@@ -7,6 +7,7 @@ export function createGitApiHandler({
   gitService = null,
   roomRegistry = null,
   vaultFileStore = null,
+  workspaceMutationCoordinator = null,
 }) {
   const handleGitApiQuery = createGitApiQueryHandler({ gitService });
   const handleGitApiCommand = createGitApiCommandHandler({
@@ -14,6 +15,7 @@ export function createGitApiHandler({
     gitService,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
 
   return async function handleGitApi(req, res, requestUrl) {

package/src/server/infrastructure/http/create-git-api-query-handler.js

@@ -21,7 +21,11 @@ function isTruthyParam(value) {
 function handleGitError(req, res, error, message, fallback) {
   const statusCode = getRequestErrorStatusCode(error);
   if (statusCode) {
-    jsonResponse(req, res, statusCode, { error: error.message });
+    const payload = { error: error.message };
+    if (typeof error?.requestCode === 'string') {
+      payload.code = error.requestCode;
+    }
+    jsonResponse(req, res, statusCode, payload);
     return true;
   }
 
@@ -57,6 +61,17 @@ export function createGitApiQueryHandler({ gitService }) {
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/pull-backups' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, {
+          backups: await gitService.listPullBackups(),
+        });
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read pull backups:', 'Failed to read pull backups');
+      }
+      return true;
+    }
+
     return false;
   };
 }

package/src/server/infrastructure/http/create-request-handler.js

@@ -42,6 +42,8 @@ export function createRequestHandler(
   roomRegistry = null,
   plantUmlRenderer = null,
   gitService = null,
+  workspaceMutationCoordinator = null,
+  fileSystemSyncService = null,
 ) {
   const handleEsmProxy = createEsmProxyHandler();
   const handleStaticRequest = createStaticHandler(config, authService);
@@ -51,12 +53,14 @@ export function createRequestHandler(
     gitService,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
   const handleVaultApi = createVaultApiHandler({
     backlinkIndex,
     plantUmlRenderer,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
 
   return async function handleRequest(req, res) {
@@ -103,8 +107,11 @@ export function createRequestHandler(
     }
 
     if (config.nodeEnv === 'test' && requestUrl.pathname === '/api/test/reset-state' && req.method === 'POST') {
+      await fileSystemSyncService?.resetForExternalStateChange?.();
       await roomRegistry?.reset?.();
       await backlinkIndex?.build?.();
+      await workspaceMutationCoordinator?.initialize?.();
+      await fileSystemSyncService?.resetForExternalStateChange?.();
       jsonResponse(req, res, 200, { ok: true });
       return;
     }