@theglitchking/semantic-memory 1.0.0

package/dist/chunk-CXTRTCIK.js

@@ -0,0 +1,762 @@
+import {
+  loadSchema,
+  validateNote
+} from "./chunk-E2Z4J4MK.js";
+
+// src/core/crud.ts
+import { readFile, writeFile, unlink, rename, mkdir } from "fs/promises";
+import { dirname, join } from "path";
+import { existsSync } from "fs";
+import { glob } from "glob";
+import matter from "gray-matter";
+var NoteCrud = class {
+  notesPath;
+  constructor(notesPath) {
+    this.notesPath = notesPath;
+  }
+  async create(relativePath, content, frontmatter) {
+    const absPath = join(this.notesPath, relativePath);
+    if (existsSync(absPath)) {
+      throw new Error(`Note already exists: ${relativePath}`);
+    }
+    await mkdir(dirname(absPath), { recursive: true });
+    const stamps = computeStamps(content);
+    const merged = { ...stamps, ...frontmatter ?? {} };
+    const fileContent = matter.stringify(content, merged);
+    await writeFile(absPath, fileContent, "utf-8");
+    return relativePath;
+  }
+  async read(relativePath) {
+    const absPath = join(this.notesPath, relativePath);
+    return readFile(absPath, "utf-8");
+  }
+  async readMultiple(paths) {
+    const results = /* @__PURE__ */ new Map();
+    await Promise.all(
+      paths.map(async (p) => {
+        try {
+          const content = await this.read(p);
+          results.set(p, content);
+        } catch {
+          results.set(p, `[Error: could not read ${p}]`);
+        }
+      })
+    );
+    return results;
+  }
+  async update(relativePath, content, options) {
+    const absPath = join(this.notesPath, relativePath);
+    if (!existsSync(absPath)) {
+      throw new Error(`Note does not exist: ${relativePath}`);
+    }
+    const existing = await readFile(absPath, "utf-8");
+    let updated;
+    switch (options.mode) {
+      case "overwrite":
+        updated = content;
+        break;
+      case "append":
+        updated = existing + "\n" + content;
+        break;
+      case "prepend": {
+        const { data, content: body2 } = matter(existing);
+        const newBody = content + "\n" + body2;
+        updated = Object.keys(data).length > 0 ? matter.stringify(newBody, data) : newBody;
+        break;
+      }
+      case "patch-by-heading": {
+        if (!options.heading) throw new Error("patch-by-heading requires a heading");
+        updated = this.patchByHeading(existing, options.heading, content);
+        break;
+      }
+    }
+    const { data: existingFm, content: body } = matter(updated);
+    const stamps = computeStamps(body);
+    const newFm = { ...existingFm, ...stamps };
+    await writeFile(absPath, matter.stringify(body, newFm), "utf-8");
+  }
+  async delete(relativePath) {
+    const absPath = join(this.notesPath, relativePath);
+    if (!existsSync(absPath)) {
+      throw new Error(`Note does not exist: ${relativePath}`);
+    }
+    await unlink(absPath);
+  }
+  async move(fromPath, toPath) {
+    const absFrom = join(this.notesPath, fromPath);
+    const absTo = join(this.notesPath, toPath);
+    if (!existsSync(absFrom)) {
+      throw new Error(`Note does not exist: ${fromPath}`);
+    }
+    if (existsSync(absTo)) {
+      throw new Error(`Destination already exists: ${toPath}`);
+    }
+    await mkdir(dirname(absTo), { recursive: true });
+    await rename(absFrom, absTo);
+    await this.updateWikilinksAfterMove(fromPath, toPath);
+  }
+  async updateWikilinksAfterMove(oldPath, newPath) {
+    const oldName = oldPath.replace(/\.md$/, "").split("/").pop();
+    const newName = newPath.replace(/\.md$/, "").split("/").pop();
+    if (oldName === newName) return;
+    const files = await glob("**/*.md", { cwd: this.notesPath });
+    for (const file of files) {
+      const absPath = join(this.notesPath, file);
+      const content = await readFile(absPath, "utf-8");
+      const pattern = new RegExp(`\\[\\[${escapeRegex(oldName)}(\\|[^\\]]*)?\\]\\]`, "g");
+      if (!pattern.test(content)) continue;
+      const updated = content.replace(pattern, `[[${newName}$1]]`);
+      await writeFile(absPath, updated, "utf-8");
+    }
+  }
+  patchByHeading(content, heading, newContent) {
+    const lines = content.split("\n");
+    const headingPattern = new RegExp(`^#{1,6}\\s+${escapeRegex(heading)}\\s*$`, "i");
+    let headingIndex = -1;
+    let headingLevel = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (headingPattern.test(lines[i])) {
+        headingIndex = i;
+        const match = lines[i].match(/^(#{1,6})\s+/);
+        headingLevel = match ? match[1].length : 1;
+        break;
+      }
+    }
+    if (headingIndex === -1) {
+      throw new Error(`Heading not found: ${heading}`);
+    }
+    let endIndex = lines.length;
+    for (let i = headingIndex + 1; i < lines.length; i++) {
+      const match = lines[i].match(/^(#{1,6})\s+/);
+      if (match && match[1].length <= headingLevel) {
+        endIndex = i;
+        break;
+      }
+    }
+    const before = lines.slice(0, headingIndex + 1);
+    const after = lines.slice(endIndex);
+    return [...before, "", newContent, "", ...after].join("\n");
+  }
+};
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function computeStamps(body) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const wordCount = body.trim() ? body.trim().split(/\s+/).length : 0;
+  const minutes = Math.max(1, Math.ceil(wordCount / 200));
+  return {
+    last_updated: today,
+    word_count: wordCount,
+    estimated_read_time: `${minutes} min read`
+  };
+}
+
+// src/core/frontmatter.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { glob as glob2 } from "glob";
+import matter2 from "gray-matter";
+var FrontmatterManager = class {
+  notesPath;
+  constructor(notesPath) {
+    this.notesPath = notesPath;
+  }
+  async get(relativePath) {
+    const absPath = join2(this.notesPath, relativePath);
+    const raw = await readFile2(absPath, "utf-8");
+    const { data } = matter2(raw);
+    return data;
+  }
+  async update(relativePath, fields) {
+    const absPath = join2(this.notesPath, relativePath);
+    const raw = await readFile2(absPath, "utf-8");
+    const { data, content } = matter2(raw);
+    for (const [key, value] of Object.entries(fields)) {
+      if (value === null || value === void 0) {
+        delete data[key];
+      } else {
+        data[key] = value;
+      }
+    }
+    const updated = matter2.stringify(content, data);
+    await writeFile2(absPath, updated, "utf-8");
+  }
+};
+var TagManager = class {
+  notesPath;
+  constructor(notesPath) {
+    this.notesPath = notesPath;
+  }
+  async list(relativePath) {
+    const absPath = join2(this.notesPath, relativePath);
+    const raw = await readFile2(absPath, "utf-8");
+    const { data, content } = matter2(raw);
+    const fmTags = Array.isArray(data.tags) ? data.tags : [];
+    const inlineTags = [...content.matchAll(/(?:^|\s)#([a-zA-Z][\w-/]*)/g)].map(
+      (m) => m[1]
+    );
+    return [.../* @__PURE__ */ new Set([...fmTags, ...inlineTags])];
+  }
+  async add(relativePath, tags) {
+    const absPath = join2(this.notesPath, relativePath);
+    const raw = await readFile2(absPath, "utf-8");
+    const { data, content } = matter2(raw);
+    const existing = Array.isArray(data.tags) ? data.tags : [];
+    const merged = [.../* @__PURE__ */ new Set([...existing, ...tags])];
+    data.tags = merged;
+    const updated = matter2.stringify(content, data);
+    await writeFile2(absPath, updated, "utf-8");
+  }
+  async remove(relativePath, tags) {
+    const absPath = join2(this.notesPath, relativePath);
+    const raw = await readFile2(absPath, "utf-8");
+    const { data, content } = matter2(raw);
+    if (Array.isArray(data.tags)) {
+      data.tags = data.tags.filter((t) => !tags.includes(t));
+    }
+    let updatedContent = content;
+    for (const tag of tags) {
+      const pattern = new RegExp(`(^|\\s)#${escapeRegex2(tag)}(?=\\s|$)`, "g");
+      updatedContent = updatedContent.replace(pattern, "$1");
+    }
+    const updated = matter2.stringify(updatedContent, data);
+    await writeFile2(absPath, updated, "utf-8");
+  }
+  async renameVaultWide(oldTag, newTag) {
+    const files = await glob2("**/*.md", { cwd: this.notesPath });
+    let count = 0;
+    for (const file of files) {
+      const absPath = join2(this.notesPath, file);
+      const raw = await readFile2(absPath, "utf-8");
+      const { data, content } = matter2(raw);
+      let changed = false;
+      if (Array.isArray(data.tags)) {
+        const idx = data.tags.indexOf(oldTag);
+        if (idx >= 0) {
+          data.tags[idx] = newTag;
+          changed = true;
+        }
+      }
+      const pattern = new RegExp(`(^|\\s)#${escapeRegex2(oldTag)}(?=\\s|$)`, "g");
+      const updatedContent = content.replace(pattern, `$1#${newTag}`);
+      if (updatedContent !== content) changed = true;
+      if (changed) {
+        const updated = matter2.stringify(updatedContent, data);
+        await writeFile2(absPath, updated, "utf-8");
+        count++;
+      }
+    }
+    return count;
+  }
+};
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/core/watcher.ts
+import { watch } from "chokidar";
+import { EventEmitter } from "events";
+var Watcher = class extends EventEmitter {
+  notesPath;
+  fsWatcher = null;
+  debounceMs;
+  pendingChanges = /* @__PURE__ */ new Set();
+  debounceTimer = null;
+  readyPromise = null;
+  usePolling;
+  constructor(notesPath, debounceMs = 500, usePolling = false) {
+    super();
+    this.notesPath = notesPath;
+    this.debounceMs = debounceMs;
+    this.usePolling = usePolling;
+  }
+  start() {
+    if (this.fsWatcher) return;
+    this.fsWatcher = watch("**/*.md", {
+      cwd: this.notesPath,
+      ignoreInitial: true,
+      followSymlinks: true,
+      ignored: [
+        "**/node_modules/**",
+        "**/.semantic-sidekick-index/**",
+        "**/.git/**"
+      ],
+      ...this.usePolling ? { usePolling: true, interval: 100 } : {}
+    });
+    this.readyPromise = new Promise((resolve) => {
+      this.fsWatcher.on("ready", resolve);
+    });
+    this.fsWatcher.on("add", (path) => this.enqueue(path));
+    this.fsWatcher.on("change", (path) => this.enqueue(path));
+    this.fsWatcher.on("unlink", (path) => this.enqueue(path));
+    this.fsWatcher.on("error", (err) => this.emit("error", err));
+  }
+  async ready() {
+    if (this.readyPromise) await this.readyPromise;
+  }
+  stop() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.fsWatcher?.close();
+    this.fsWatcher = null;
+    this.pendingChanges.clear();
+  }
+  enqueue(path) {
+    this.pendingChanges.add(path);
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      const paths = [...this.pendingChanges];
+      this.pendingChanges.clear();
+      this.emit("changed", paths);
+    }, this.debounceMs);
+  }
+};
+
+// src/core/ingest.ts
+import { basename } from "path";
+function buildIngestChangeSet(input) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const sourcePath = input.source.source_path ?? defaultSourcePath(input.source);
+  const sourceNote = {
+    path: sourcePath,
+    content: buildSourceBody(input.source),
+    frontmatter: {
+      title: input.source.source_title,
+      type: input.source.source_type ?? "source",
+      status: "active",
+      source: input.source.source_uri,
+      last_verified: today,
+      confidence: "high",
+      ...input.source.source_tags && input.source.source_tags.length > 0 && { tags: input.source.source_tags }
+    }
+  };
+  const unitCreates = input.units.map((u) => {
+    const title = u.title ?? titleFromPath(u.path);
+    const derivedFrom = [sourcePath, ...u.extra_derived_from ?? []];
+    return {
+      path: u.path.endsWith(".md") ? u.path : u.path + ".md",
+      content: u.content.startsWith("#") ? u.content : `# ${title}
+
+${u.content.trim()}
+`,
+      frontmatter: {
+        title,
+        type: u.type ?? "note",
+        status: "active",
+        derived_from: derivedFrom,
+        last_verified: today,
+        confidence: u.confidence ?? "medium",
+        ...u.extra_frontmatter ?? {}
+      }
+    };
+  });
+  return {
+    changeset: { creates: [sourceNote, ...unitCreates] },
+    sourcePath,
+    unitPaths: unitCreates.map((c) => c.path)
+  };
+}
+function buildSourceBody(source) {
+  const lines = [`# ${source.source_title}`, "", `**Source:** ${source.source_uri}`, ""];
+  if (source.source_summary) {
+    lines.push(source.source_summary.trim(), "");
+  } else {
+    lines.push("_Summary not provided \u2014 fill in when referencing this source._", "");
+  }
+  return lines.join("\n");
+}
+function defaultSourcePath(source) {
+  const slug = slugify(source.source_title);
+  return `sources/${slug}.md`;
+}
+function titleFromPath(p) {
+  return basename(p).replace(/\.md$/, "").replace(/[-_]/g, " ");
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+}
+
+// src/core/index-regen.ts
+import { readdir, readFile as readFile3, writeFile as writeFile3, stat } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3, dirname as dirname2, basename as basename2, sep } from "path";
+import matter3 from "gray-matter";
+var INDEX_FILE = "INDEX.md";
+var INDEX_OVERFLOW_THRESHOLD = 100;
+async function regenDirectoryIndex(vaultPath, dirRel) {
+  const absDir = join3(vaultPath, dirRel);
+  const indexPath = join3(absDir, INDEX_FILE);
+  const relIndex = join3(dirRel, INDEX_FILE);
+  if (!existsSync2(absDir)) {
+    return { directory: dirRel, indexPath: relIndex, entryCount: 0, overflowed: false, wrote: false };
+  }
+  const files = (await readdir(absDir)).filter(
+    (f) => f.endsWith(".md") && f !== INDEX_FILE && f !== "README.md"
+  );
+  const entries = [];
+  for (const f of files) {
+    const full = join3(absDir, f);
+    try {
+      const st = await stat(full);
+      if (!st.isFile()) continue;
+      const raw = await readFile3(full, "utf-8");
+      const { data, content } = matter3(raw);
+      const title = typeof data.title === "string" ? data.title : firstHeading(content) ?? basenameNoExt(f);
+      const summary = typeof data.purpose === "string" ? data.purpose : firstParagraph(content);
+      entries.push({ path: f, title, summary });
+    } catch {
+    }
+  }
+  entries.sort((a, b) => a.title.localeCompare(b.title));
+  const body = renderIndex(dirRel, entries);
+  const overflowed = entries.length > INDEX_OVERFLOW_THRESHOLD;
+  let wrote = false;
+  if (existsSync2(indexPath)) {
+    const current = await readFile3(indexPath, "utf-8");
+    if (current !== body) {
+      await writeFile3(indexPath, body, "utf-8");
+      wrote = true;
+    }
+  } else {
+    await writeFile3(indexPath, body, "utf-8");
+    wrote = true;
+  }
+  return { directory: dirRel, indexPath: relIndex, entryCount: entries.length, overflowed, wrote };
+}
+async function regenIndexesForPaths(vaultPath, paths) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const p of paths) {
+    const d = dirname2(p);
+    if (d === "." || d === "/") continue;
+    dirs.add(d);
+  }
+  const results = [];
+  for (const d of dirs) {
+    results.push(await regenDirectoryIndex(vaultPath, d));
+  }
+  return results;
+}
+function renderIndex(dirRel, entries) {
+  const header = `# ${toTitle(dirRel)} Index
+
+> Auto-generated by semantic-sidekick. Changes are overwritten on apply_patch. Add prose to per-note files, not here.
+
+`;
+  if (entries.length === 0) return header + "_No notes in this directory yet._\n";
+  const overflowNote = entries.length > INDEX_OVERFLOW_THRESHOLD ? `> \u26A0\uFE0F  ${entries.length} entries \u2014 consider splitting this directory into subfolders (threshold: ${INDEX_OVERFLOW_THRESHOLD}).
+
+` : "";
+  const lines = entries.map((e) => {
+    const linkText = e.title;
+    const target = e.path.replace(/\.md$/, "");
+    const summary = e.summary ? ` \u2014 ${truncate(e.summary, 140)}` : "";
+    return `- [${linkText}](./${e.path}) \u2014 \`[[${target}]]\`${summary}`;
+  });
+  return header + overflowNote + lines.join("\n") + "\n";
+}
+function toTitle(dirRel) {
+  return dirRel.split(sep).pop().replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function basenameNoExt(p) {
+  return basename2(p).replace(/\.md$/, "");
+}
+function firstHeading(content) {
+  const m = content.match(/^\s*#{1,6}\s+(.+)$/m);
+  return m ? m[1].trim() : null;
+}
+function firstParagraph(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith(">")) continue;
+    if (trimmed.startsWith("```")) continue;
+    return trimmed.replace(/\s+/g, " ");
+  }
+  return void 0;
+}
+function truncate(s, n) {
+  return s.length <= n ? s : s.slice(0, n - 1).trimEnd() + "\u2026";
+}
+
+// src/core/patch.ts
+import { readFile as readFile4, writeFile as writeFile4, unlink as unlink2, rename as rename2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+import matter4 from "gray-matter";
+async function applyPatch(notesPath, changeset, options = {}) {
+  const validate = options.validate !== false;
+  const dryRun = options.dryRun === true;
+  const allowWarn = options.allowLintWarnings !== false;
+  const errors = [];
+  const lint = [];
+  const applied = [];
+  const snapshots = [];
+  const crud = new NoteCrud(notesPath);
+  let schema = null;
+  if (validate) {
+    try {
+      schema = await loadSchema(notesPath);
+    } catch (e) {
+      errors.push(`failed to load schema: ${e instanceof Error ? e.message : String(e)}`);
+      return { ok: false, applied, rolledBack: [], lint, errors };
+    }
+  }
+  for (const c of changeset.creates ?? []) {
+    if (existsSync3(join4(notesPath, c.path))) {
+      errors.push(`create: already exists: ${c.path}`);
+    }
+  }
+  for (const u of changeset.updates ?? []) {
+    if (!existsSync3(join4(notesPath, u.path))) {
+      errors.push(`update: does not exist: ${u.path}`);
+    }
+  }
+  for (const d of changeset.deletes ?? []) {
+    if (!existsSync3(join4(notesPath, d.path))) {
+      errors.push(`delete: does not exist: ${d.path}`);
+    }
+  }
+  for (const m of changeset.moves ?? []) {
+    if (!existsSync3(join4(notesPath, m.from))) {
+      errors.push(`move: source does not exist: ${m.from}`);
+    }
+    if (existsSync3(join4(notesPath, m.to))) {
+      errors.push(`move: destination exists: ${m.to}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, applied, rolledBack: [], lint, errors };
+  }
+  if (validate && schema) {
+    for (const c of changeset.creates ?? []) {
+      const proposed = matter4.stringify(c.content, c.frontmatter ?? {});
+      lint.push(...validateNote(c.path, proposed, schema));
+    }
+    for (const u of changeset.updates ?? []) {
+      const abs = join4(notesPath, u.path);
+      let proposed;
+      try {
+        const existing = await readFile4(abs, "utf-8");
+        proposed = applyUpdateInMemory(existing, u);
+      } catch (e) {
+        errors.push(`update precheck: ${u.path}: ${e instanceof Error ? e.message : String(e)}`);
+        continue;
+      }
+      lint.push(...validateNote(u.path, proposed, schema));
+    }
+    const schemaErrors = lint.filter((f) => f.rule === "schema_violations" && f.severity === "error");
+    if (schemaErrors.length > 0) {
+      errors.push(`${schemaErrors.length} schema violation(s) blocked the patch`);
+    }
+    if (!allowWarn) {
+      const warns = lint.filter((f) => f.severity === "warn");
+      if (warns.length > 0) errors.push(`${warns.length} lint warning(s) blocked the patch (allowLintWarnings=false)`);
+    }
+  }
+  if (errors.length > 0 || dryRun) {
+    return { ok: errors.length === 0, applied, rolledBack: [], lint, errors };
+  }
+  try {
+    for (const c of changeset.creates ?? []) {
+      const abs = join4(notesPath, c.path);
+      await crud.create(c.path, c.content, c.frontmatter);
+      snapshots.push({ op: "create", path: c.path, absPath: abs });
+      applied.push({ op: "create", path: c.path });
+    }
+    for (const u of changeset.updates ?? []) {
+      const abs = join4(notesPath, u.path);
+      const prev = await readFile4(abs, "utf-8");
+      await crud.update(u.path, u.content, { mode: u.mode, heading: u.heading });
+      snapshots.push({ op: "update", path: u.path, absPath: abs, prevContent: prev });
+      applied.push({ op: "update", path: u.path });
+    }
+    for (const m of changeset.moves ?? []) {
+      await crud.move(m.from, m.to);
+      snapshots.push({
+        op: "move",
+        path: m.to,
+        absPath: join4(notesPath, m.to),
+        prevAbsPath: join4(notesPath, m.from)
+      });
+      applied.push({ op: "move", path: `${m.from} -> ${m.to}` });
+    }
+    for (const d of changeset.deletes ?? []) {
+      const abs = join4(notesPath, d.path);
+      const prev = await readFile4(abs, "utf-8");
+      await crud.delete(d.path);
+      snapshots.push({ op: "delete", path: d.path, absPath: abs, prevContent: prev });
+      applied.push({ op: "delete", path: d.path });
+    }
+  } catch (e) {
+    errors.push(`op failed: ${e instanceof Error ? e.message : String(e)} \u2014 rolling back`);
+    const rolledBack = await rollback(snapshots);
+    return { ok: false, applied, rolledBack, lint, errors };
+  }
+  let indexes_regenerated = [];
+  if (options.regenIndexes !== false) {
+    const touched = [
+      ...(changeset.creates ?? []).map((c) => c.path),
+      ...(changeset.deletes ?? []).map((d) => d.path),
+      ...(changeset.moves ?? []).flatMap((m) => [m.from, m.to])
+    ];
+    try {
+      indexes_regenerated = await regenIndexesForPaths(notesPath, touched);
+    } catch (e) {
+      errors.push(`index regen failed (patch still applied): ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return { ok: true, applied, rolledBack: [], lint, errors, indexes_regenerated };
+}
+async function rollback(snapshots) {
+  const reverted = [];
+  for (const s of snapshots.slice().reverse()) {
+    try {
+      switch (s.op) {
+        case "create":
+          if (existsSync3(s.absPath)) await unlink2(s.absPath);
+          reverted.push({ op: "create", path: s.path });
+          break;
+        case "update":
+          if (s.prevContent !== void 0) {
+            await writeFile4(s.absPath, s.prevContent, "utf-8");
+          }
+          reverted.push({ op: "update", path: s.path });
+          break;
+        case "delete":
+          if (s.prevContent !== void 0) {
+            await mkdir2(dirname3(s.absPath), { recursive: true });
+            await writeFile4(s.absPath, s.prevContent, "utf-8");
+          }
+          reverted.push({ op: "delete", path: s.path });
+          break;
+        case "move":
+          if (s.prevAbsPath && existsSync3(s.absPath)) {
+            await mkdir2(dirname3(s.prevAbsPath), { recursive: true });
+            await rename2(s.absPath, s.prevAbsPath);
+          }
+          reverted.push({ op: "move", path: s.path });
+          break;
+      }
+    } catch {
+    }
+  }
+  return reverted;
+}
+function applyUpdateInMemory(existing, u) {
+  switch (u.mode) {
+    case "overwrite":
+      return u.content;
+    case "append":
+      return existing + "\n" + u.content;
+    case "prepend": {
+      const { data, content: body } = matter4(existing);
+      const newBody = u.content + "\n" + body;
+      return Object.keys(data).length > 0 ? matter4.stringify(newBody, data) : newBody;
+    }
+    case "patch-by-heading": {
+      if (!u.heading) throw new Error("patch-by-heading requires heading");
+      return patchByHeadingInMemory(existing, u.heading, u.content);
+    }
+  }
+}
+function patchByHeadingInMemory(content, heading, newContent) {
+  const lines = content.split("\n");
+  const re = new RegExp(`^#{1,6}\\s+${heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`, "i");
+  let idx = -1;
+  let level = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (re.test(lines[i])) {
+      idx = i;
+      const m = lines[i].match(/^(#{1,6})\s+/);
+      level = m ? m[1].length : 1;
+      break;
+    }
+  }
+  if (idx === -1) throw new Error(`Heading not found: ${heading}`);
+  let end = lines.length;
+  for (let i = idx + 1; i < lines.length; i++) {
+    const m = lines[i].match(/^(#{1,6})\s+/);
+    if (m && m[1].length <= level) {
+      end = i;
+      break;
+    }
+  }
+  return [...lines.slice(0, idx + 1), "", newContent, "", ...lines.slice(end)].join("\n");
+}
+
+// src/core/synthesize.ts
+import { basename as basename3 } from "path";
+function buildSynthesizeChangeSet(input) {
+  const path = input.suggested_path.endsWith(".md") ? input.suggested_path : input.suggested_path + ".md";
+  const title = input.topic.trim();
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const frontmatter = {
+    title,
+    type: input.type ?? "note",
+    status: input.status ?? "active",
+    last_verified: today,
+    confidence: input.confidence ?? "medium",
+    ...input.sources && input.sources.length > 0 && { sources: input.sources },
+    ...input.derived_from && input.derived_from.length > 0 && { derived_from: input.derived_from },
+    ...input.decision_maker && { decision_maker: input.decision_maker },
+    ...input.decided_on && { decided_on: input.decided_on },
+    ...input.severity && { severity: input.severity },
+    ...input.extra_frontmatter ?? {}
+  };
+  const body = buildBody(title, input.answer, input.related_notes ?? []);
+  const create = { path, content: body, frontmatter };
+  const changeset = { creates: [create] };
+  return { changeset, path, title };
+}
+function buildBody(title, answer, relatedNotes) {
+  let body = `# ${title}
+
+${answer.trim()}
+`;
+  if (relatedNotes.length > 0) {
+    body = autoWikilink(body, relatedNotes);
+    const links = relatedNotes.map((r) => `- [[${wikilinkName(r)}]]`).join("\n");
+    body += `
+## Related
+
+${links}
+`;
+  }
+  return body;
+}
+function autoWikilink(body, relatedNotes) {
+  const parts = body.split(/(```[\s\S]*?```)/g);
+  return parts.map((part, i) => {
+    if (i % 2 === 1) return part;
+    let out = part;
+    for (const r of relatedNotes) {
+      const name = wikilinkName(r);
+      if (/[\[\]]/.test(out) && out.includes(`[[${name}]]`)) continue;
+      const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(`\\b${escaped}\\b`, "i");
+      out = out.replace(re, `[[${name}]]`);
+    }
+    return out;
+  }).join("");
+}
+function wikilinkName(pathOrName) {
+  const base = basename3(pathOrName).replace(/\.md$/, "");
+  return base;
+}
+
+export {
+  NoteCrud,
+  FrontmatterManager,
+  TagManager,
+  Watcher,
+  buildIngestChangeSet,
+  INDEX_FILE,
+  INDEX_OVERFLOW_THRESHOLD,
+  regenDirectoryIndex,
+  regenIndexesForPaths,
+  applyPatch,
+  buildSynthesizeChangeSet
+};
+//# sourceMappingURL=chunk-CXTRTCIK.js.map