@titan-design/brain 0.3.0 → 0.5.0

package/dist/chunk-4SD4JRLS.js

@@ -0,0 +1,840 @@
+import {
+  scanForChanges
+} from "./chunk-PO3GJPIC.js";
+
+// src/services/indexing.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { basename, dirname, join as join2, relative } from "path";
+
+// src/services/markdown-parser.ts
+import matter from "gray-matter";
+
+// src/types.ts
+var VALID_CORE_NOTE_TYPES = [
+  "note",
+  "decision",
+  "pattern",
+  "research",
+  "meeting",
+  "session-log",
+  "guide"
+];
+var VALID_NOTE_TIERS = ["slow", "fast"];
+var VALID_NOTE_CONFIDENCES = ["high", "medium", "low", "speculative"];
+var VALID_NOTE_STATUSES = ["current", "outdated", "deprecated", "draft"];
+var VALID_INBOX_SOURCES = [
+  "cli",
+  "rss",
+  "crawler",
+  "alert",
+  "api",
+  "file",
+  "notion",
+  "linear"
+];
+
+// src/utils.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function parseIntervalDays(interval) {
+  const match = interval.match(/^(\d+)\s*(d|w|m)$/);
+  if (!match) return 90;
+  const value = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "d":
+      return value;
+    case "w":
+      return value * 7;
+    case "m":
+      return value * 30;
+    default:
+      return 90;
+  }
+}
+
+// src/services/markdown-parser.ts
+var MAX_CHUNK_TOKENS = 512;
+var FENCE_OPEN = /^```/;
+var FENCE_CLOSE = /^```\s*$/;
+var TABLE_LINE = /^\|.+\|/;
+var MIN_CHUNK_LENGTH = 20;
+var IMAGE_REF = /!\[([^\]]*)\]\(([^)]+)\)/g;
+function estimateTokens(text) {
+  if (text.length === 0) return 0;
+  return Math.ceil(text.length / 4);
+}
+function parseMarkdown(filePath, content) {
+  const { data, content: body } = matter(content);
+  const id = deriveId(filePath, data);
+  const frontmatter = coerceFrontmatter(filePath, data);
+  const chunks = chunkBody(body);
+  const relations = extractRelations(id, data);
+  const imageRefs = extractImageReferences(body);
+  return {
+    id,
+    filePath,
+    frontmatter,
+    rawFrontmatter: data,
+    content: body,
+    chunks,
+    relations,
+    imageRefs: imageRefs.length > 0 ? imageRefs : void 0
+  };
+}
+function deriveId(filePath, data) {
+  if (typeof data.id === "string" && data.id.length > 0) return data.id;
+  if (typeof data.title === "string" && data.title.length > 0) return slugify(data.title);
+  const filename = filePath.split("/").pop() ?? filePath;
+  return filename.replace(/\.md$/, "");
+}
+function coerceFrontmatter(filePath, data) {
+  const filename = (filePath.split("/").pop() ?? filePath).replace(/\.md$/, "");
+  const hasModule = typeof data.module === "string";
+  const type = hasModule && typeof data.type === "string" ? data.type : coerceEnum(data.type, VALID_CORE_NOTE_TYPES, "note");
+  return {
+    id: typeof data.id === "string" ? data.id : void 0,
+    title: typeof data.title === "string" ? data.title : filename,
+    type,
+    tier: coerceEnum(data.tier, VALID_NOTE_TIERS, "slow"),
+    category: coerceString(data.category),
+    tags: coerceTags(data.tags),
+    summary: coerceString(data.summary),
+    confidence: coerceEnum(data.confidence, VALID_NOTE_CONFIDENCES, void 0),
+    status: coerceEnum(data.status, VALID_NOTE_STATUSES, void 0),
+    sources: coerceSources(data.sources),
+    created: coerceDate(data.created),
+    modified: coerceDate(data.modified),
+    "last-reviewed": coerceDate(data["last-reviewed"]),
+    "review-interval": coerceReviewInterval(data["review-interval"]),
+    expires: coerceDate(data.expires),
+    date: coerceDate(data.date),
+    participants: coerceStringArray(data.participants),
+    project: coerceString(data.project),
+    outcome: coerceString(data.outcome),
+    related: coerceStringArray(data.related),
+    supersedes: coerceString(data.supersedes),
+    parent: coerceString(data.parent),
+    module: coerceString(data.module),
+    "module-instance": coerceString(data["module-instance"]),
+    "content-dir": coerceString(data["content-dir"])
+  };
+}
+function coerceString(value) {
+  if (typeof value === "string") return value;
+  if (value != null && typeof value !== "object") return String(value);
+  return void 0;
+}
+function coerceEnum(value, valid, fallback) {
+  if (typeof value === "string" && valid.includes(value)) return value;
+  return fallback;
+}
+function coerceTags(value) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => typeof v === "string");
+  }
+  if (typeof value === "string") {
+    if (value.includes(",")) {
+      return value.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    return [value];
+  }
+  return void 0;
+}
+function coerceDate(value) {
+  if (value instanceof Date) {
+    return isNaN(value.getTime()) ? void 0 : value.toISOString();
+  }
+  if (typeof value === "string") return value;
+  return void 0;
+}
+function coerceSources(value) {
+  if (!Array.isArray(value)) return void 0;
+  const valid = [];
+  for (const entry of value) {
+    if (typeof entry === "object" && entry !== null && typeof entry.url === "string") {
+      valid.push({
+        url: entry.url,
+        accessed: typeof entry.accessed === "string" ? entry.accessed : "",
+        type: typeof entry.type === "string" ? entry.type : ""
+      });
+    }
+  }
+  return valid.length > 0 ? valid : void 0;
+}
+function coerceReviewInterval(value) {
+  if (typeof value === "string" && /^\d+[dwm]$/.test(value)) return value;
+  return void 0;
+}
+function coerceStringArray(value) {
+  if (Array.isArray(value)) {
+    const filtered = value.filter((v) => typeof v === "string");
+    return filtered.length > 0 ? filtered : void 0;
+  }
+  return void 0;
+}
+function buildAncestry(stack) {
+  if (stack.length === 0) return null;
+  return stack.map((h) => `${"#".repeat(h.level)} ${h.text}`).join("\n");
+}
+function splitIntoSections(body) {
+  const lines = body.split("\n");
+  const sections = [];
+  const headingStack = [];
+  let current = { heading: null, headingLevel: 0, headingAncestry: null, lines: [] };
+  for (const line of lines) {
+    const match = line.match(/^(#{1,3})\s+(.+)$/);
+    if (match) {
+      sections.push(current);
+      const level = match[1].length;
+      const text = match[2];
+      while (headingStack.length > 0 && headingStack[headingStack.length - 1].level >= level) {
+        headingStack.pop();
+      }
+      headingStack.push({ level, text });
+      current = {
+        heading: text,
+        headingLevel: level,
+        headingAncestry: buildAncestry(headingStack),
+        lines: []
+      };
+    } else {
+      current.lines.push(line);
+    }
+  }
+  sections.push(current);
+  return sections;
+}
+function prependAncestry(ancestry, text) {
+  if (!ancestry) return text;
+  return `${ancestry}
+
+${text}`;
+}
+function chunkBody(body) {
+  const sections = splitIntoSections(body);
+  const chunks = [];
+  let position = 0;
+  for (const section of sections) {
+    const text = synthesizeImageParagraphs(section.lines.join("\n").trim());
+    if (text.length < MIN_CHUNK_LENGTH) continue;
+    const contentWithAncestry = prependAncestry(section.headingAncestry, text);
+    const tokens = estimateTokens(contentWithAncestry);
+    const containsTable = /^\|.+\|/m.test(text);
+    if (tokens <= MAX_CHUNK_TOKENS && !containsTable) {
+      chunks.push({
+        heading: section.heading,
+        headingAncestry: section.headingAncestry,
+        text: contentWithAncestry,
+        tokenCount: tokens,
+        chunkType: "section",
+        cutType: "heading_boundary",
+        position: position++
+      });
+    } else {
+      const subChunks = splitOversizedSection(
+        section.heading,
+        section.headingAncestry,
+        text,
+        position
+      );
+      position += subChunks.length;
+      chunks.push(...subChunks);
+    }
+  }
+  return chunks;
+}
+function splitOversizedSection(heading, headingAncestry, text, startPosition) {
+  const paragraphs = splitParagraphsProtectingFences(text);
+  const chunks = [];
+  let buffer = "";
+  let overlapPrefix = "";
+  let pos = startPosition;
+  const ancestryPrefix = headingAncestry ? headingAncestry + "\n\n" : "";
+  const ancestryTokens = estimateTokens(ancestryPrefix);
+  const chunkBudget = MAX_CHUNK_TOKENS - ancestryTokens;
+  for (const para of paragraphs) {
+    const isTablePara = TABLE_LINE.test(para);
+    const bufferIsTable = TABLE_LINE.test(buffer);
+    const boundaryChange = buffer.length > 0 && isTablePara !== bufferIsTable;
+    const budgetForContent = overlapPrefix.length > 0 ? chunkBudget - estimateTokens(overlapPrefix + "\n\n") : chunkBudget;
+    const bufferWithPara = buffer.length > 0 ? buffer + "\n\n" + para : para;
+    if ((estimateTokens(bufferWithPara) > budgetForContent || boundaryChange) && buffer.length > 0) {
+      const rawText = overlapPrefix.length > 0 ? overlapPrefix + "\n\n" + buffer : buffer;
+      const chunkText = ancestryPrefix + rawText.trim();
+      const tokenCount = estimateTokens(chunkText);
+      const cutType = para.startsWith("```") ? "code_fence" : isTablePara || bufferIsTable ? "table_boundary" : "paragraph_end";
+      chunks.push({
+        heading,
+        headingAncestry,
+        text: chunkText,
+        tokenCount,
+        chunkType: "paragraph",
+        cutType,
+        position: pos++
+      });
+      overlapPrefix = bufferIsTable ? "" : extractOverlap(buffer);
+      buffer = para;
+    } else {
+      buffer = buffer.length > 0 ? buffer + "\n\n" + para : para;
+    }
+  }
+  if (buffer.length > 0) {
+    const rawText = overlapPrefix.length > 0 ? overlapPrefix + "\n\n" + buffer : buffer;
+    const chunkText = ancestryPrefix + rawText.trim();
+    const tokenCount = estimateTokens(chunkText);
+    chunks.push({
+      heading,
+      headingAncestry,
+      text: chunkText,
+      tokenCount,
+      chunkType: "paragraph",
+      cutType: "paragraph_end",
+      position: pos++
+    });
+  }
+  return chunks;
+}
+function extractOverlap(text) {
+  const targetTokens = Math.ceil(estimateTokens(text) * 0.1);
+  const targetChars = targetTokens * 4;
+  if (text.length <= targetChars) return text;
+  return text.slice(-targetChars);
+}
+function splitParagraphsProtectingFences(text) {
+  const lines = text.split("\n");
+  const paragraphs = [];
+  let current = [];
+  let inFence = false;
+  let inTable = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!inFence && FENCE_OPEN.test(line)) {
+      if (current.length > 0) {
+        const joined2 = current.join("\n").trim();
+        if (joined2.length > 0) paragraphs.push(joined2);
+        current = [];
+      }
+      inFence = true;
+      inTable = false;
+      current.push(line);
+      continue;
+    }
+    if (inFence) {
+      current.push(line);
+      if (FENCE_CLOSE.test(line) && current.length > 1) {
+        const joined2 = current.join("\n").trim();
+        if (joined2.length > 0) paragraphs.push(joined2);
+        current = [];
+        inFence = false;
+      }
+      continue;
+    }
+    if (TABLE_LINE.test(line)) {
+      if (!inTable) {
+        if (current.length > 0) {
+          const joined2 = current.join("\n").trim();
+          if (joined2.length > 0) paragraphs.push(joined2);
+          current = [];
+        }
+        inTable = true;
+      }
+      current.push(line);
+      continue;
+    }
+    if (inTable) {
+      const joined2 = current.join("\n").trim();
+      if (joined2.length > 0) paragraphs.push(joined2);
+      current = [];
+      inTable = false;
+    }
+    if (line.trim() === "") {
+      if (current.length > 0) {
+        const joined2 = current.join("\n").trim();
+        if (joined2.length > 0) paragraphs.push(synthesizeImageContext(joined2));
+        current = [];
+      }
+    } else {
+      current.push(line);
+    }
+  }
+  const joined = current.join("\n").trim();
+  if (joined.length > 0) paragraphs.push(synthesizeImageContext(joined));
+  return paragraphs;
+}
+function extractImageReferences(content) {
+  const refs = [];
+  const regex = new RegExp(IMAGE_REF.source, IMAGE_REF.flags);
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    refs.push({ alt: match[1], path: match[2] });
+  }
+  return refs;
+}
+function synthesizeImageParagraphs(text) {
+  return text.split(/\n\n/).map((p) => synthesizeImageContext(p)).join("\n\n");
+}
+function synthesizeImageContext(paragraph) {
+  const imageMatch = paragraph.match(/!\[([^\]]*)\]\(([^)]+)\)/);
+  if (!imageMatch) return paragraph;
+  const alt = imageMatch[1];
+  const textWithoutImage = paragraph.replace(/!\[[^\]]*\]\([^)]+\)/, "").trim();
+  if (textWithoutImage.length < 50 && alt.length > 0) {
+    return `[Image: ${alt}] ${textWithoutImage}`.trim();
+  }
+  return paragraph;
+}
+function extractNoteLinks(content) {
+  const linkPattern = /\[([^\]]*)\]\(([^)]+)\)/g;
+  const links = [];
+  for (const match of content.matchAll(linkPattern)) {
+    const target = match[2];
+    if (target.startsWith("http") || target.startsWith("#") || target.startsWith("mailto:"))
+      continue;
+    const slug = target.replace(/\.md$/, "").split("/").pop() ?? target;
+    if (slug.length > 0) links.push(slug);
+  }
+  return [...new Set(links)];
+}
+function extractRelations(sourceId, data) {
+  const relations = [];
+  if (Array.isArray(data.related)) {
+    for (const target of data.related) {
+      if (typeof target === "string") {
+        relations.push({
+          sourceId,
+          targetId: target,
+          type: "related-to"
+        });
+      }
+    }
+  }
+  if (typeof data.supersedes === "string") {
+    relations.push({
+      sourceId,
+      targetId: data.supersedes,
+      type: "supersedes"
+    });
+  }
+  if (typeof data.parent === "string") {
+    relations.push({
+      sourceId,
+      targetId: data.parent,
+      type: "parent"
+    });
+  }
+  return relations;
+}
+
+// src/services/content-dir.ts
+import { mkdirSync, existsSync, readdirSync, readFileSync, renameSync, rmSync } from "fs";
+import { join, extname } from "path";
+var INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".json", ".yaml", ".yml"]);
+function readIndexableContent(contentDir) {
+  if (!existsSync(contentDir)) return "";
+  const files = readdirSync(contentDir);
+  const parts = [];
+  for (const file of files.sort()) {
+    const ext = extname(file).toLowerCase();
+    if (!INDEXABLE_EXTENSIONS.has(ext)) continue;
+    try {
+      const content = readFileSync(join(contentDir, file), "utf-8");
+      parts.push(content);
+    } catch {
+    }
+  }
+  return parts.join("\n\n");
+}
+
+// src/services/graph.ts
+var MAX_DEPTH = 3;
+var BIDIRECTIONAL_TYPES = /* @__PURE__ */ new Set(["related-to", "related", "parent", "depends_on"]);
+function distanceToCosineSim(distance) {
+  return 1 - distance * distance / 2;
+}
+function computeAutoLinks(db, noteId, threshold = 0.65, maxLinks = 5, embedding) {
+  let queryEmbedding = embedding;
+  if (!queryEmbedding) {
+    const chunks = db.getChunksForNote(noteId);
+    if (chunks.length === 0) return [];
+    const stored = db.getChunkEmbedding(chunks[0].id);
+    if (!stored) return [];
+    queryEmbedding = stored;
+  }
+  const vectorResults = db.searchVector(queryEmbedding, maxLinks + 1);
+  const existing = db.getRelationsFrom(noteId);
+  const existingTargets = new Set(existing.map((r) => r.targetId));
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const result of vectorResults) {
+    if (result.noteId === noteId) continue;
+    if (seen.has(result.noteId)) continue;
+    const cosineSim = distanceToCosineSim(result.distance);
+    if (cosineSim < threshold) continue;
+    if (existingTargets.has(result.noteId)) continue;
+    seen.add(result.noteId);
+    links.push({
+      sourceId: noteId,
+      targetId: result.noteId,
+      type: "related"
+    });
+  }
+  return links;
+}
+function traverseGraph(db, rootId, depth) {
+  const effectiveDepth = Math.min(depth, MAX_DEPTH);
+  const visited = /* @__PURE__ */ new Map();
+  visited.set(rootId, 0);
+  const allEdges = [];
+  let frontier = [rootId];
+  for (let d = 0; d < effectiveDepth; d++) {
+    const relationsBatch = db.getRelationsBatch(frontier);
+    const nextFrontier = [];
+    for (const nodeId of frontier) {
+      const rels = relationsBatch.get(nodeId);
+      if (!rels) continue;
+      for (const rel of rels.from) {
+        allEdges.push(rel);
+        if (!visited.has(rel.targetId)) {
+          visited.set(rel.targetId, d + 1);
+          nextFrontier.push(rel.targetId);
+        }
+      }
+      for (const rel of rels.to) {
+        if (!BIDIRECTIONAL_TYPES.has(rel.type)) continue;
+        allEdges.push(rel);
+        if (!visited.has(rel.sourceId)) {
+          visited.set(rel.sourceId, d + 1);
+          nextFrontier.push(rel.sourceId);
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  const allIds = [...visited.keys()];
+  const notesById = db.getNotesByIds(allIds);
+  const root = {
+    id: rootId,
+    title: notesById.get(rootId)?.title ?? rootId,
+    type: notesById.get(rootId)?.type ?? "note",
+    tier: notesById.get(rootId)?.tier ?? "slow",
+    depth: 0
+  };
+  const nodes = [];
+  for (const [id, nodeDepth] of visited) {
+    const note = notesById.get(id);
+    nodes.push({
+      id,
+      title: note?.title ?? id,
+      type: note?.type ?? "note",
+      tier: note?.tier ?? "slow",
+      depth: nodeDepth
+    });
+  }
+  const nodeIds = new Set(visited.keys());
+  const edges = deduplicateEdges(
+    allEdges.filter((e) => nodeIds.has(e.sourceId) && nodeIds.has(e.targetId))
+  );
+  return { root, nodes, edges };
+}
+function expandResults(db, noteIds, depth) {
+  if (noteIds.length === 0) return [];
+  const inputSet = new Set(noteIds);
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const noteId of noteIds) {
+    const result = traverseGraph(db, noteId, depth);
+    for (const node of result.nodes) {
+      if (inputSet.has(node.id)) continue;
+      const decayed = Math.pow(0.5, node.depth);
+      const existing = scoreMap.get(node.id) ?? 0;
+      scoreMap.set(node.id, Math.max(existing, decayed));
+    }
+  }
+  return Array.from(scoreMap.entries()).map(([noteId, decayedScore]) => ({ noteId, decayedScore })).sort((a, b) => b.decayedScore - a.decayedScore);
+}
+function computeGraphScores(db, rootId, maxDepth = 3) {
+  const result = traverseGraph(db, rootId, maxDepth);
+  const scores = /* @__PURE__ */ new Map();
+  const edgeTypeByTarget = /* @__PURE__ */ new Map();
+  for (const edge of result.edges) {
+    const neighbor = edge.sourceId === rootId ? edge.targetId : edge.sourceId;
+    if (!edgeTypeByTarget.has(neighbor)) {
+      edgeTypeByTarget.set(neighbor, edge.type);
+    }
+  }
+  for (const node of result.nodes) {
+    if (node.id === rootId) continue;
+    const depth = node.depth;
+    const score = 1 / Math.pow(2, depth);
+    const relationType = edgeTypeByTarget.get(node.id) ?? "related";
+    const existing = scores.get(node.id);
+    if (!existing || score > existing.score) {
+      scores.set(node.id, { noteId: node.id, score, relationType, depth });
+    }
+  }
+  return scores;
+}
+function deduplicateEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const edge of edges) {
+    const key = `${edge.sourceId}|${edge.targetId}|${edge.type}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(edge);
+    }
+  }
+  return result;
+}
+
+// src/services/indexing.ts
+function isSkippedFile(filePath) {
+  return filePath.includes("/_templates/") || basename(filePath) === "_index.md";
+}
+function addFrontmatterField(filePath, field, value) {
+  const content = readFileSync2(filePath, "utf-8");
+  const endOfFrontmatter = content.indexOf("\n---", 4);
+  if (endOfFrontmatter === -1) return;
+  const frontmatter = content.slice(0, endOfFrontmatter);
+  const fieldRegex = new RegExp(`^${field}:.*$`, "m");
+  let updated;
+  if (fieldRegex.test(frontmatter)) {
+    updated = frontmatter.replace(fieldRegex, `${field}: ${value}`) + content.slice(endOfFrontmatter);
+  } else {
+    updated = frontmatter + `
+${field}: ${value}` + content.slice(endOfFrontmatter);
+  }
+  writeFileSync(filePath, updated, "utf-8");
+}
+function frontmatterToRecord(parsed) {
+  const fm = parsed.frontmatter;
+  const metadata = JSON.stringify(parsed.rawFrontmatter);
+  return {
+    id: parsed.id,
+    filePath: parsed.filePath,
+    title: fm.title,
+    type: fm.type,
+    tier: fm.tier,
+    category: fm.category ?? null,
+    tags: fm.tags ? fm.tags.join(",") : null,
+    summary: fm.summary ?? null,
+    confidence: fm.confidence ?? null,
+    status: fm.status ?? "current",
+    sources: fm.sources ? JSON.stringify(fm.sources) : null,
+    createdAt: fm.created ?? null,
+    modifiedAt: fm.modified ?? null,
+    lastReviewed: fm["last-reviewed"] ?? null,
+    reviewInterval: fm["review-interval"] ?? null,
+    expires: fm.expires ?? null,
+    metadata,
+    module: fm.module ?? null,
+    moduleInstance: fm["module-instance"] ?? null,
+    contentDir: fm["content-dir"] ?? null
+  };
+}
+function chunkId(noteId, content) {
+  const hash = createHash("sha256").update(`${noteId}:${content}`).digest("hex").slice(0, 16);
+  return `${noteId}::${hash}`;
+}
+function rawChunksToChunks(noteId, rawChunks) {
+  return rawChunks.map((rc) => ({
+    id: chunkId(noteId, rc.text),
+    noteId,
+    heading: rc.heading,
+    headingAncestry: rc.headingAncestry,
+    content: rc.text,
+    tokenCount: rc.tokenCount,
+    chunkType: rc.chunkType,
+    cutType: rc.cutType,
+    position: rc.position
+  }));
+}
+function inboxItemToMarkdown(item) {
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const title = item.title ?? "Inbox capture";
+  const id = slugify(title) || item.id.slice(0, 8);
+  const lines = [
+    "---",
+    `id: ${id}`,
+    `title: "${title.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`,
+    "type: note",
+    "tier: fast",
+    `status: draft`,
+    `created: ${now}`,
+    `modified: ${now}`
+  ];
+  if (item.sourceUrl) {
+    lines.push("sources:");
+    lines.push(`  - url: "${item.sourceUrl}"`);
+    lines.push(`    accessed: "${now}"`);
+    lines.push('    type: "web"');
+  }
+  lines.push("---", "", item.content);
+  return lines.join("\n");
+}
+async function indexSingleFile(db, embedder, filePath, content, hash, mtime) {
+  const parsed = parseMarkdown(filePath, content);
+  const noteRecord = frontmatterToRecord(parsed);
+  db.upsertNote(noteRecord);
+  let ftsContent = parsed.content;
+  if (noteRecord.contentDir) {
+    const dirContent = readIndexableContent(noteRecord.contentDir);
+    if (dirContent) {
+      ftsContent = ftsContent + "\n\n" + dirContent;
+    }
+  }
+  db.upsertNoteFTS(
+    parsed.id,
+    parsed.frontmatter.title,
+    parsed.frontmatter.summary ?? "",
+    ftsContent
+  );
+  const chunks = rawChunksToChunks(parsed.id, parsed.chunks);
+  let vectors = [];
+  if (chunks.length > 0) {
+    const texts = chunks.map((c) => c.content);
+    const embeddings = await embedder.embed(texts);
+    vectors = embeddings.map((e) => new Float32Array(e));
+    db.upsertChunks(parsed.id, chunks, vectors);
+  }
+  if (parsed.relations.length > 0) {
+    db.upsertRelations(parsed.id, parsed.relations);
+  }
+  const noteLinks = extractNoteLinks(parsed.content);
+  const linkRelations = [];
+  for (const targetSlug of noteLinks) {
+    const targetNote = db.getNoteById(targetSlug);
+    if (targetNote && targetSlug !== parsed.id) {
+      linkRelations.push({ sourceId: parsed.id, targetId: targetSlug, type: "related-to" });
+    }
+  }
+  if (linkRelations.length > 0) {
+    db.upsertRelations(parsed.id, linkRelations);
+  }
+  if (vectors.length > 0) {
+    const autoLinks = computeAutoLinks(db, parsed.id, 0.85, 5, vectors[0]);
+    if (autoLinks.length > 0) {
+      const existingRelations = db.getRelationsFrom(parsed.id);
+      db.upsertRelations(parsed.id, [...existingRelations, ...autoLinks]);
+    }
+  }
+  db.upsertFile({
+    path: filePath,
+    hash,
+    mtime,
+    indexedAt: Date.now()
+  });
+  return parsed.id;
+}
+async function indexFiles(db, embedder, notesDir, opts) {
+  if (!opts.force) {
+    db.checkModelMatch(embedder.model);
+  }
+  if (opts.force) {
+    const allNotes = db.getAllNotes();
+    for (const note of allNotes) {
+      db.deleteChunksForNote(note.id);
+    }
+  }
+  db.setEmbeddingModel(embedder.model, embedder.dimensions);
+  const knownFiles = opts.force ? /* @__PURE__ */ new Map() : db.getAllFiles();
+  const changes = await scanForChanges(notesDir, knownFiles);
+  let indexed = 0;
+  let deleted = 0;
+  const indexedNoteIds = [];
+  const toProcess = [...changes.new, ...changes.modified].filter((f) => !isSkippedFile(f.path));
+  for (const file of toProcess) {
+    const content = readFileSync2(file.path, "utf-8");
+    const noteId = await indexSingleFile(db, embedder, file.path, content, file.hash, file.mtime);
+    indexedNoteIds.push(noteId);
+    indexed++;
+  }
+  for (const filePath of changes.deleted.filter((p) => !isSkippedFile(p))) {
+    const note = db.getNoteByFilePath(filePath);
+    if (note) {
+      db.deleteNote(note.id);
+    }
+    db.deleteFile(filePath);
+    deleted++;
+  }
+  return { indexed, deleted, unchanged: changes.unchanged, indexedNoteIds };
+}
+async function processInbox(db, notesDir, embedder) {
+  const pending = db.getInboxItems("pending");
+  let processed = 0;
+  for (const item of pending) {
+    db.updateInboxStatus(item.id, "processing");
+    try {
+      const markdown = inboxItemToMarkdown(item);
+      const parsed = parseMarkdown("inbox-item.md", markdown);
+      const now = /* @__PURE__ */ new Date();
+      const yyyy = String(now.getFullYear());
+      const mm = String(now.getMonth() + 1).padStart(2, "0");
+      const dd = String(now.getDate()).padStart(2, "0");
+      const outPath = join2(notesDir, "logs", yyyy, mm, `${yyyy}-${mm}-${dd}-${parsed.id}.md`);
+      const dir = dirname(outPath);
+      if (!existsSync2(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+      writeFileSync(outPath, markdown, "utf-8");
+      const hash = createHash("sha256").update(markdown).digest("hex");
+      await indexSingleFile(db, embedder, outPath, markdown, hash, Date.now());
+      db.updateInboxStatus(item.id, "indexed");
+      processed++;
+    } catch (err) {
+      db.updateInboxStatus(item.id, "failed");
+      process.stderr.write(
+        `Failed to process inbox item ${item.id}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return processed;
+}
+function generateNoteIndex(db, notesDir) {
+  const notes = db.getAllNotes();
+  if (notes.length === 0) return;
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    const cat = note.category ?? "uncategorized";
+    const list = byCategory.get(cat) ?? [];
+    list.push(note);
+    byCategory.set(cat, list);
+  }
+  const lines = ["# Index", ""];
+  const sortedCategories = [...byCategory.keys()].sort();
+  for (const cat of sortedCategories) {
+    const catNotes = byCategory.get(cat);
+    lines.push(`## ${cat}`, "");
+    for (const note of catNotes) {
+      const relPath = relative(notesDir, note.filePath);
+      const summary = note.summary ? ` \u2014 ${note.summary}` : "";
+      lines.push(`- [${note.title}](${relPath})${summary}`);
+    }
+    lines.push("");
+  }
+  writeFileSync(join2(notesDir, "_index.md"), lines.join("\n"), "utf-8");
+}
+
+export {
+  VALID_CORE_NOTE_TYPES,
+  VALID_NOTE_TIERS,
+  VALID_NOTE_CONFIDENCES,
+  VALID_NOTE_STATUSES,
+  VALID_INBOX_SOURCES,
+  slugify,
+  parseIntervalDays,
+  parseMarkdown,
+  splitIntoSections,
+  computeAutoLinks,
+  traverseGraph,
+  expandResults,
+  computeGraphScores,
+  isSkippedFile,
+  addFrontmatterField,
+  indexSingleFile,
+  indexFiles,
+  processInbox,
+  generateNoteIndex
+};