collabmd 0.1.49 → 0.1.52

package/src/domain/excalidraw-agent-scene.js

@@ -14,6 +14,18 @@ const ELEMENT_TYPES = new Set([
 ]);
 
 const LINEAR_TYPES = new Set(['arrow', 'freedraw', 'line']);
+// Matches Excalidraw's DEFAULT_FONT_FAMILY (Excalifont).
+const DEFAULT_TEXT_FONT_FAMILY = 5;
+const TEXT_LAYOUT_CONTAINER_TYPES = new Set(['diamond', 'ellipse', 'rectangle']);
+const TEXT_METRIC_FIELDS = new Set([
+  'autoResize',
+  'containerId',
+  'fontFamily',
+  'fontSize',
+  'lineHeight',
+  'text',
+]);
+const TEXT_GEOMETRY_FIELDS = new Set(['height', 'width', 'x', 'y']);
 
 function invalid(message) {
   const error = new Error(message);
@@ -186,7 +198,7 @@ function addFreeDrawElementFields(element, raw) {
 function addTextElementFields(element, raw, { fontSize, text }) {
   element.autoResize = raw.autoResize ?? true;
   element.containerId = raw.containerId ?? null;
-  element.fontFamily = raw.fontFamily ?? 1;
+  element.fontFamily = raw.fontFamily ?? DEFAULT_TEXT_FONT_FAMILY;
   element.fontSize = fontSize;
   element.lineHeight = raw.lineHeight ?? 1.25;
   element.originalText = raw.originalText ?? text;
@@ -341,6 +353,66 @@ function resolveTranslationIds(elements, requestedIds) {
   return [...resolved];
 }
 
+function textHeight(element) {
+  const text = String(element.text ?? '');
+  const lineCount = Math.max(1, text.split('\n').length);
+  const fontSize = requireNumber(element.fontSize ?? 20, `Element ${element.id} fontSize`);
+  const lineHeight = requireNumber(element.lineHeight ?? 1.25, `Element ${element.id} lineHeight`);
+  return lineCount * fontSize * lineHeight;
+}
+
+function sameNumber(left, right) {
+  return Math.abs(left - right) < 0.001;
+}
+
+function reflowBoundText(elements, ids, now, alreadyVersionedIds) {
+  const activeById = new Map(
+    elements.filter((element) => !element.isDeleted).map((element) => [element.id, element]),
+  );
+  let reflowed = 0;
+
+  ids.forEach((id) => {
+    const text = activeById.get(id);
+    if (text?.type !== 'text' || !text.containerId) return;
+
+    const container = activeById.get(text.containerId);
+    if (
+      !container
+      || !TEXT_LAYOUT_CONTAINER_TYPES.has(container.type)
+      || Number(container.angle ?? 0) !== 0
+    ) {
+      return;
+    }
+
+    const width = requireNumber(text.width, `Element ${id} width`);
+    const height = textHeight(text);
+    const x = requireNumber(container.x, `Element ${text.containerId} x`)
+      + ((requireNumber(container.width, `Element ${text.containerId} width`) - width) / 2);
+    const y = requireNumber(container.y, `Element ${text.containerId} y`)
+      + ((requireNumber(container.height, `Element ${text.containerId} height`) - height) / 2);
+
+    if (
+      sameNumber(text.x, x)
+      && sameNumber(text.y, y)
+      && sameNumber(text.height, height)
+    ) {
+      return;
+    }
+
+    const positioned = { ...text, height, x, y };
+    const next = alreadyVersionedIds.has(id)
+      ? positioned
+      : bumpElementVersion(positioned, now, 'bound-text-layout');
+    const elementIndex = elements.indexOf(text);
+    elements[elementIndex] = next;
+    activeById.set(id, next);
+    alreadyVersionedIds.add(id);
+    reflowed += 1;
+  });
+
+  return reflowed;
+}
+
 export function createAgentExcalidrawScene(rawElements) {
   if (!Array.isArray(rawElements) || rawElements.length < 1 || rawElements.length > 200) {
     throw invalid('Excalidraw scene must contain 1 to 200 elements');
@@ -372,6 +444,10 @@ export function createAgentExcalidrawScene(rawElements) {
 }
 
 export function applyAgentExcalidrawEdits(scene, edits = {}) {
+  return applyAgentExcalidrawEditsWithSummary(scene, edits).scene;
+}
+
+export function applyAgentExcalidrawEditsWithSummary(scene, edits = {}) {
   requireObject(scene, 'Excalidraw scene');
   if (scene.type !== 'excalidraw' || !Array.isArray(scene.elements)) {
     throw invalid('Document is not a valid Excalidraw scene');
@@ -383,10 +459,14 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
   const remove = edits.delete ?? [];
   const reorder = edits.reorder ?? [];
   const translate = edits.translate ?? null;
+  const normalizeTextPlacement = edits.normalizeTextPlacement;
   const operations = [create, update, replace, remove, reorder];
   if (!operations.every(Array.isArray)) {
     throw invalid('Excalidraw edit operations must be arrays');
   }
+  if (normalizeTextPlacement !== undefined && normalizeTextPlacement !== true) {
+    throw invalid('normalizeTextPlacement must be true when provided');
+  }
   let translatedIds = [];
   let translateDx = 0;
   let translateDy = 0;
@@ -405,7 +485,11 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
       throw invalid('Translate operation must move elements');
     }
   }
-  const operationCount = operations.reduce((count, entries) => count + entries.length, translatedIds.length);
+  const normalizationOperationCount = normalizeTextPlacement ? 1 : 0;
+  const operationCount = operations.reduce(
+    (count, entries) => count + entries.length,
+    translatedIds.length + normalizationOperationCount,
+  );
   if (operationCount < 1) {
     throw invalid('Excalidraw edits must include at least one operation');
   }
@@ -417,6 +501,7 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
   let elements = scene.elements.map((element) => ({ ...element }));
   const byId = new Map(elements.map((element) => [element.id, element]));
   const alreadyVersionedIds = new Set();
+  const autoReflowIds = new Set();
   const createdElements = create.map((raw) => {
     const element = normalizeElement(raw, now);
     if (byId.has(element.id)) throw invalid(`Excalidraw element already exists: ${element.id}`);
@@ -447,8 +532,7 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
     const resizesStandaloneText = current.type === 'text'
       && !raw.containerId
       && raw.autoResize !== false
-      && ['autoResize', 'fontFamily', 'fontSize', 'lineHeight', 'text']
-        .some((field) => Object.hasOwn(set, field));
+      && [...TEXT_METRIC_FIELDS].some((field) => Object.hasOwn(set, field));
     if (resizesStandaloneText) {
       delete raw.width;
       delete raw.height;
@@ -457,6 +541,12 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
     elements[elements.indexOf(current)] = next;
     byId.set(id, next);
     alreadyVersionedIds.add(id);
+    const changesTextMetrics = current.type === 'text'
+      && [...TEXT_METRIC_FIELDS].some((field) => Object.hasOwn(set, field));
+    const changesTextGeometry = [...TEXT_GEOMETRY_FIELDS].some((field) => Object.hasOwn(set, field));
+    if (changesTextMetrics && !changesTextGeometry) {
+      autoReflowIds.add(id);
+    }
   });
   replace.forEach((operation) => {
     requireObject(operation, 'Replace operation');
@@ -481,7 +571,10 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
   });
   if (translatedIds.length > 0) {
     translatedIds = resolveTranslationIds(elements, translatedIds);
-    const expandedOperationCount = operations.reduce((count, entries) => count + entries.length, translatedIds.length);
+    const expandedOperationCount = operations.reduce(
+      (count, entries) => count + entries.length,
+      translatedIds.length + normalizationOperationCount,
+    );
     if (expandedOperationCount > 200) {
       throw invalid('Excalidraw edits cannot exceed 200 operations including related translations');
     }
@@ -515,8 +608,17 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
     const id = String(operation.id ?? '').trim();
     moveElement(elements, id, operation, `Reorder ${id}`);
   });
+  const reflowIds = normalizeTextPlacement
+    ? elements
+      .filter((element) => element.type === 'text' && !element.isDeleted && element.containerId)
+      .map((element) => element.id)
+    : [...autoReflowIds];
+  const reflowed = reflowBoundText(elements, reflowIds, now, alreadyVersionedIds);
   validateUniqueIds(elements);
   elements = normalizeElementOrder(elements, now, alreadyVersionedIds);
   refreshArrowBindings(elements);
-  return { ...scene, elements };
+  return {
+    reflowed,
+    scene: { ...scene, elements },
+  };
 }

package/src/domain/excalidraw-agent-verification.js

@@ -5,6 +5,19 @@ const RENDERED_TYPES = new Set([...BASIC_SHAPE_TYPES, ...LINEAR_TYPES, 'text']);
 const MAX_SUMMARY_ELEMENTS = 500;
 const MAX_WARNINGS = 200;
 const MAX_RENDER_DIMENSION = 4096;
+const BOUND_TEXT_CENTER_TOLERANCE = 2;
+
+const FONT_FAMILY_NAMES = new Map([
+  [1, 'Virgil'],
+  [2, 'Helvetica'],
+  [3, 'Cascadia'],
+  [5, 'Excalifont'],
+  [6, 'Nunito'],
+  [7, 'Lilita One'],
+  [8, 'Comic Shanns'],
+  [9, 'Liberation Sans'],
+  [10, 'Assistant'],
+]);
 
 function finiteNumber(value, fallback = 0) {
   const number = Number(value);
@@ -182,6 +195,9 @@ function summarizeElement(element, paintOrder, activeElements) {
   if (elementBehind?.id) summary.inFrontOf = String(elementBehind.id);
   if (element?.type === 'text') summary.text = String(element.text ?? '');
   if (element?.type === 'text') {
+    const fontFamily = finiteNumber(element.fontFamily, 5);
+    summary.fontFamily = fontFamily;
+    summary.fontName = FONT_FAMILY_NAMES.get(fontFamily) ?? `Unknown (${fontFamily})`;
     summary.fontSize = finiteNumber(element.fontSize, 20);
     summary.lineHeight = finiteNumber(element.lineHeight, 1.25);
     if (element.containerId) summary.containerId = String(element.containerId);
@@ -209,6 +225,78 @@ function textOverflowWarning(element, bounds, id) {
     : null;
 }
 
+function expectedTextHeight(element) {
+  const lines = String(element?.text ?? '').split('\n');
+  return Math.max(1, lines.length)
+    * finiteNumber(element?.fontSize, 20)
+    * finiteNumber(element?.lineHeight, 1.25);
+}
+
+function collectBoundTextLayout(elements) {
+  const activeById = new Map(elements.map((element) => [String(element.id), element]));
+  const layout = {
+    boundText: {
+      misaligned: 0,
+      outsideContainer: 0,
+      staleHeight: 0,
+      total: 0,
+    },
+  };
+  const warnings = [];
+
+  elements.forEach((element) => {
+    if (element?.type !== 'text' || !element.containerId) return;
+    const container = activeById.get(String(element.containerId));
+    if (!container || !BASIC_SHAPE_TYPES.has(container.type) || finiteNumber(container.angle) !== 0) {
+      return;
+    }
+    const textBounds = elementBounds(element);
+    const containerBounds = elementBounds(container);
+    if (!textBounds || !containerBounds) return;
+
+    const id = String(element.id ?? '');
+    const containerId = String(container.id ?? '');
+    const textCenterX = textBounds.x + (textBounds.width / 2);
+    const textCenterY = textBounds.y + (textBounds.height / 2);
+    const containerCenterX = containerBounds.x + (containerBounds.width / 2);
+    const containerCenterY = containerBounds.y + (containerBounds.height / 2);
+    const offsetX = textCenterX - containerCenterX;
+    const offsetY = textCenterY - containerCenterY;
+    const centered = Math.abs(offsetX) <= BOUND_TEXT_CENTER_TOLERANCE
+      && Math.abs(offsetY) <= BOUND_TEXT_CENTER_TOLERANCE;
+
+    layout.boundText.total += 1;
+    if (!centered) {
+      layout.boundText.misaligned += 1;
+      warnings.push(warning(
+        'bound-text-not-centered',
+        `Bound text ${id} is offset ${Math.round(offsetX)} horizontally and ${Math.round(offsetY)} vertically from container ${containerId}.`,
+        [id, containerId],
+      ));
+    }
+
+    if (!boxContains(containerBounds, textBounds)) {
+      layout.boundText.outsideContainer += 1;
+      warnings.push(warning(
+        'bound-text-outside-container',
+        `Bound text ${id} extends outside container ${containerId}.`,
+        [id, containerId],
+      ));
+    }
+
+    if (Math.abs(textBounds.height - expectedTextHeight(element)) > BOUND_TEXT_CENTER_TOLERANCE) {
+      layout.boundText.staleHeight += 1;
+      warnings.push(warning(
+        'bound-text-height-stale',
+        `Bound text ${id} has height ${Math.round(textBounds.height)} but its current text metrics require ${Math.round(expectedTextHeight(element))}.`,
+        [id, containerId],
+      ));
+    }
+  });
+
+  return { layout, warnings };
+}
+
 function boundEndpointWarning(element, binding, endpointName, activeById) {
   if (!binding?.elementId || !LINEAR_TYPES.has(element?.type) || !Array.isArray(element.points)) {
     return null;
@@ -336,7 +424,11 @@ export function inspectAgentExcalidrawScene(scene = {}, {
   const activeElements = (Array.isArray(scene?.elements) ? scene.elements : [])
     .filter((element) => element && !element.isDeleted);
   const boxes = activeElements.map(elementBounds).filter(Boolean);
-  const warnings = collectWarnings(activeElements, { inspectOcclusion });
+  const boundTextLayout = collectBoundTextLayout(activeElements);
+  const warnings = [
+    ...collectWarnings(activeElements, { inspectOcclusion }),
+    ...boundTextLayout.warnings,
+  ].slice(0, MAX_WARNINGS);
   return {
     bounds: mergeBounds(boxes),
     elementCount: activeElements.length,
@@ -348,6 +440,8 @@ export function inspectAgentExcalidrawScene(scene = {}, {
     truncated: (!includeElements && activeElements.length > 0)
       || activeElements.length > MAX_SUMMARY_ELEMENTS
       || warnings.length >= MAX_WARNINGS,
+    layout: boundTextLayout.layout,
+    valid: warnings.length === 0,
     warnings,
   };
 }

package/src/domain/excalidraw-room-codec.js

@@ -11,6 +11,7 @@ export const EXCALIDRAW_META_KEY = 'excalidraw-meta';
 export const EXCALIDRAW_ROOM_SCHEMA_VERSION = 1;
 export const EXCALIDRAW_ROOM_TEXT_KEY = 'codemirror';
 export const EXCALIDRAW_SCHEMA_VERSION_KEY = 'schemaVersion';
+export const EXCALIDRAW_REPLACE_GENERATION_KEY = 'replaceGeneration';
 
 function createEmptyScene() {
   return {
@@ -222,6 +223,15 @@ export function isExcalidrawRoomDocStructured(ydoc) {
   return Number(meta.get(EXCALIDRAW_SCHEMA_VERSION_KEY)) === EXCALIDRAW_ROOM_SCHEMA_VERSION;
 }
 
+export function readExcalidrawReplaceGeneration(ydoc) {
+  if (!ydoc) {
+    return 0;
+  }
+
+  const value = Number(ydoc.getMap(EXCALIDRAW_META_KEY).get(EXCALIDRAW_REPLACE_GENERATION_KEY));
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+
 export function ensureExcalidrawRoomSchema(ydoc) {
   const meta = ydoc.getMap(EXCALIDRAW_META_KEY);
   if (Number(meta.get(EXCALIDRAW_SCHEMA_VERSION_KEY)) !== EXCALIDRAW_ROOM_SCHEMA_VERSION) {
@@ -295,7 +305,7 @@ export function replaceExcalidrawRoomScene(ydoc, rawScene, {
   }
 
   const scene = normalizeScene(rawScene);
-  ensureExcalidrawRoomSchema(ydoc);
+  const meta = ensureExcalidrawRoomSchema(ydoc);
 
   const elementsMap = ydoc.getMap(EXCALIDRAW_ELEMENTS_KEY);
   const filesMap = ydoc.getMap(EXCALIDRAW_FILES_KEY);
@@ -321,6 +331,7 @@ export function replaceExcalidrawRoomScene(ydoc, rawScene, {
   const nextAppState = normalizeAppState(scene.appState);
   appStateMap.set('gridSize', nextAppState.gridSize);
   appStateMap.set('viewBackgroundColor', nextAppState.viewBackgroundColor);
+  meta.set(EXCALIDRAW_REPLACE_GENERATION_KEY, readExcalidrawReplaceGeneration(ydoc) + 1);
 
   return scene;
 }

package/src/domain/literal-text-search.js

@@ -0,0 +1,13 @@
+const WORD_CHARACTER = /[\p{L}\p{N}_]/u;
+
+function isWordCharacterAt(value, index) {
+  if (index < 0 || index >= value.length) return false;
+  let start = index;
+  const codeUnit = value.charCodeAt(index);
+  if (index > 0 && codeUnit >= 0xDC00 && codeUnit <= 0xDFFF) start -= 1;
+  return WORD_CHARACTER.test(String.fromCodePoint(value.codePointAt(start)));
+}
+
+export function isWholeWordMatch(value, start, end) {
+  return !isWordCharacterAt(value, start - 1) && !isWordCharacterAt(value, end);
+}

package/src/domain/markdown-outline.js

@@ -0,0 +1,35 @@
+import { extractYamlFrontmatter } from './yaml-frontmatter.js';
+
+// ponytail: top-level ATX and single-line Setext headings only; use a shared full parser if nested outlines are needed.
+export function collectMarkdownOutline(content) {
+  const lines = (extractYamlFrontmatter(content)?.bodyMarkdown ?? content).split(/\r?\n/u);
+  const headings = [];
+  let fence = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const marker = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/u);
+    if (fence) {
+      if (marker && marker[1][0] === fence[0] && marker[1].length >= fence.length && !marker[2].trim()) {
+        fence = null;
+      }
+      continue;
+    }
+    if (marker && (marker[1][0] !== '`' || !marker[2].includes('`'))) {
+      fence = marker[1];
+      continue;
+    }
+    const atx = line.match(/^ {0,3}(#{1,6})(?:[\t ]+(.*)|$)/u);
+    const setext = !atx && /^ {0,3}\S/u.test(line) && !/^ {0,3}(?:>|[-+*]\s|\d+[.)]\s)/u.test(line)
+      && lines[index + 1]?.match(/^ {0,3}(=+|-+)[\t ]*$/u);
+    if (!atx && !setext) continue;
+    const text = atx ? (atx[2] ?? '').replace(/(?:^|[\t ]+)#+[\t ]*$/u, '').trim() : line.trim();
+    headings.push({
+      level: atx ? atx[1].length : setext[1][0] === '=' ? 1 : 2,
+      line: index + 1,
+      text: text.slice(0, 200),
+      truncated: text.length > 200,
+    });
+    if (setext) index += 1;
+  }
+  return headings;
+}

package/src/server/application/agent-connection-service.js

@@ -158,12 +158,16 @@ export class AgentConnectionService {
       throw createAccessError('AGENT_TOKEN_INVALID', 'Agent Connection token is invalid or expired', 401);
     }
 
+    if (this.hostedWorkspaceService?.enabled && connection.subjectType !== 'hosted_membership') {
+      throw createAccessError('AGENT_MEMBERSHIP_REQUIRED', 'Create a new Agent Connection for this Team Membership', 403);
+    }
+
     let collaborator = connection.subjectEmail
       ? { email: connection.subjectEmail, name: connection.subjectEmail }
       : null;
     if (connection.subjectType === 'hosted_membership') {
-      const access = await this.hostedWorkspaceService.authorizeWorkspaceAccess({ user: collaborator });
-      if (!access.ok || access.membership.id !== connection.subjectId) {
+      const access = await this.hostedWorkspaceService?.authorizeWorkspaceAccess({ user: collaborator });
+      if (!access?.ok || access.membership?.id !== connection.subjectId) {
         throw createAccessError('AGENT_MEMBERSHIP_REQUIRED', 'Team Membership is no longer active', 403);
       }
       collaborator = access.membership;