collabmd 0.1.23 → 0.1.26

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

@@ -1,4 +1,5 @@
 import {
+  isDrawioFilePath,
   isExcalidrawFilePath,
   isMermaidFilePath,
   isPlantUmlFilePath,
@@ -26,6 +27,10 @@ function selectWriteOperation(vaultFileStore, filePath, content) {
     return vaultFileStore.writeExcalidrawFile(filePath, content);
   }
 
+  if (isDrawioFilePath(filePath)) {
+    return vaultFileStore.writeDrawioFile(filePath, content);
+  }
+
   if (isMermaidFilePath(filePath)) {
     return vaultFileStore.writeMermaidFile(filePath, content);
   }
@@ -54,6 +59,10 @@ function handleVaultError(req, res, error, logMessage, fallbackMessage) {
   return true;
 }
 
+function getDirectoryDeleteStatusCode(message = '') {
+  return String(message).includes('Directory is not empty') ? 409 : 400;
+}
+
 export function createVaultApiCommandHandler({
   vaultFileStore,
   workspaceMutationCoordinator = null,
@@ -246,6 +255,69 @@ export function createVaultApiCommandHandler({
       return true;
     }
 
+    if (requestUrl.pathname === '/api/directory' && req.method === 'PATCH') {
+      try {
+        const body = await parseJsonBody(req);
+        if (!body.oldPath || !body.newPath) {
+          jsonResponse(req, res, 400, { error: 'Missing oldPath or newPath' });
+          return true;
+        }
+
+        const workspaceChange = await workspaceMutationCoordinator?.createDirectoryRenameWorkspaceChange?.(body.oldPath, body.newPath);
+        const result = await vaultFileStore.renameDirectory(body.oldPath, body.newPath);
+        if (!result.ok) {
+          jsonResponse(req, res, 400, { error: result.error });
+          return true;
+        }
+
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'rename-directory',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: workspaceChange ?? {
+            renamedPaths: [{ oldPath: body.oldPath, newPath: body.newPath }],
+          },
+        });
+
+        jsonResponse(req, res, 200, { ok: true, path: body.newPath });
+      } catch (error) {
+        handleVaultError(req, res, error, '[api] Failed to rename directory:', 'Failed to rename directory');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/directory' && req.method === 'DELETE') {
+      const dirPath = requestUrl.searchParams.get('path');
+      const recursive = requestUrl.searchParams.get('recursive') === '1';
+      if (!dirPath) {
+        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+        return true;
+      }
+
+      try {
+        const workspaceChange = await workspaceMutationCoordinator?.createDirectoryDeleteWorkspaceChange?.(dirPath);
+        const result = await vaultFileStore.deleteDirectory(dirPath, { recursive });
+        if (!result.ok) {
+          jsonResponse(req, res, getDirectoryDeleteStatusCode(result.error), { error: result.error });
+          return true;
+        }
+
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'delete-directory',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: workspaceChange ?? {
+            deletedPaths: [dirPath],
+          },
+        });
+
+        jsonResponse(req, res, 200, { ok: true });
+      } catch (error) {
+        handleVaultError(req, res, error, '[api] Failed to delete directory:', 'Failed to delete directory');
+      }
+      return true;
+    }
+
     return false;
   };
 }

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

@@ -1,6 +1,7 @@
 import { basename } from 'node:path';
 
 import {
+  isDrawioFilePath,
   isExcalidrawFilePath,
   isImageAttachmentFilePath,
   isMermaidFilePath,
@@ -45,6 +46,10 @@ function selectReadOperation(vaultFileStore, filePath) {
     return vaultFileStore.readExcalidrawFile(filePath);
   }
 
+  if (isDrawioFilePath(filePath)) {
+    return vaultFileStore.readDrawioFile(filePath);
+  }
+
   if (isMermaidFilePath(filePath)) {
     return vaultFileStore.readMermaidFile(filePath);
   }

package/src/server/infrastructure/persistence/path-utils.js

@@ -3,7 +3,7 @@ import { isAbsolute, normalize, relative, resolve } from 'path';
 import { isVaultFilePath } from '../../../domain/file-kind.js';
 
 export const IGNORED_DIRECTORIES = new Set(['.git', '.obsidian', '.trash', 'node_modules', '.DS_Store']);
-export const VAULT_FILE_PATH_REQUIREMENT = '.md, .excalidraw, .mmd, .mermaid, .puml, .plantuml, .png, .jpg, .jpeg, .webp, .gif, or .svg';
+export const VAULT_FILE_PATH_REQUIREMENT = '.md, .excalidraw, .drawio, .mmd, .mermaid, .puml, .plantuml, .png, .jpg, .jpeg, .webp, .gif, or .svg';
 export const INVALID_VAULT_FILE_PATH_ERROR = `Invalid file path — must end in ${VAULT_FILE_PATH_REQUIREMENT}`;
 export const INVALID_DIRECTORY_PATH_ERROR = 'Invalid directory path';
 
@@ -58,6 +58,17 @@ export function resolveVaultDirectoryPath(vaultDir, requestedPath) {
   return { absolute, error: null };
 }
 
+export function resolveVaultDirectoryRenamePaths(vaultDir, oldPath, newPath) {
+  const absoluteOld = sanitizeVaultPath(vaultDir, oldPath);
+  const absoluteNew = sanitizeVaultPath(vaultDir, newPath);
+
+  if (!absoluteOld || !absoluteNew) {
+    return { absoluteNew: null, absoluteOld: null, error: INVALID_DIRECTORY_PATH_ERROR };
+  }
+
+  return { absoluteNew, absoluteOld, error: null };
+}
+
 export function resolveVaultRenamePaths(vaultDir, oldPath, newPath) {
   const absoluteOld = sanitizeVaultPath(vaultDir, oldPath);
   const absoluteNew = sanitizeVaultPath(vaultDir, newPath);

package/src/server/infrastructure/persistence/vault-content-adapter.js

@@ -1,4 +1,5 @@
 import {
+  isDrawioFilePath,
   isExcalidrawFilePath,
   isMarkdownFilePath,
   isMermaidFilePath,
@@ -32,6 +33,11 @@ const adapters = [
     kind: 'excalidraw',
     matches: isExcalidrawFilePath,
   }),
+  new VaultContentAdapter({
+    invalidPathError: 'Invalid file path — must end in .drawio',
+    kind: 'drawio',
+    matches: isDrawioFilePath,
+  }),
   new VaultContentAdapter({
     invalidPathError: 'Invalid file path — must end in .mmd or .mermaid',
     kind: 'mermaid',

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
+import { mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from 'fs/promises';
 import { basename, dirname, extname, join, relative, resolve } from 'path';
 
 import {
@@ -12,6 +12,7 @@ import {
   INVALID_VAULT_FILE_PATH_ERROR,
   isIgnoredVaultEntry,
   resolveVaultDirectoryPath,
+  resolveVaultDirectoryRenamePaths,
   resolveVaultFilePath,
   resolveVaultRenamePaths,
   sanitizeVaultPath,
@@ -73,6 +74,26 @@ function createWorkspaceEntry(relativePath, type) {
   };
 }
 
+function replacePathPrefix(pathValue, oldPrefix, newPrefix) {
+  if (pathValue === oldPrefix) {
+    return newPrefix;
+  }
+
+  return `${newPrefix}${pathValue.slice(oldPrefix.length)}`;
+}
+
+function sortWorkspacePaths(paths = [], direction = 'asc') {
+  const factor = direction === 'desc' ? -1 : 1;
+  return [...paths].sort((left, right) => {
+    const depthDelta = left.split('/').length - right.split('/').length;
+    if (depthDelta !== 0) {
+      return depthDelta * factor;
+    }
+
+    return left.localeCompare(right, undefined, { sensitivity: 'base' }) * factor;
+  });
+}
+
 async function cleanupPaths(paths = []) {
   await Promise.allSettled(paths.filter(Boolean).map((pathValue) => rm(pathValue, { force: true })));
 }
@@ -298,6 +319,10 @@ export class VaultFileStore {
     return this.readContentFile(filePath, 'excalidraw');
   }
 
+  async readDrawioFile(filePath) {
+    return this.readContentFile(filePath, 'drawio');
+  }
+
   async readMermaidFile(filePath) {
     return this.readContentFile(filePath, 'mermaid');
   }
@@ -336,6 +361,10 @@ export class VaultFileStore {
     return this.writeContentFile(filePath, content, 'excalidraw', options);
   }
 
+  async writeDrawioFile(filePath, content, options = {}) {
+    return this.writeContentFile(filePath, content, 'drawio', options);
+  }
+
   async writeMermaidFile(filePath, content, options = {}) {
     return this.writeContentFile(filePath, content, 'mermaid', options);
   }
@@ -550,6 +579,58 @@ export class VaultFileStore {
     return { ok: true };
   }
 
+  async listWorkspacePathsUnder(pathValue) {
+    const normalizedRoot = String(pathValue ?? '').replace(/\\/g, '/').trim();
+    if (!normalizedRoot) {
+      return [];
+    }
+
+    const { absolute } = resolveVaultDirectoryPath(this.vaultDir, normalizedRoot);
+    if (!absolute) {
+      return [];
+    }
+
+    try {
+      const info = await stat(absolute);
+      if (!info.isDirectory()) {
+        return [];
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+
+      throw error;
+    }
+
+    const paths = [normalizedRoot];
+    const visitDirectory = async (directoryPath) => {
+      const dirEntries = await readdir(directoryPath, { withFileTypes: true });
+      const sortedEntries = dirEntries.sort((left, right) => left.name.localeCompare(right.name, undefined, { sensitivity: 'base' }));
+
+      for (const entry of sortedEntries) {
+        if (isIgnoredVaultEntry(entry.name)) {
+          continue;
+        }
+
+        const childAbsolutePath = join(directoryPath, entry.name);
+        const relativePath = toVaultRelativePath(this.vaultDir, childAbsolutePath).replace(/\\/g, '/');
+        if (entry.isDirectory()) {
+          paths.push(relativePath);
+          await visitDirectory(childAbsolutePath);
+          continue;
+        }
+
+        if (isVaultFilePath(entry.name)) {
+          paths.push(relativePath);
+        }
+      }
+    };
+
+    await visitDirectory(absolute);
+    return sortWorkspacePaths(paths);
+  }
+
   async deleteFile(filePath) {
     const { absolute, error } = resolveVaultFilePath(this.vaultDir, filePath);
     if (!absolute) {
@@ -573,6 +654,14 @@ export class VaultFileStore {
       return { ok: false, error };
     }
 
+    if (absoluteOld === absoluteNew) {
+      return { ok: true };
+    }
+
+    if (await pathExists(absoluteNew)) {
+      return { ok: false, error: 'Target path already exists' };
+    }
+
     try {
       await this.runManagedWrite([oldPath, newPath], async () => {
         await mkdir(dirname(absoluteNew), { recursive: true });
@@ -599,6 +688,82 @@ export class VaultFileStore {
     }
   }
 
+  async renameDirectory(oldPath, newPath) {
+    const { absoluteNew, absoluteOld, error } = resolveVaultDirectoryRenamePaths(this.vaultDir, oldPath, newPath);
+    if (!absoluteOld || !absoluteNew) {
+      return { ok: false, error };
+    }
+
+    if (absoluteOld === absoluteNew) {
+      return { ok: true };
+    }
+
+    if (await pathExists(absoluteNew)) {
+      return { ok: false, error: 'Target path already exists' };
+    }
+
+    const managedPaths = await this.listWorkspacePathsUnder(oldPath);
+    const nextManagedPaths = managedPaths.map((pathValue) => replacePathPrefix(pathValue, oldPath, newPath));
+
+    try {
+      await this.runManagedWrite([oldPath, newPath, ...managedPaths, ...nextManagedPaths], async () => {
+        await mkdir(dirname(absoluteNew), { recursive: true });
+        await rename(absoluteOld, absoluteNew);
+        await Promise.all(
+          managedPaths.map((pathValue, index) => this.sidecarStore.renameAllForFile(pathValue, nextManagedPaths[index])),
+        );
+      });
+      return { ok: true };
+    } catch (renameError) {
+      return { ok: false, error: renameError.message };
+    }
+  }
+
+  async deleteDirectory(dirPath, { recursive = false } = {}) {
+    const { absolute, error } = resolveVaultDirectoryPath(this.vaultDir, dirPath);
+    if (!absolute) {
+      return { ok: false, error };
+    }
+
+    const managedPaths = await this.listWorkspacePathsUnder(dirPath);
+
+    try {
+      const info = await stat(absolute);
+      if (!info.isDirectory()) {
+        return { ok: false, error: 'Path is not a directory' };
+      }
+    } catch (statError) {
+      if (statError.code === 'ENOENT') {
+        return { ok: true };
+      }
+
+      return { ok: false, error: statError.message };
+    }
+
+    try {
+      if (!recursive) {
+        const contents = await readdir(absolute);
+        if (contents.length > 0) {
+          return { ok: false, error: 'Directory is not empty' };
+        }
+      }
+
+      await this.runManagedWrite([dirPath, ...managedPaths], async () => {
+        if (recursive) {
+          await rm(absolute, { force: true, recursive: true });
+        } else {
+          await rmdir(absolute);
+        }
+        await Promise.all(
+          managedPaths.map((pathValue) => this.sidecarStore.deleteAllForFile(pathValue)),
+        );
+      });
+      return { ok: true };
+    } catch (deleteError) {
+      return { ok: false, error: deleteError.message };
+    }
+  }
+
   async countVaultFiles() {
     return this.countFilesInDir(this.vaultDir);
   }
@@ -623,12 +788,10 @@ export class VaultFileStore {
   async reconcileCollaborationSnapshots({
     changedPaths = [],
     deletedPaths = [],
-    renamedPaths = [],
   } = {}) {
     const affectedPaths = new Set([
       ...(changedPaths ?? []).filter(Boolean),
       ...(deletedPaths ?? []).filter(Boolean),
-      ...((renamedPaths ?? []).flatMap((entry) => [entry?.oldPath, entry?.newPath]).filter(Boolean)),
     ]);
 
     await Promise.allSettled(

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

@@ -34,6 +34,10 @@ function normalizeWorkspacePath(pathValue = '') {
   return String(pathValue ?? '').replace(/\\/g, '/').trim();
 }
 
+function isDirectoryWorkspaceEntry(entry = {}) {
+  return entry?.type === 'directory' || entry?.nodeType === 'directory';
+}
+
 function getParentDirectoryPath(pathValue = '') {
   const parentPath = dirname(normalizeWorkspacePath(pathValue)).replace(/\\/g, '/');
   return parentPath === '.' ? '' : parentPath;
@@ -191,14 +195,16 @@ export class WorkspaceMutationCoordinator {
   isIncrementalApiAction(action) {
     return action === 'create-directory'
       || action === 'create-file'
+      || action === 'delete-directory'
       || action === 'delete-file'
+      || action === 'rename-directory'
       || action === 'rename-file'
       || action === 'upload-attachment'
       || action === 'write-file';
   }
 
   async readWorkspacePathState(pathValue, {
-    expectDirectory = false,
+    expectDirectory = null,
   } = {}) {
     const normalizedPath = normalizeWorkspacePath(pathValue);
     if (!normalizedPath) {
@@ -212,7 +218,7 @@ export class WorkspaceMutationCoordinator {
 
     try {
       const info = await stat(absolutePath);
-      if (expectDirectory) {
+      if (expectDirectory === true) {
         if (!info.isDirectory()) {
           return null;
         }
@@ -223,6 +229,17 @@ export class WorkspaceMutationCoordinator {
         };
       }
 
+      if (expectDirectory === false && info.isDirectory()) {
+        return null;
+      }
+
+      if (info.isDirectory()) {
+        return {
+          entry: createWorkspaceEntry(normalizedPath, 'directory'),
+          metadata: createWorkspaceMetadata(normalizedPath, 'directory', info),
+        };
+      }
+
       if (!info.isFile() || !isVaultFilePath(normalizedPath)) {
         return null;
       }
@@ -296,7 +313,10 @@ export class WorkspaceMutationCoordinator {
         return null;
       }
 
-      const nextPathState = await this.readWorkspacePathState(entry.newPath);
+      const previousEntry = previousState.entries.get(entry.oldPath);
+      const nextPathState = await this.readWorkspacePathState(entry.newPath, {
+        expectDirectory: isDirectoryWorkspaceEntry(previousEntry) ? true : null,
+      });
       if (!nextPathState) {
         return null;
       }
@@ -441,6 +461,67 @@ export class WorkspaceMutationCoordinator {
     return filtered;
   }
 
+  async getWorkspaceStateSnapshot() {
+    return this.workspaceState ?? this.vaultFileStore.scanWorkspaceState();
+  }
+
+  async createDirectoryRenameWorkspaceChange(oldPath, newPath) {
+    const normalizedOldPath = normalizeWorkspacePath(oldPath);
+    const normalizedNewPath = normalizeWorkspacePath(newPath);
+    if (!normalizedOldPath || !normalizedNewPath || normalizedOldPath === normalizedNewPath) {
+      return createEmptyWorkspaceChange();
+    }
+
+    const workspaceState = await this.getWorkspaceStateSnapshot();
+    const renamedPaths = Array.from(workspaceState.entries.keys())
+      .filter((pathValue) => pathValue === normalizedOldPath || pathValue.startsWith(`${normalizedOldPath}/`))
+      .sort((left, right) => {
+        const depthDelta = left.split('/').length - right.split('/').length;
+        if (depthDelta !== 0) {
+          return depthDelta;
+        }
+
+        return left.localeCompare(right, undefined, { sensitivity: 'base' });
+      })
+      .map((pathValue) => ({
+        oldPath: pathValue,
+        newPath: pathValue === normalizedOldPath
+          ? normalizedNewPath
+          : `${normalizedNewPath}${pathValue.slice(normalizedOldPath.length)}`,
+      }));
+
+    if (renamedPaths.length === 0) {
+      renamedPaths.push({ oldPath: normalizedOldPath, newPath: normalizedNewPath });
+    }
+
+    return createWorkspaceChange({ renamedPaths });
+  }
+
+  async createDirectoryDeleteWorkspaceChange(pathValue) {
+    const normalizedPath = normalizeWorkspacePath(pathValue);
+    if (!normalizedPath) {
+      return createEmptyWorkspaceChange();
+    }
+
+    const workspaceState = await this.getWorkspaceStateSnapshot();
+    const deletedPaths = Array.from(workspaceState.entries.keys())
+      .filter((entryPath) => entryPath === normalizedPath || entryPath.startsWith(`${normalizedPath}/`))
+      .sort((left, right) => {
+        const depthDelta = right.split('/').length - left.split('/').length;
+        if (depthDelta !== 0) {
+          return depthDelta;
+        }
+
+        return left.localeCompare(right, undefined, { sensitivity: 'base' });
+      });
+
+    if (deletedPaths.length === 0) {
+      deletedPaths.push(normalizedPath);
+    }
+
+    return createWorkspaceChange({ deletedPaths });
+  }
+
   async reconcileBacklinks(workspaceChange, nextState, {
     forceRebuild = false,
   } = {}) {

package/public/assets/css/base.css

@@ -1 +0,0 @@
-*,*:before,*:after{box-sizing:border-box;margin:0;padding:0}html{-moz-text-size-adjust:none;-webkit-text-size-adjust:none;text-size-adjust:none;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;text-rendering:optimizeLegibility;scroll-behavior:smooth;hanging-punctuation:first last;scroll-padding-top:var(--space-16)}body{min-height:100dvh;line-height:1.6;font-family:var(--font-body, sans-serif);font-size:var(--text-sm);color:var(--color-text);background-color:var(--color-bg)}img,picture,video,canvas,svg{display:block;max-width:100%;height:auto}ul[role=list],ol[role=list]{list-style:none}input,button,textarea,select{font:inherit;color:inherit}h1,h2,h3,h4,h5,h6{font-family:var(--font-display, inherit);text-wrap:balance;line-height:1.15}p,li,figcaption{text-wrap:pretty;max-width:72ch}::selection{background:oklch(from var(--color-primary) l c h / .25);color:var(--color-text)}:focus-visible{outline:2px solid var(--color-primary);outline-offset:3px;border-radius:var(--radius-sm)}@media(prefers-reduced-motion:reduce){*,*:before,*:after{animation-duration:.01ms!important;animation-iteration-count:1!important;transition-duration:.01ms!important;scroll-behavior:auto!important}}button{cursor:pointer;background:none;border:none}table{border-collapse:collapse;width:100%}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border-width:0}