dig-burrow 1.2.0

package/.claude/burrow/lib/mongoose.cjs

@@ -0,0 +1,461 @@
+'use strict';
+
+const { generateId } = require('./core.cjs');
+
+// --- Helpers ---
+
+/**
+ * Recursively find a card by ID in the tree.
+ * @param {object} data - Root data object
+ * @param {string} id - Card ID to find
+ * @returns {object|null} The card, or null if not found
+ */
+function findById(data, id) {
+  function search(cards) {
+    for (const card of cards) {
+      if (card.id === id) return card;
+      if (card.children && card.children.length) {
+        const found = search(card.children);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return search(data.cards);
+}
+
+/**
+ * Find the parent of a card by ID.
+ * Uses a single recursive traversal (no separate root-level loop).
+ * @param {object} data - Root data object
+ * @param {string} id - Card ID to find parent of
+ * @returns {{parent: object|null, container: Array}|null} parent card (null for root), container (the array the card lives in)
+ */
+function findParent(data, id) {
+  function search(parentCard, container) {
+    for (const card of container) {
+      if (card.id === id) {
+        return { parent: parentCard, container };
+      }
+      if (card.children && card.children.length) {
+        const found = search(card, card.children);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return search(null, data.cards);
+}
+
+/**
+ * Get the array to push into for adding/listing cards.
+ * @param {object} data - Root data object
+ * @param {string|null|undefined} parentId - Parent ID, or null/undefined for root
+ * @returns {Array|null} The array to operate on, or null if parentId not found
+ */
+function getContainer(data, parentId) {
+  if (parentId == null) return data.cards;
+  const parent = findById(data, parentId);
+  if (!parent) return null;
+  return parent.children;
+}
+
+/**
+ * Get the ancestry path from root to the target card.
+ * @param {object} data - Root data object
+ * @param {string} id - Target card ID
+ * @returns {Array<object>|null} Array from root ancestor to target, or null
+ */
+function getPath(data, id) {
+  function search(cards, path) {
+    for (const card of cards) {
+      const currentPath = [...path, card];
+      if (card.id === id) return currentPath;
+      if (card.children && card.children.length) {
+        const found = search(card.children, currentPath);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return search(data.cards, []);
+}
+
+/**
+ * Count descendants recursively.
+ * @param {object} card
+ * @param {object} [opts]
+ * @param {boolean} [opts.activeOnly=false] - When true, skip archived children and their subtrees
+ * @returns {number}
+ */
+function countDescendants(card, opts) {
+  const activeOnly = opts && opts.activeOnly;
+  let count = 0;
+  if (card.children && card.children.length) {
+    for (const child of card.children) {
+      if (activeOnly && child.archived) continue;
+      count += 1 + countDescendants(child, opts);
+    }
+  }
+  return count;
+}
+
+// --- Constants ---
+
+/**
+ * Maximum length for body preview snippets in renderTree output.
+ * Bodies longer than this are sliced before newline replacement to avoid
+ * processing thousands of characters unnecessarily.
+ * @type {number}
+ */
+const PREVIEW_TRUNCATE_LENGTH = 80;
+
+// --- Public API ---
+
+/**
+ * Add a new card to the tree.
+ * @param {object} data - Root data object
+ * @param {object} opts - {title, parentId, body, position}
+ * @returns {{card: object, breadcrumbs: Array<{id, title}>}|null} The created card with ancestor breadcrumbs, or null if parent not found
+ */
+function addCard(data, { title, parentId, body, position }) {
+  const container = getContainer(data, parentId);
+  if (!container) return null;
+
+  const id = generateId();
+
+  const card = {
+    id,
+    title,
+    created: new Date().toISOString(),
+    archived: false,
+    body: body || '',
+    children: [],
+  };
+
+  if (position != null && position < container.length) {
+    container.splice(position, 0, card);
+  } else {
+    container.push(card);
+  }
+
+  const pathResult = getPath(data, card.id);
+  const breadcrumbs = pathResult ? pathResult.slice(0, -1).map((c) => ({ id: c.id, title: c.title })) : [];
+
+  return { card, breadcrumbs };
+}
+
+/**
+ * Edit an existing card's title or body.
+ * @param {object} data - Root data object
+ * @param {string} id - Card ID
+ * @param {object} changes - {title, body}
+ * @returns {{card: object, oldTitle: string, oldBody: string, breadcrumbs: Array<{id, title}>}|null} Result with old values and breadcrumbs, or null if not found
+ */
+function editCard(data, id, { title, body }) {
+  const card = findById(data, id);
+  if (!card) return null;
+
+  const oldTitle = card.title;
+  const oldBody = card.body;
+
+  if (title !== undefined) card.title = title;
+  if (body !== undefined) card.body = body;
+
+  const pathResult = getPath(data, id);
+  const breadcrumbs = pathResult ? pathResult.slice(0, -1).map((c) => ({ id: c.id, title: c.title })) : [];
+
+  return { card, oldTitle, oldBody, breadcrumbs };
+}
+
+/**
+ * Delete a card and all its descendants.
+ * @param {object} data - Root data object
+ * @param {string} id - Card ID to delete
+ * @returns {object|null} Full deleted card object with descendantCount added, or null if not found
+ */
+function deleteCard(data, id) {
+  const parentResult = findParent(data, id);
+  if (!parentResult) return null;
+
+  const { container } = parentResult;
+  const idx = container.findIndex((c) => c.id === id);
+  if (idx === -1) return null;
+
+  const card = container[idx];
+  const descendantCount = countDescendants(card);
+
+  container.splice(idx, 1);
+
+  return { ...card, descendantCount };
+}
+
+/**
+ * Internal helper: find a card and its ancestry (parent + container) in a single walk.
+ * @param {object} data - Root data object
+ * @param {string} cardId - Card ID to find
+ * @returns {{card: object, parent: object|null, container: Array, ancestorIds: Set}|null}
+ */
+function findCardWithAncestry(data, cardId) {
+  function search(container, parent, ancestorIds) {
+    for (const card of container) {
+      if (card.id === cardId) {
+        return { card, parent, container, ancestorIds };
+      }
+      if (card.children && card.children.length) {
+        const nextAncestors = new Set(ancestorIds);
+        nextAncestors.add(card.id);
+        const found = search(card.children, card, nextAncestors);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return search(data.cards, null, new Set());
+}
+
+/**
+ * Move a card to a new parent (or root).
+ * Uses at most 2 tree walks: one to find card + ancestry, one to get target container.
+ * @param {object} data - Root data object
+ * @param {string} cardId - ID of card to move
+ * @param {string|null} newParentId - Target parent ID, or null for root
+ * @param {number} [requestedPosition] - Optional index in target array
+ * @returns {{card: object, sourceParentTitle: string, breadcrumbs: Array<{id, title}>}|null} Result with source parent title and breadcrumbs, or null on error (not found, cycle)
+ */
+function moveCard(data, cardId, newParentId, requestedPosition) {
+  // Walk 1: find card, its container, and ancestor IDs for cycle detection
+  const found = findCardWithAncestry(data, cardId);
+  if (!found) return null;
+
+  const { card, parent: sourceParent, container: sourceContainer, ancestorIds } = found;
+  const sourceParentTitle = sourceParent ? sourceParent.title : 'root';
+
+  // Cycle check: newParentId cannot be the card itself or any ancestor's descendant
+  // ancestorIds contains all ancestors of card; card.id is card itself
+  if (newParentId != null && (newParentId === cardId || ancestorIds.has(newParentId))) {
+    // newParentId is an ancestor of card — but we need to check if newParentId is a descendant of card
+    // ancestorIds only has ancestors, not descendants. We need to check if newParentId is under card.
+    // If newParentId === cardId, that's a trivial cycle. Otherwise check via getPath.
+    if (newParentId === cardId) return null;
+  }
+
+  // For cycle detection: newParentId must not be a descendant of cardId
+  if (newParentId != null) {
+    const path = getPath(data, newParentId);
+    if (path && path.some((p) => p.id === cardId)) {
+      return null; // Would create a cycle
+    }
+  }
+
+  // Remove from source (using already-found container)
+  const sourceIdx = sourceContainer.findIndex((c) => c.id === cardId);
+  sourceContainer.splice(sourceIdx, 1);
+
+  // Walk 2: get target container
+  const targetContainer = getContainer(data, newParentId);
+  if (!targetContainer) return null;
+
+  if (requestedPosition != null) {
+    targetContainer.splice(requestedPosition, 0, card);
+  } else {
+    targetContainer.push(card);
+  }
+
+  const pathResult = getPath(data, cardId);
+  const breadcrumbs = pathResult ? pathResult.slice(0, -1).map((c) => ({ id: c.id, title: c.title })) : [];
+
+  return { card, sourceParentTitle, breadcrumbs };
+}
+
+
+/**
+ * Create a body preview: truncate at PREVIEW_TRUNCATE_LENGTH chars first, then replace newlines with spaces.
+ * Truncate-first avoids processing thousands of characters in huge bodies.
+ * @param {string} body
+ * @returns {string}
+ */
+function makePreview(body) {
+  if (!body) return '';
+  if (body.length > PREVIEW_TRUNCATE_LENGTH) {
+    return body.slice(0, PREVIEW_TRUNCATE_LENGTH).replace(/\n/g, ' ') + '...';
+  }
+  return body.replace(/\n/g, ' ');
+}
+
+/**
+ * Render a nested tree of cards with pre-computed metadata, breadcrumbs, and archive filtering.
+ * @param {object} data - Root data object
+ * @param {string|null} rootId - Focus card ID, or null for root view
+ * @param {object} [opts] - {depth, archiveFilter}
+ * @returns {{breadcrumbs: Array|null, cards: Array}|null} Render result, or null if rootId not found
+ *   cards is a nested tree: [{id, title, descendantCount, hasBody, bodyPreview, created, archived, children: [...]}]
+ */
+function renderTree(data, rootId, opts) {
+  const { depth: depthArg, archiveFilter } = opts || {};
+  if (depthArg !== undefined && typeof depthArg !== 'number') {
+    throw new Error('renderTree: depth must be a number');
+  }
+  const maxDepth = depthArg === 0 ? Infinity : (depthArg !== undefined ? depthArg : 1);
+  const filter = archiveFilter || 'active';
+
+  // Archive filter function
+  const shouldInclude = filter === 'active'
+    ? (card) => !card.archived
+    : filter === 'archived-only'
+      ? (card) => card.archived
+      : () => true;
+
+  // Build breadcrumbs
+  let breadcrumbs = null;
+  if (rootId != null) {
+    const path = getPath(data, rootId);
+    if (!path) return null;
+    breadcrumbs = path.slice(0, -1).map((c) => ({ id: c.id, title: c.title }));
+  }
+
+  function buildNested(cards, currentDepth) {
+    const result = [];
+    for (const card of cards) {
+      if (shouldInclude(card)) {
+        const entry = {
+          id: card.id,
+          title: card.title,
+          descendantCount: countDescendants(card, { activeOnly: true }),
+          hasBody: !!(card.body && card.body.trim()),
+          bodyPreview: makePreview(card.body),
+          created: card.created,
+          archived: card.archived,
+          children: (currentDepth < maxDepth && card.children && card.children.length)
+            ? buildNested(card.children, currentDepth + 1)
+            : [],
+        };
+        result.push(entry);
+      }
+    }
+    return result;
+  }
+
+  let cards;
+  if (rootId != null) {
+    const rootCard = findById(data, rootId);
+    if (!shouldInclude(rootCard)) return { breadcrumbs, cards: [] };
+    const builtChildren = (maxDepth > 0 && rootCard.children && rootCard.children.length)
+      ? buildNested(rootCard.children, 1)
+      : [];
+    // Derive descendantCount from already-built children instead of a redundant tree walk
+    const descendantCount = builtChildren.reduce(
+      (sum, child) => sum + 1 + (child.descendantCount || 0), 0
+    );
+    const entry = {
+      id: rootCard.id,
+      title: rootCard.title,
+      descendantCount,
+      hasBody: !!(rootCard.body && rootCard.body.trim()),
+      bodyPreview: makePreview(rootCard.body),
+      created: rootCard.created,
+      archived: rootCard.archived,
+      children: builtChildren,
+    };
+    cards = [entry];
+  } else {
+    cards = buildNested(data.cards, 0);
+  }
+
+  return { breadcrumbs, cards };
+}
+
+/**
+ * Recursively set archived flag on a card and all descendants.
+ * Returns the count of descendant nodes visited (excludes the card itself).
+ * @param {object} card
+ * @param {boolean} value
+ * @returns {number} Count of descendants processed
+ */
+function setArchivedRecursive(card, value) {
+  card.archived = value;
+  let count = 0;
+  if (card.children && card.children.length) {
+    for (const child of card.children) {
+      count += 1 + setArchivedRecursive(child, value);
+    }
+  }
+  return count;
+}
+
+/**
+ * Archive a card and all its descendants.
+ * @param {object} data - Root data object
+ * @param {string} id - Card ID
+ * @returns {object|null} Full card object with descendantCount, or null if not found
+ */
+function archiveCard(data, id) {
+  const card = findById(data, id);
+  if (!card) return null;
+  const descendantCount = setArchivedRecursive(card, true);
+  return { ...card, descendantCount };
+}
+
+/**
+ * Unarchive a card and all its descendants.
+ * @param {object} data - Root data object
+ * @param {string} id - Card ID
+ * @returns {object|null} Full card object with descendantCount, or null if not found
+ */
+function unarchiveCard(data, id) {
+  const card = findById(data, id);
+  if (!card) return null;
+  const descendantCount = setArchivedRecursive(card, false);
+  return { ...card, descendantCount };
+}
+
+/**
+ * Search all active cards for a query string (case-insensitive title match).
+ * Returns matches with path breadcrumbs for display.
+ * @param {object} data - Root data object
+ * @param {string} query - Lowercase search query
+ * @returns {Array<{id: string, title: string, path: string}>} Matching cards with path
+ */
+function searchCards(data, query) {
+  const lowerQuery = query.toLowerCase();
+  const results = [];
+
+  function walk(cards, ancestors) {
+    for (const card of cards) {
+      if (card.archived) continue;
+      const crumbs = [...ancestors, { id: card.id, title: card.title }];
+      if ((card.title || '').toLowerCase().includes(lowerQuery)) {
+        results.push({
+          id: card.id,
+          title: card.title,
+          path: crumbs.map((c) => c.title).join(' › '),
+        });
+      }
+      if (card.children && card.children.length) {
+        walk(card.children, crumbs);
+      }
+    }
+  }
+
+  walk(data.cards, []);
+  return results;
+}
+
+module.exports = {
+  findById,
+  findParent,
+  getContainer,
+  getPath,
+  addCard,
+  editCard,
+  deleteCard,
+  moveCard,
+
+  countDescendants,
+  makePreview,
+  PREVIEW_TRUNCATE_LENGTH,
+  renderTree,
+  searchCards,
+  archiveCard,
+  unarchiveCard,
+};