collabmd 0.1.48 → 0.1.51

package/src/server/domain/collaboration/collaboration-room.js

@@ -4,12 +4,18 @@ import * as syncProtocol from 'y-protocols/sync';
 import * as encoding from 'lib0/encoding';
 import * as decoding from 'lib0/decoding';
 
-import { MSG_AWARENESS, MSG_SYNC } from './protocol.js';
+import {
+  MSG_AGENT_FLUSH,
+  MSG_AGENT_FLUSH_ACK,
+  MSG_AWARENESS,
+  MSG_SYNC,
+} from './protocol.js';
 import { CollaborationDocumentStore } from './collaboration-document-store.js';
 import { logPerfEvent } from '../../config/perf-logging.js';
 import { populateCommentThreads, serializeCommentThreads } from '../../../domain/comment-threads.js';
 import { getVaultFileKind } from '../../../domain/file-kind.js';
 import {
+  applySceneDiffToExcalidrawRoom,
   EXCALIDRAW_APP_STATE_KEY,
   EXCALIDRAW_ELEMENTS_KEY,
   EXCALIDRAW_FILES_KEY,
@@ -21,6 +27,7 @@ import {
   tryParseExcalidrawSceneJson,
 } from '../../../domain/excalidraw-room-codec.js';
 import { isDrawioLeaseRoom } from '../../../domain/drawio-room.js';
+import { normalizeEditableText } from '../../../domain/editable-text.js';
 import { normalizeWorkspaceEvent } from '../../../domain/workspace-change.js';
 import { WORKSPACE_EVENT_MAX_MESSAGES, WORKSPACE_ROOM_NAME } from '../../../domain/workspace-room.js';
 
@@ -130,9 +137,6 @@ function isWorkspaceRoom(name) {
   return name === WORKSPACE_ROOM_NAME;
 }
 
-function normalizeEditableText(content) {
-  return String(content ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-}
 
 function isContentCleanOrigin(origin) {
   return origin === 'hydrate'
@@ -171,6 +175,34 @@ function computeTextReplacement(currentContent, nextContent) {
   };
 }
 
+function reconcileTextContent(baselineContent, currentContent, externalContent) {
+  const localReplacement = computeTextReplacement(baselineContent, currentContent);
+  const externalReplacement = computeTextReplacement(baselineContent, externalContent);
+  if (!externalReplacement) {
+    return { content: currentContent, preservesPendingChanges: true };
+  }
+
+  const localEnd = localReplacement.start + localReplacement.deleteCount;
+  const externalEnd = externalReplacement.start + externalReplacement.deleteCount;
+  let externalStart;
+  if (localEnd <= externalReplacement.start) {
+    externalStart = externalReplacement.start
+      + localReplacement.insertText.length
+      - localReplacement.deleteCount;
+  } else if (externalEnd <= localReplacement.start) {
+    externalStart = externalReplacement.start;
+  } else {
+    return { content: externalContent, preservesPendingChanges: false };
+  }
+
+  return {
+    content: currentContent.slice(0, externalStart)
+      + externalReplacement.insertText
+      + currentContent.slice(externalStart + externalReplacement.deleteCount),
+    preservesPendingChanges: true,
+  };
+}
+
 export class CollaborationRoom {
   constructor({
     documentStore = null,
@@ -504,7 +536,8 @@ export class CollaborationRoom {
         snapshot: Y.encodeStateAsUpdate(this.doc),
       });
       if (includeContent) {
-        this.resetContentBaseline();
+        this.persistedContentBaseline = content;
+        this.refreshContentDirty();
       }
     })();
 
@@ -568,29 +601,37 @@ export class CollaborationRoom {
     }
 
     const ytext = this.doc.getText('codemirror');
+    const currentContent = ytext.toString();
     const normalizedContent = normalizeEditableText(content);
-    const replacement = computeTextReplacement(ytext.toString(), normalizedContent);
-    if (!replacement && !replaceCommentThreads) {
-      this.resetContentBaseline();
-      return { highlightRange: null, ok: true, skipped: true };
-    }
-
-    this.doc.transact(() => {
-      if (replacement?.deleteCount) {
-        ytext.delete(replacement.start, replacement.deleteCount);
-      }
-      if (replacement?.insertText) {
-        ytext.insert(replacement.start, replacement.insertText);
-      }
-      if (replaceCommentThreads) {
-        if (comments.length > 0) {
-          comments.delete(0, comments.length);
+    const reconciliation = this.refreshContentDirty() && this.persistedContentBaseline !== null
+      ? reconcileTextContent(this.persistedContentBaseline, currentContent, normalizedContent)
+      : { content: normalizedContent, preservesPendingChanges: false };
+    const replacement = computeTextReplacement(currentContent, reconciliation.content);
+    const skipped = !replacement && !replaceCommentThreads;
+    if (!skipped) {
+      this.doc.transact(() => {
+        if (replacement?.deleteCount) {
+          ytext.delete(replacement.start, replacement.deleteCount);
         }
-        populateCommentThreads(comments, commentThreads);
-      }
-    }, 'workspace-reconcile');
+        if (replacement?.insertText) {
+          ytext.insert(replacement.start, replacement.insertText);
+        }
+        if (replaceCommentThreads) {
+          if (comments.length > 0) {
+            comments.delete(0, comments.length);
+          }
+          populateCommentThreads(comments, commentThreads);
+        }
+      }, 'workspace-reconcile');
+    }
 
-    this.resetContentBaseline();
+    if (reconciliation.preservesPendingChanges) {
+      this.persistedContentBaseline = normalizedContent;
+      this.refreshContentDirty();
+      this.schedulePersist();
+    } else {
+      this.resetContentBaseline();
+    }
     return {
       highlightRange: replacement
         ? {
@@ -599,6 +640,7 @@ export class CollaborationRoom {
         }
         : null,
       ok: true,
+      ...(skipped && { skipped: true }),
     };
   }
 
@@ -832,6 +874,47 @@ export class CollaborationRoom {
     return true;
   }
 
+  isHydrated() {
+    return this.hydrated;
+  }
+
+  readEditableContent() {
+    if (!this.hydrated || this.deleted || this.destroyed || isExcalidrawRoom(this.name)) {
+      return null;
+    }
+    return this.doc.getText('codemirror').toString();
+  }
+
+  applyExactTextChanges(changes, { origin = 'agent' } = {}) {
+    if (!this.hydrated || this.deleted || this.destroyed || isExcalidrawRoom(this.name)) {
+      throw new Error('The collaborative document is unavailable');
+    }
+    const ytext = this.doc.getText('codemirror');
+    this.doc.transact(() => {
+      for (let index = changes.length - 1; index >= 0; index -= 1) {
+        const change = changes[index];
+        if (change.to > change.from) {
+          ytext.delete(change.from, change.to - change.from);
+        }
+        if (change.insert) {
+          ytext.insert(change.from, change.insert);
+        }
+      }
+    }, origin);
+    return changes.length;
+  }
+
+  applyExcalidrawScene(scene, { origin = 'agent' } = {}) {
+    if (!this.hydrated || this.deleted || this.destroyed || !isExcalidrawRoom(this.name)) {
+      throw new Error('The collaborative Excalidraw document is unavailable');
+    }
+    let changed = false;
+    this.doc.transact(() => {
+      changed = applySceneDiffToExcalidrawRoom(this.doc, scene);
+    }, origin);
+    return changed;
+  }
+
   getPersistedContent() {
     if (isWorkspaceRoom(this.name)) {
       return null;
@@ -897,6 +980,19 @@ export class CollaborationRoom {
           break;
         }
 
+        case MSG_AGENT_FLUSH: {
+          const requestId = decoding.readVarString(decoder);
+          if (!requestId || requestId.length > 128) {
+            break;
+          }
+
+          const encoder = encoding.createEncoder();
+          encoding.writeVarUint(encoder, MSG_AGENT_FLUSH_ACK);
+          encoding.writeVarString(encoder, requestId);
+          sendMessage.call(this, ws, encoding.toUint8Array(encoder), this);
+          break;
+        }
+
         default:
           console.warn(`[room:${this.name}] Unsupported message type: ${messageType}`);
       }

package/src/server/domain/collaboration/protocol.js

@@ -1,2 +1,6 @@
 export const MSG_SYNC = 0;
 export const MSG_AWARENESS = 1;
+export {
+  MSG_AGENT_FLUSH,
+  MSG_AGENT_FLUSH_ACK,
+} from '../../../domain/collaboration-protocol.js';

package/src/server/domain/hosted-workspace.js

@@ -381,7 +381,7 @@ export class HostedWorkspaceService {
     };
   }
 
-  async completeWorkspaceSetup() {
+  async completeWorkspaceSetup({ user = null } = {}) {
     await this.initialize();
     const team = await this.store.getTeam();
     if (!team) {
@@ -394,6 +394,15 @@ export class HostedWorkspaceService {
       setupCompletedAt: team.setupCompletedAt || timestamp,
     };
     await this.store.updateTeam(updatedTeam);
+    if (!team.setupCompletedAt) {
+      await this.store.createAuditEvent(createAuditEvent({
+        actor: user,
+        targetEmail: user?.email ?? '',
+        targetRole: user?.role ?? '',
+        timestamp,
+        type: 'workspace_setup_completed',
+      }));
+    }
     return updatedTeam;
   }
 
@@ -730,6 +739,27 @@ export class HostedWorkspaceService {
     return { ok: true };
   }
 
+  async recordAgentConnectionEvent({ connection, type, user }) {
+    if (!this.enabled) return;
+    const access = await this.authorizeWorkspaceAccess({ user });
+    if (!access.ok) {
+      throw createHostedError(access.statusCode, access.body.error, access.body.code);
+    }
+    await this.store.createAuditEvent(createAuditEvent({
+      actor: access.membership,
+      metadata: {
+        clientKind: connection.clientKind,
+        connectionId: connection.id,
+        expiresAt: connection.expiresAt,
+        label: connection.label,
+        scopes: connection.scopes,
+      },
+      targetRole: access.membership.role,
+      timestamp: nowMs(),
+      type,
+    }));
+  }
+
   async listAuditEvents(user) {
     await this.requireAdmin(user);
     return (await this.store.listAuditEvents()).map(publicAuditEvent);

package/src/server/domain/markdown-reference-extractor.js

@@ -130,6 +130,18 @@ export function createReferenceTargetAliasMap(renamedEntries = []) {
 
   return aliases;
 }
+export function collectMarkdownImageSources(markdownText = '') {
+  const sources = [];
+  String(markdownText ?? '').split('\n').forEach((line, lineIndex) => {
+    MARKDOWN_IMAGE_OPEN_RE.lastIndex = 0;
+    while (MARKDOWN_IMAGE_OPEN_RE.exec(line) !== null) {
+      const source = parseMarkdownImageDestination(line.slice(MARKDOWN_IMAGE_OPEN_RE.lastIndex));
+      if (source) sources.push({ line: lineIndex + 1, source });
+    }
+  });
+  return sources;
+}
+
 
 export function collectMarkdownReferences(markdownText = '', {
   sourceFilePath = '',
@@ -139,7 +151,7 @@ export function collectMarkdownReferences(markdownText = '', {
   const references = [];
   const lines = String(markdownText ?? '').split('\n');
 
-  for (const line of lines) {
+  for (const [lineIndex, line] of lines.entries()) {
     const context = line.trim();
 
     INTERNAL_LINK_RE.lastIndex = 0;
@@ -155,6 +167,7 @@ export function collectMarkdownReferences(markdownText = '', {
       references.push({
         context,
         isEmbed: Boolean(linkMatch[1]),
+        line: lineIndex + 1,
         rawTarget,
         rawTargetKey: normalizeReferenceTargetKey(rawTarget),
         resolvedPath,
@@ -176,6 +189,7 @@ export function collectMarkdownReferences(markdownText = '', {
       references.push({
         context,
         isEmbed: true,
+        line: lineIndex + 1,
         rawTarget,
         rawTargetKey: normalizeReferenceTargetKey(targetPath),
         resolvedPath,

package/src/server/domain/ripgrep-search-service.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { promisify } from 'node:util';
 
 import { getVaultFileKind } from '../../domain/file-kind.js';
+import { isWholeWordMatch } from '../../domain/literal-text-search.js';
 import { logPerfEvent } from '../config/perf-logging.js';
 
 const execFile = promisify(execFileCallback);
@@ -108,6 +109,7 @@ function createSnippet(lineText = '', matchStart = 0, matchEnd = matchStart) {
 function createRipgrepArgs(query, {
   maxFileSize = DEFAULT_MAX_FILE_SIZE,
   maxSnippetsPerFile = DEFAULT_MAX_SNIPPETS_PER_FILE,
+  wholeWord = false,
 } = {}) {
   const args = [
     '--json',
@@ -130,6 +132,7 @@ function createRipgrepArgs(query, {
     '--glob',
     '!.trash/**',
   ];
+  if (wholeWord) args.push('--word-regexp');
 
   TEXT_SEARCH_GLOBS.forEach((glob) => {
     args.push('--glob', glob);
@@ -140,10 +143,13 @@ function createRipgrepArgs(query, {
 }
 
 export function parseRipgrepJson(stdout, {
+  kinds = [],
   maxFiles = DEFAULT_MAX_FILES,
   maxSnippetsPerFile = DEFAULT_MAX_SNIPPETS_PER_FILE,
+  prefix = '',
   query = '',
 } = {}) {
+  const kindFilter = new Set(Array.isArray(kinds) ? kinds : []);
   const files = [];
   const filesByPath = new Map();
   let matchCount = 0;
@@ -167,7 +173,12 @@ export function parseRipgrepJson(stdout, {
     }
 
     const filePath = String(event?.data?.path?.text ?? '').replace(/^\.\//u, '');
-    if (!filePath) {
+    const kind = getVaultFileKind(filePath) ?? 'text';
+    if (
+      !filePath
+      || (prefix && filePath !== prefix && !filePath.startsWith(`${prefix}/`))
+      || (kindFilter.size > 0 && !kindFilter.has(kind))
+    ) {
       continue;
     }
 
@@ -180,7 +191,7 @@ export function parseRipgrepJson(stdout, {
 
       fileGroup = {
         file: filePath,
-        kind: getVaultFileKind(filePath) ?? 'text',
+        kind,
         matchCount: 0,
         snippets: [],
         truncated: false,
@@ -226,7 +237,21 @@ export function parseRipgrepJson(stdout, {
   };
 }
 
-async function searchExcalidrawText({ maxFileSize, maxFiles, maxSnippetsPerFile, query, signal, vaultDir }) {
+async function searchExcalidrawText({
+  kinds = [],
+  maxFileSize,
+  maxFiles,
+  maxSnippetsPerFile,
+  prefix = '',
+  query,
+  wholeWord = false,
+  signal,
+  vaultDir,
+}) {
+  const kindFilter = new Set(Array.isArray(kinds) ? kinds : []);
+  if (kindFilter.size > 0 && !kindFilter.has('excalidraw')) {
+    return { files: [], matchCount: 0, truncated: false };
+  }
   const files = [];
   let matchCount = 0;
   let truncated = false;
@@ -237,6 +262,8 @@ async function searchExcalidrawText({ maxFileSize, maxFiles, maxSnippetsPerFile,
   });
 
   for await (const filePath of paths) {
+    const normalizedPath = filePath.replaceAll('\\', '/');
+    if (prefix && normalizedPath !== prefix && !normalizedPath.startsWith(`${prefix}/`)) continue;
     signal?.throwIfAborted?.();
     const absolutePath = join(vaultDir, filePath);
     if ((await stat(absolutePath)).size > parseByteLimit(maxFileSize)) continue;
@@ -256,19 +283,21 @@ async function searchExcalidrawText({ maxFileSize, maxFiles, maxSnippetsPerFile,
       const normalizedText = text.toLocaleLowerCase();
       let matchStart = normalizedText.indexOf(normalizedQuery);
       while (matchStart >= 0) {
-        fileMatchCount += 1;
-        matchCount += 1;
-        if (snippets.length < maxSnippetsPerFile) {
-          const snippet = createSnippet(text, matchStart, matchStart + query.length);
-          snippets.push({
-            column: matchStart + 1,
-            line: 1,
-            matchEnd: snippet.matchEnd,
-            matchStart: snippet.matchStart,
-            text: snippet.text,
-          });
-        } else {
-          truncated = true;
+        if (!wholeWord || isWholeWordMatch(normalizedText, matchStart, matchStart + normalizedQuery.length)) {
+          fileMatchCount += 1;
+          matchCount += 1;
+          if (snippets.length < maxSnippetsPerFile) {
+            const snippet = createSnippet(text, matchStart, matchStart + query.length);
+            snippets.push({
+              column: matchStart + 1,
+              line: 1,
+              matchEnd: snippet.matchEnd,
+              matchStart: snippet.matchStart,
+              text: snippet.text,
+            });
+          } else {
+            truncated = true;
+          }
         }
         matchStart = normalizedText.indexOf(normalizedQuery, matchStart + Math.max(query.length, 1));
       }
@@ -280,7 +309,7 @@ async function searchExcalidrawText({ maxFileSize, maxFiles, maxSnippetsPerFile,
         continue;
       }
       files.push({
-        file: filePath.replaceAll('\\', '/'),
+        file: normalizedPath,
         kind: 'excalidraw',
         matchCount: fileMatchCount,
         snippets,
@@ -354,11 +383,19 @@ export class RipgrepSearchService {
   }
 
   async search({
+    kinds = [],
     limit = DEFAULT_MAX_FILES,
+    maxSnippetsPerFile = DEFAULT_MAX_SNIPPETS_PER_FILE,
+    prefix = '',
     query = '',
     signal = null,
+    wholeWord = false,
   } = {}) {
     const normalizedQuery = String(query ?? '').trim();
+    const snippetLimit = normalizePositiveInt(maxSnippetsPerFile, this.maxSnippetsPerFile, {
+      max: 10,
+      min: 1,
+    });
     const maxFiles = normalizePositiveInt(limit, this.maxFiles, {
       max: this.maxFiles,
       min: 1,
@@ -381,7 +418,8 @@ export class RipgrepSearchService {
     const startedAt = Date.now();
     const args = createRipgrepArgs(normalizedQuery, {
       maxFileSize: this.maxFileSize,
-      maxSnippetsPerFile: this.maxSnippetsPerFile,
+      maxSnippetsPerFile: snippetLimit,
+      wholeWord,
     });
     let parsed;
     try {
@@ -393,8 +431,10 @@ export class RipgrepSearchService {
         timeout: this.timeoutMs,
       });
       parsed = parseRipgrepJson(result.stdout, {
+        kinds,
         maxFiles,
-        maxSnippetsPerFile: this.maxSnippetsPerFile,
+        maxSnippetsPerFile: snippetLimit,
+        prefix,
         query: normalizedQuery,
       });
     } catch (error) {
@@ -406,8 +446,10 @@ export class RipgrepSearchService {
       } else {
         const isMaxBuffer = error?.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';
         parsed = parseRipgrepJson(error?.stdout ?? '', {
+          kinds,
           maxFiles,
-          maxSnippetsPerFile: this.maxSnippetsPerFile,
+          maxSnippetsPerFile: snippetLimit,
+          prefix,
           query: normalizedQuery,
         });
         if (isMaxBuffer && parsed.files.length > 0) {
@@ -421,16 +463,21 @@ export class RipgrepSearchService {
 
     if (parsed.files.length < maxFiles) {
       const excalidraw = await searchExcalidrawText({
+        kinds,
         maxFileSize: this.maxFileSize,
         maxFiles: maxFiles - parsed.files.length,
-        maxSnippetsPerFile: this.maxSnippetsPerFile,
+        maxSnippetsPerFile: snippetLimit,
+        prefix,
         query: normalizedQuery,
+        wholeWord,
         signal,
         vaultDir: this.vaultDir,
       });
       parsed.files.push(...excalidraw.files);
       parsed.matchCount += excalidraw.matchCount;
       parsed.truncated ||= excalidraw.truncated;
+    } else if (kinds.length === 0 || kinds.includes('excalidraw')) {
+      parsed.truncated = true;
     }
     parsed.search = this.getClientConfig();
     logPerfEvent(this.perfLoggingEnabled, 'search-query', {

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

@@ -146,9 +146,18 @@ export class GitService {
     };
   }
 
+  async stageAll() {
+    await this.commandRunner.execGit(['add', '-A', '--']);
+    this.invalidateStatusCache();
+    return {
+      ok: true,
+      workspaceChange: createEmptyWorkspaceChange(),
+    };
+  }
+
   async unstageFile(path) {
     const normalizedPath = normalizeRelativeGitPath(path);
-    await this.commandRunner.execGit(['reset', 'HEAD', '--', normalizedPath]);
+    await this.commandRunner.execGit(['reset', '--', normalizedPath]);
     this.invalidateStatusCache();
     return {
       ok: true,
@@ -157,6 +166,15 @@ export class GitService {
     };
   }
 
+  async unstageAll() {
+    await this.commandRunner.execGit(['reset', '--']);
+    this.invalidateStatusCache();
+    return {
+      ok: true,
+      workspaceChange: createEmptyWorkspaceChange(),
+    };
+  }
+
   async commitStaged({ author = null, message } = {}) {
     const normalizedMessage = String(message ?? '').trim();
     if (!normalizedMessage) {

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

@@ -233,7 +233,7 @@ export class GitHistoryService {
         '-n',
         String(normalizedLimit + 1),
         '--follow',
-        '--find-renames=20%',
+        '--find-renames',
         '--date=iso-strict',
         '--format=%x1e%H%x1f%h%x1f%s%x1f%an%x1f%ae%x1f%aI%x1f%P',
         '--',

package/src/server/infrastructure/git/local-exclude.js

@@ -0,0 +1,37 @@
+import { execFile as execFileCallback } from 'node:child_process';
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFile = promisify(execFileCallback);
+
+export async function ensureCollabMetadataGitExclude(vaultDir) {
+  let excludePath = resolve(vaultDir, '.git/info/exclude');
+  try {
+    const { stdout } = await execFile('git', ['rev-parse', '--git-path', 'info/exclude'], {
+      cwd: vaultDir,
+    });
+    excludePath = resolve(vaultDir, String(stdout).trim());
+  } catch {
+    // Preserve support for repositories represented by a local .git directory.
+  }
+  let existingContent = '';
+
+  try {
+    existingContent = await readFile(excludePath, 'utf8');
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  const lines = existingContent
+    .split(/\r?\n/u)
+    .map((line) => line.trim());
+  if (lines.includes('.collabmd') || lines.includes('.collabmd/')) {
+    return;
+  }
+
+  const prefix = existingContent && !existingContent.endsWith('\n') ? '\n' : '';
+  await writeFile(excludePath, `${existingContent}${prefix}.collabmd/\n`, 'utf8');
+}