@letrquan/book 0.3.0 → 0.4.0-beta.0

package/dist/chunk-EFXVSQ5J.js

@@ -0,0 +1,931 @@
+import {
+  parseFrontmatter
+} from "./chunk-KXAYUIKP.js";
+import {
+  isUserHome,
+  tryRealPath
+} from "./chunk-SBTU5BEC.js";
+import {
+  createDebugLogger
+} from "./chunk-OJBMDM5H.js";
+import {
+  createUncGuard
+} from "./chunk-EEX6QNXV.js";
+import {
+  writeFileAtomic
+} from "./chunk-REASC2QG.js";
+import {
+  resolveBookHome
+} from "./chunk-ZPSZZUWF.js";
+
+// src/memory-store.ts
+import {
+  closeSync,
+  constants,
+  copyFileSync,
+  existsSync,
+  fstatSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  readSync,
+  realpathSync,
+  renameSync,
+  rmdirSync,
+  rmSync,
+  statSync,
+  unlinkSync
+} from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
+
+// src/memory-limits.ts
+var DEFAULT_MAX_INDEX_LINES = 200;
+var MAX_INDEX_BYTES = 25e3;
+
+// src/memory-store.ts
+var MEMORY_TYPES = ["user", "feedback", "project", "reference"];
+function sanitizeMemorySlug(rawSlug) {
+  const cleaned = rawSlug.replace(/[\x00-\x1f\x7f]/g, "").replace(/[/\\]/g, "").replace(/[[\]()]/g, "").trim().replace(/^\.+/, "").trim();
+  return cleaned.length > 0 ? cleaned : null;
+}
+function lastSlugSegment(raw) {
+  return raw.split(/[/\\]/).pop() ?? "";
+}
+function memoryFileForSlug(dir, raw) {
+  const cleanSlug = sanitizeMemorySlug(lastSlugSegment(raw.trim()));
+  if (!cleanSlug) return { error: "Invalid memory slug." };
+  const filename = cleanSlug.toLowerCase().endsWith(".md") ? cleanSlug : `${cleanSlug}.md`;
+  if (filename.toLowerCase() === INDEX_FILE.toLowerCase()) {
+    return { error: "Target filename cannot be the index file." };
+  }
+  const target = join(dir, filename);
+  const rel = relative(dir, target);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    return { error: "Target path must stay inside the project memory directory." };
+  }
+  return { filename, target };
+}
+function memoryWriteScope(config) {
+  const memory = config.settings?.memory;
+  if (memory && (memory.enabled === false || memory.autoSave === false)) return "none";
+  return config.sessionDriver === "agent" ? "learnings" : "full";
+}
+var INDEX_FILE = "MEMORY.md";
+var INBOX_DIR = ".inbox";
+var DISCARDED_DIR = "discarded";
+function slugifyWorkspace(workspace) {
+  return workspace.replace(/[/\\:]+/g, "-").replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "workspace";
+}
+function bookRoot(opts) {
+  return opts?.bookRoot ?? resolveBookHome();
+}
+var log = createDebugLogger("memory-store");
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function canonicalPath(path) {
+  const absolute = resolve(path);
+  try {
+    return realpathSync(absolute);
+  } catch {
+    return absolute;
+  }
+}
+function lstatIfPresent(path) {
+  try {
+    return lstatSync(path);
+  } catch (e) {
+    if (errorCode(e) === "ENOENT" || errorCode(e) === "ENOTDIR") return null;
+    throw e;
+  }
+}
+function statIfPresent(path) {
+  try {
+    return statSync(path);
+  } catch (e) {
+    if (errorCode(e) === "ENOENT" || errorCode(e) === "ENOTDIR") return null;
+    throw e;
+  }
+}
+var MAX_POINTER_FILE_BYTES = 64 * 1024;
+function readPointerFile(path, reachesUnc) {
+  if (reachesUnc(path)) return void 0;
+  let fd;
+  try {
+    fd = openSync(path, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+  } catch (e) {
+    const code = errorCode(e);
+    if (code === "ENOENT" || code === "ENOTDIR" || code === "EISDIR") return void 0;
+    throw e;
+  }
+  try {
+    if (!fstatSync(fd).isFile()) return void 0;
+    const buffer = Buffer.alloc(MAX_POINTER_FILE_BYTES + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const n = readSync(fd, buffer, length, buffer.length - length, null);
+      if (n === 0) break;
+      length += n;
+    }
+    if (length > MAX_POINTER_FILE_BYTES) throw new Error(`not a git pointer file: ${path}`);
+    return buffer.toString("utf-8", 0, length).split(/\r?\n/, 1)[0].trim();
+  } finally {
+    closeSync(fd);
+  }
+}
+function gitRootMarkedBy(dir, reachesUnc) {
+  const dotGit = join(dir, ".git");
+  if (reachesUnc(dotGit)) throw new Error(`.git on a UNC path: ${dotGit}`);
+  const st = statIfPresent(dotGit);
+  if (!st) return void 0;
+  if (st.isDirectory()) return dir;
+  if (!st.isFile()) return void 0;
+  const pointer = /^gitdir:[ \t]*(\S.*)$/.exec(readPointerFile(dotGit, reachesUnc) ?? "");
+  if (!pointer) throw new Error(`unrecognized .git file: ${dotGit}`);
+  const gitDir = resolve(dir, pointer[1]);
+  if (reachesUnc(gitDir)) return dir;
+  const commonDir = readPointerFile(join(gitDir, "commondir"), reachesUnc);
+  if (commonDir === void 0) return dir;
+  const commonPath = resolve(gitDir, commonDir);
+  if (reachesUnc(commonPath)) return dir;
+  const common = canonicalPath(commonPath);
+  return basename(common) === ".git" && isListedWorktree(dir, gitDir, common, reachesUnc) ? dirname(common) : dir;
+}
+function comparablePath(path) {
+  return tryRealPath(path) ?? resolve(path);
+}
+function samePath(a, b) {
+  return relative(comparablePath(a), comparablePath(b)) === "";
+}
+function isListedWorktree(dir, gitDir, common, reachesUnc) {
+  const entry = comparablePath(gitDir);
+  if (!samePath(dirname(entry), join(common, "worktrees"))) return false;
+  const listing = join(entry, "gitdir");
+  try {
+    const backPointer = readPointerFile(listing, reachesUnc);
+    if (!backPointer) return false;
+    const target = resolve(entry, backPointer);
+    if (basename(target) !== ".git" || !samePath(dirname(target), dir)) return false;
+    return lstatSync(join(dir, ".git")).uid === statSync(listing).uid;
+  } catch {
+    return false;
+  }
+}
+function findGitRoot(workspace) {
+  const reachesUnc = createUncGuard();
+  if (reachesUnc(workspace)) return resolve(workspace);
+  const resolved = canonicalPath(workspace);
+  try {
+    for (let dir = resolved; ; ) {
+      const root = gitRootMarkedBy(dir, reachesUnc);
+      if (root !== void 0) {
+        return isUserHome(tryRealPath(dir) ?? dir, void 0) ? resolved : root;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) return resolved;
+      dir = parent;
+    }
+  } catch {
+    return resolved;
+  }
+}
+function memoryDirIn(root, workspaceKey) {
+  return join(root, "projects", slugifyWorkspace(workspaceKey), "memory");
+}
+function getProjectMemoryDir(workspace, opts) {
+  return memoryDirIn(bookRoot(opts), findGitRoot(workspace));
+}
+function moveFileNoClobber(src, dst) {
+  try {
+    linkSync(src, dst);
+  } catch (e) {
+    if (errorCode(e) === "EEXIST") return "exists";
+    if (errorCode(e) === "ENOENT" && !lstatIfPresent(src)) return "gone";
+    try {
+      copyFileSync(src, dst, constants.COPYFILE_EXCL);
+    } catch (copyError) {
+      if (errorCode(copyError) === "EEXIST") return "exists";
+      if (errorCode(copyError) === "ENOENT" && !lstatIfPresent(src)) return "gone";
+      throw copyError;
+    }
+  }
+  try {
+    unlinkSync(src);
+  } catch (e) {
+    if (errorCode(e) !== "ENOENT") throw e;
+  }
+  return "moved";
+}
+function moveKeepingBoth(sourceDir, targetDir, name) {
+  const stem = name.slice(0, -".md".length);
+  for (let n = 1; n <= 1e3; n++) {
+    const candidate = n === 1 ? name : `${stem}-${n}.md`;
+    const outcome = moveFileNoClobber(join(sourceDir, name), join(targetDir, candidate));
+    if (outcome === "moved") return candidate;
+    if (outcome === "gone") return null;
+  }
+  throw new Error(`too many name collisions moving ${name}`);
+}
+function ensureRealDir(path) {
+  const st = lstatIfPresent(path);
+  if (!st) {
+    mkdirSync(path, { recursive: true });
+    return true;
+  }
+  return st.isDirectory();
+}
+function isMemoryTopicFile(name) {
+  const lower = name.toLowerCase();
+  return lower.endsWith(".md") && lower !== INDEX_FILE.toLowerCase();
+}
+function regularMarkdownFiles(dir, accept) {
+  const st = lstatIfPresent(dir);
+  if (!st?.isDirectory()) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && accept(entry.name)).map((entry) => entry.name).sort();
+}
+function mergeLegacyIndex(oldDir, newDir, renamed) {
+  const oldIndex = join(oldDir, INDEX_FILE);
+  if (!lstatIfPresent(oldIndex)?.isFile()) return;
+  const newIndexStat = lstatIfPresent(join(newDir, INDEX_FILE));
+  if (newIndexStat && !newIndexStat.isFile()) return;
+  let oldText;
+  try {
+    oldText = readFileSync(oldIndex, "utf-8");
+  } catch (e) {
+    if (errorCode(e) === "ENOENT") return;
+    throw e;
+  }
+  const lines = readIndexLines(newDir);
+  const listed = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const file = indexEntryFile(line);
+    if (file) listed.add(file.toLowerCase());
+  }
+  const additions = [];
+  for (const line of oldText.split("\n")) {
+    const file = indexEntryFile(line);
+    if (!file) continue;
+    const target = renamed.get(file) ?? file;
+    if (listed.has(target.toLowerCase())) continue;
+    listed.add(target.toLowerCase());
+    additions.push(target === file ? line : line.replace(`](${file})`, `](${target})`));
+  }
+  if (additions.length > 0) {
+    const merged = lines.length === 0 ? ["# Book memory index", ...additions] : lines[0].startsWith("#") ? [lines[0], ...additions, ...lines.slice(1)] : [...additions, ...lines];
+    writeIndexLines(newDir, merged);
+  }
+  try {
+    unlinkSync(oldIndex);
+  } catch (e) {
+    if (errorCode(e) !== "ENOENT") throw e;
+  }
+}
+function mergeLegacyMemoryDir(oldDir, newDir) {
+  const renamed = /* @__PURE__ */ new Map();
+  for (const name of regularMarkdownFiles(oldDir, isMemoryTopicFile)) {
+    const final = moveKeepingBoth(oldDir, newDir, name);
+    if (final && final !== name) renamed.set(name, final);
+  }
+  for (const sub of [INBOX_DIR, join(INBOX_DIR, DISCARDED_DIR)]) {
+    const files = regularMarkdownFiles(
+      join(oldDir, sub),
+      (name) => name.toLowerCase().endsWith(".md")
+    );
+    if (files.length === 0) continue;
+    const targetDir = join(newDir, sub);
+    if (!ensureRealDir(join(newDir, INBOX_DIR)) || !ensureRealDir(targetDir)) continue;
+    for (const name of files) moveKeepingBoth(join(oldDir, sub), targetDir, name);
+  }
+  mergeLegacyIndex(oldDir, newDir, renamed);
+  for (const leftover of [
+    join(oldDir, INBOX_DIR, DISCARDED_DIR),
+    join(oldDir, INBOX_DIR),
+    oldDir
+  ]) {
+    try {
+      if (lstatIfPresent(leftover)?.isDirectory()) rmdirSync(leftover);
+    } catch {
+    }
+  }
+}
+function removeEmptyLegacyProjectDir(projectDir) {
+  try {
+    if (lstatIfPresent(projectDir)?.isDirectory()) rmdirSync(projectDir);
+  } catch {
+  }
+}
+function migrateLegacyMemoryDir(workspace, opts) {
+  try {
+    const legacySlug = slugifyWorkspace(workspace);
+    if (legacySlug === "." || legacySlug === "..") return;
+    const oldDir = memoryDirIn(bookRoot(opts), workspace);
+    const newDir = getProjectMemoryDir(workspace, opts);
+    if (oldDir === newDir) return;
+    if (!lstatIfPresent(oldDir)?.isDirectory()) return;
+    if (!lstatIfPresent(newDir)) {
+      mkdirSync(dirname(newDir), { recursive: true });
+      try {
+        renameSync(oldDir, newDir);
+        removeEmptyLegacyProjectDir(dirname(oldDir));
+        return;
+      } catch (e) {
+        const code = errorCode(e);
+        if (code === "ENOENT" && !lstatIfPresent(oldDir)) return;
+        if (code !== "EEXIST" && code !== "ENOTEMPTY" && code !== "ENOENT") throw e;
+      }
+    }
+    if (!lstatIfPresent(newDir)?.isDirectory()) return;
+    mergeLegacyMemoryDir(oldDir, newDir);
+    removeEmptyLegacyProjectDir(dirname(oldDir));
+  } catch (e) {
+    log.warn("memory move from the old directory failed", e);
+  }
+}
+var FORMAT_FILE = ".format";
+var FORMAT_VERSION = "2";
+var BACKUP_PREFIX = "memory.legacy-";
+var BACKUP_NAME = /^memory\.legacy-(\d{8})(?:-(\d+))?$/;
+var SLUG_MAX = 60;
+var DESCRIPTION_MAX = 150;
+var INDEX_LINE_MAX = 200;
+var TITLE_MAX = 120;
+var DROPPED_STATUSES = /* @__PURE__ */ new Set(["superseded", "pending", "discarded"]);
+var isLegacyLeftover = (name) => name === INBOX_DIR || /^\.extraction[-.]/.test(name);
+function parseLegacyFile(text) {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  if (lines[0].trim() !== "---") return null;
+  const close = lines.indexOf("---", 1);
+  if (close < 0) return null;
+  const keys = /* @__PURE__ */ new Map();
+  const extra = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const line of lines.slice(1, close)) {
+    const key = /^([A-Za-z][\w-]*)[ \t]*:[ \t]*(.*)$/.exec(line);
+    if (key) {
+      current = key[1];
+      keys.set(current, key[2].trim());
+      extra.set(current, []);
+    } else if (current && line.trim() !== "" && !line.startsWith("#")) {
+      extra.get(current)?.push(line);
+    }
+  }
+  return { keys, extra, body: lines.slice(close + 1).join("\n") };
+}
+var unquote = (value) => value.replace(/^(["'])(.*)\1$/, "$2").trim();
+var stripControls = (text) => text.replace(/[\x00-\x1f\x7f]/g, "").trim();
+function shortenAtWord(text, max) {
+  if (text.length <= max) return text;
+  if (max < 1) return "";
+  let end = max - 1;
+  for (; ; ) {
+    const atBoundary = end === 0 || /\s/.test(text[end]) || /\s/.test(text[end - 1]);
+    if (!atBoundary) {
+      end = Math.max(0, text.slice(0, end).search(/\s\S*$/));
+      continue;
+    }
+    const ticks = text.slice(0, end).split("`").length - 1;
+    if (ticks % 2 === 1) {
+      end = text.lastIndexOf("`", end - 1);
+      continue;
+    }
+    break;
+  }
+  const kept = text.slice(0, end).trimEnd();
+  return `${kept}\u2026`;
+}
+function yamlValue(value) {
+  const risky = value === "" || /^[\s\-?:,[\]{}#&*!|>'"%@`]/.test(value) || /:(\s|$)|\s#|\s$/.test(value) || /^(?:true|false|null|yes|no|on|off|~|[-+]?[\d.]+)$/i.test(value);
+  return risky ? JSON.stringify(value) : value;
+}
+function capSlug(slug, max) {
+  if (slug.length <= max) return slug;
+  const cut = slug.slice(0, max);
+  const whole = slug[max] === "-" ? cut : cut.slice(0, Math.max(cut.lastIndexOf("-"), 0) || max);
+  return whole.replace(/-+$/, "");
+}
+function kebabSlug(text) {
+  return capSlug(
+    text.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""),
+    SLUG_MAX
+  );
+}
+function titleFromLegacyName(name) {
+  return name.replace(/\.md$/i, "").replace(/^\d{4}-\d{2}-\d{2}-/, "").replace(/^(?:user|feedback|project|reference)-/, "").replace(/-(?=[a-f]*\d)[0-9a-f]{6,12}$/, "").replace(/-+/g, " ").trim();
+}
+var OLD_ENTRY_TAIL = /^\s*—\s*[^—]*?\s*—\s*\d{4}-\d{2}-\d{2}(?:\s*—\s*(.*))?$/;
+function parseIndexEntry(line) {
+  const entry = /^- \[[^\]]*\]\(([^()]+)\)(.*)$/.exec(line);
+  if (!entry) return null;
+  const target = entry[1].replace(/^\.\//, "").toLowerCase();
+  const old = OLD_ENTRY_TAIL.exec(entry[2]);
+  if (old) return { target, hook: old[1] ?? "", old: true };
+  return { target, hook: entry[2].replace(/^\s*—\s*/, ""), old: false };
+}
+function indexLine(title, file, description) {
+  const plain = title.replace(/[[\]()]/g, "").trim() || file;
+  const linkCost = 6 + file.length;
+  let shown = shortenAtWord(plain, Math.min(TITLE_MAX, INDEX_LINE_MAX - linkCost));
+  if (shown === "\u2026") shown = file;
+  const head = `- [${shown}](${file})`;
+  const room = INDEX_LINE_MAX - head.length - 3;
+  const hook = room > 1 ? shortenAtWord(description, room) : "";
+  return hook && hook !== "\u2026" ? `${head} \u2014 ${hook}` : head;
+}
+function legacyModifiedMs(file, name, mtimeMs) {
+  const stamped = Date.parse(unquote(file.keys.get("updated") || file.keys.get("created") || ""));
+  if (!Number.isNaN(stamped)) return stamped;
+  const named = Date.parse(/^\d{4}-\d{2}-\d{2}/.exec(name)?.[0] ?? "");
+  return Number.isNaN(named) ? mtimeMs : named;
+}
+function convertLegacyFile(name, file, hook, slug, mtimeMs) {
+  const lines = file.body.split("\n");
+  let start = 0;
+  while (start < lines.length && lines[start].trim() === "") start++;
+  let heading;
+  if (start < lines.length && /^#\s+\S/.test(lines[start])) {
+    heading = lines[start].replace(/^#\s+/, "").replace(/^Candidate:\s*/i, "").trim();
+    start++;
+  }
+  const body = lines.slice(start).join("\n").replace(/^(?:[ \t]*\n)+/, "").trimEnd();
+  const title = heading || titleFromLegacyName(name) || "Memory";
+  const firstLine = body.split("\n").find((line) => line.trim() !== "") ?? "";
+  const description = shortenAtWord(
+    stripControls(hook ?? "") || stripControls(firstLine) || stripControls(title),
+    DESCRIPTION_MAX
+  );
+  const finalSlug = slug(title);
+  const value = (key) => unquote(file.keys.get(key) ?? "");
+  const meta = [];
+  if (value("type")) meta.push(`  type: ${yamlValue(value("type"))}`);
+  if (value("sessionId")) meta.push(`  originSessionId: ${yamlValue(value("sessionId"))}`);
+  const modified = value("updated") || value("created");
+  if (modified) meta.push(`  modified: ${yamlValue(modified)}`);
+  if (value("driver") === "agent") meta.push("  driver: agent");
+  const evidence = file.keys.get("evidence") ?? "";
+  const evidenceLines = file.extra.get("evidence") ?? [];
+  if (evidence !== "") {
+    meta.push(`  evidence: ${evidence}`);
+  } else if (evidenceLines.length > 0) {
+    meta.push("  evidence:");
+    for (const line of evidenceLines) {
+      const item = /^\s*-\s+(.*)$/.exec(line)?.[1]?.trim();
+      meta.push(
+        item === void 0 ? `  ${line}` : `    - ${/^(["']).*\1$/.test(item) ? item : yamlValue(item)}`
+      );
+    }
+  }
+  const content = [
+    "---",
+    `name: ${finalSlug}`,
+    `description: ${yamlValue(description)}`,
+    ...meta.length > 0 ? ["metadata:", ...meta] : [],
+    "---",
+    ...body ? [body] : []
+  ].join("\n") + "\n";
+  return {
+    oldName: name,
+    slug: finalSlug,
+    title,
+    description,
+    content,
+    modifiedMs: legacyModifiedMs(file, name, mtimeMs)
+  };
+}
+function localDateStamp(now) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+}
+function copyTreeWithoutLinks(source, target) {
+  for (const entry of readdirSync(source, { withFileTypes: true })) {
+    const from = join(source, entry.name);
+    const to = join(target, entry.name);
+    if (entry.isDirectory()) {
+      mkdirSync(to);
+      copyTreeWithoutLinks(from, to);
+    } else if (entry.isFile()) {
+      copyFileSync(from, to, constants.COPYFILE_EXCL);
+    }
+  }
+}
+function backUpMemoryDir(dir) {
+  const stamp = localDateStamp(/* @__PURE__ */ new Date());
+  for (let n = 1; n <= 1e3; n++) {
+    const target = join(dirname(dir), `${BACKUP_PREFIX}${stamp}${n === 1 ? "" : `-${n}`}`);
+    try {
+      mkdirSync(target);
+    } catch (e) {
+      if (errorCode(e) === "EEXIST") continue;
+      throw e;
+    }
+    try {
+      copyTreeWithoutLinks(dir, target);
+      return target;
+    } catch (e) {
+      rmSync(target, { recursive: true, force: true });
+      throw e;
+    }
+  }
+  throw new Error("too many memory backups for one day");
+}
+function findLegacyMemoryBackup(dir) {
+  try {
+    const found = readdirSync(dirname(dir), { withFileTypes: true }).filter((entry) => entry.isDirectory() && BACKUP_NAME.test(entry.name)).map((entry) => {
+      const [, date, n] = BACKUP_NAME.exec(entry.name) ?? [];
+      return { name: entry.name, date, n: Number(n ?? 1) };
+    }).sort((a, b) => a.date.localeCompare(b.date) || a.n - b.n);
+    const newest = found.at(-1);
+    return newest ? join(dirname(dir), newest.name) : null;
+  } catch {
+    return null;
+  }
+}
+function legacyBackupNotice(backup) {
+  return `Migrated to the new memory format; the old files are in ${backup}.`;
+}
+function migratedIndexLines(oldText, converted, droppedNames) {
+  const byTarget = new Map(converted.map((c) => [`${c.slug}.md`, c]));
+  for (const c of converted) byTarget.set(c.oldName.toLowerCase(), c);
+  const kept = [];
+  const ordered = [];
+  for (const raw of oldText?.split("\n") ?? []) {
+    const line = raw.replace(/\r$/, "");
+    if (/^#\s*Book memory index\s*$/i.test(line)) continue;
+    const entry = parseIndexEntry(line);
+    if (!entry) {
+      kept.push(line);
+      continue;
+    }
+    const match = byTarget.get(entry.target);
+    if (match) {
+      if (!ordered.includes(match)) ordered.push(match);
+    } else if (!droppedNames.has(entry.target) && !entry.old) {
+      kept.push(line);
+    }
+  }
+  const missing = converted.filter((c) => !ordered.includes(c)).sort((a, b) => b.modifiedMs - a.modifiedMs || b.oldName.localeCompare(a.oldName));
+  const tidy = [];
+  for (const line of kept) {
+    if (line.trim() === "" && (tidy.length === 0 || tidy[tidy.length - 1].trim() === "")) continue;
+    tidy.push(line);
+  }
+  while (tidy.length > 0 && tidy[tidy.length - 1].trim() === "") tidy.pop();
+  return [
+    ...tidy,
+    ...[...ordered, ...missing].map((c) => indexLine(c.title, `${c.slug}.md`, c.description))
+  ];
+}
+function migrateFormat(dir) {
+  if (!lstatIfPresent(dir)?.isDirectory()) return;
+  const marker = join(dir, FORMAT_FILE);
+  if (lstatIfPresent(marker)?.isFile() && readFileSync(marker, "utf-8").trim() === FORMAT_VERSION) {
+    return;
+  }
+  const everything = readdirSync(dir, { withFileTypes: true });
+  const entries = everything.filter((e) => !e.isSymbolicLink());
+  const leftovers = entries.filter((e) => isLegacyLeftover(e.name)).map((e) => e.name);
+  const legacy = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || entry.name.startsWith(".") || !isMemoryTopicFile(entry.name)) continue;
+    const path = join(dir, entry.name);
+    const file = parseLegacyFile(readFileSync(path, "utf-8"));
+    if (file && (file.keys.has("status") || file.keys.has("type"))) {
+      legacy.push({ name: entry.name, file, mtimeMs: statSync(path).mtimeMs });
+    }
+  }
+  if (legacy.length === 0 && leftovers.length === 0) {
+    writeFileAtomic(marker, `${FORMAT_VERSION}
+`);
+    return;
+  }
+  const indexPath = join(dir, INDEX_FILE);
+  const indexStat = lstatIfPresent(indexPath);
+  const oldIndex = indexStat?.isFile() ? readFileSync(indexPath, "utf-8") : null;
+  const hooks = /* @__PURE__ */ new Map();
+  for (const line of oldIndex?.split("\n") ?? []) {
+    const entry = parseIndexEntry(line.replace(/\r$/, ""));
+    if (entry && !hooks.has(entry.target)) hooks.set(entry.target, entry.hook);
+  }
+  const backup = backUpMemoryDir(dir);
+  log.info(`memory backed up to ${backup}`);
+  const taken = new Set(everything.map((e) => e.name.toLowerCase()));
+  taken.add(INDEX_FILE.toLowerCase());
+  const converted = [];
+  const dropped = /* @__PURE__ */ new Set();
+  for (const { name, file, mtimeMs } of legacy.sort((a, b) => a.name.localeCompare(b.name))) {
+    const status = unquote(file.keys.get("status") ?? "").toLowerCase();
+    if (DROPPED_STATUSES.has(status)) {
+      dropped.add(name.toLowerCase());
+      continue;
+    }
+    const own = name.toLowerCase();
+    const claim = (title) => {
+      const base = kebabSlug(title) || kebabSlug(titleFromLegacyName(name)) || kebabSlug(unquote(file.keys.get("type") ?? "")) || "memory";
+      for (let n = 1; ; n++) {
+        const suffix = n === 1 ? "" : `-${n}`;
+        const slug = `${capSlug(base, SLUG_MAX - suffix.length)}${suffix}`;
+        const lower = `${slug}.md`;
+        if (!taken.has(lower) || lower === own) {
+          taken.add(lower);
+          return slug;
+        }
+      }
+    };
+    converted.push(convertLegacyFile(name, file, hooks.get(own) || void 0, claim, mtimeMs));
+  }
+  for (const c of converted) {
+    writeFileAtomic(join(dir, `${c.slug}.md`), c.content);
+    if (`${c.slug}.md` !== c.oldName) unlinkSync(join(dir, c.oldName));
+  }
+  for (const name of dropped) {
+    const original = legacy.find((l) => l.name.toLowerCase() === name)?.name;
+    if (original) unlinkSync(join(dir, original));
+  }
+  for (const name of leftovers) rmSync(join(dir, name), { recursive: true, force: true });
+  if (indexStat === null || indexStat.isFile()) {
+    const lines = migratedIndexLines(oldIndex, converted, dropped);
+    if (oldIndex !== null || lines.length > 0) {
+      writeFileAtomic(indexPath, lines.length > 0 ? `${lines.join("\n")}
+` : "");
+    }
+  } else {
+    log.warn("MEMORY.md is not a regular file; it was left as it is");
+  }
+  writeFileAtomic(marker, `${FORMAT_VERSION}
+`);
+}
+function migrateLegacyMemoryFormat(dir) {
+  try {
+    migrateFormat(dir);
+  } catch (e) {
+    log.warn("memory format migration failed", e);
+  }
+}
+function isMemoryType(value) {
+  return typeof value === "string" && MEMORY_TYPES.includes(value);
+}
+function titleFromBody(body) {
+  const firstHeading = body.split("\n").find((line) => line.startsWith("# "));
+  return firstHeading?.replace(/^#\s+/, "").trim();
+}
+function summarizeMemoryFile(path, name = basename(path)) {
+  try {
+    const st = statSync(path);
+    if (!st.isFile()) return null;
+    const { body, frontmatter } = parseFrontmatter(readFileSync(path, "utf-8"));
+    const title = typeof frontmatter.title === "string" && frontmatter.title || titleFromBody(body) || typeof frontmatter.name === "string" && frontmatter.name || void 0;
+    return {
+      name,
+      path,
+      type: isMemoryType(frontmatter.type) ? frontmatter.type : void 0,
+      title,
+      ...typeof frontmatter.description === "string" && frontmatter.description.trim() ? { description: frontmatter.description.trim() } : {},
+      size: st.size,
+      ...frontmatter.driver === "agent" ? { driver: "agent" } : {},
+      ...frontmatter.status === "superseded" ? { legacySuperseded: true } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function listMemoryFiles(workspace, opts) {
+  const dir = getProjectMemoryDir(workspace, opts);
+  if (!existsSync(dir)) return [];
+  const files = [];
+  try {
+    for (const entry of readdirSync(dir).sort()) {
+      if (entry.startsWith(".") || !isMemoryTopicFile(entry)) continue;
+      const summary = summarizeMemoryFile(join(dir, entry), entry);
+      if (summary) files.push(summary);
+    }
+  } catch {
+    return files;
+  }
+  return files;
+}
+var formatCount = (n) => n.toLocaleString("en-US");
+function countNonEmptyLines(text) {
+  return text.split("\n").filter((line) => line.trim().length > 0).length;
+}
+function cutIndex(raw, maxLines) {
+  const trimmed = raw.trim();
+  const byteCount = Buffer.byteLength(trimmed);
+  const lines = trimmed.length > 0 ? trimmed.split("\n") : [];
+  const wasLineTruncated = lines.length > maxLines;
+  let kept = wasLineTruncated ? lines.slice(0, maxLines).join("\n") : trimmed;
+  let keptLineCount = Math.min(lines.length, maxLines);
+  let wasByteTruncated = false;
+  let bytesKeptOfLine1;
+  if (Buffer.byteLength(kept) > MAX_INDEX_BYTES) {
+    wasByteTruncated = true;
+    const bytes = Buffer.from(kept, "utf-8");
+    const newline = bytes.lastIndexOf(10, MAX_INDEX_BYTES);
+    if (newline > 0) {
+      kept = bytes.subarray(0, newline).toString("utf-8");
+      keptLineCount = kept.split("\n").length;
+    } else {
+      let end = MAX_INDEX_BYTES;
+      while (end > 0 && (bytes[end] & 192) === 128) end--;
+      kept = bytes.subarray(0, end).toString("utf-8");
+      keptLineCount = 1;
+      bytesKeptOfLine1 = end;
+    }
+  }
+  let text = kept;
+  if (wasLineTruncated || wasByteTruncated) {
+    const detail = bytesKeptOfLine1 !== void 0 ? `everything after the first ${formatCount(bytesKeptOfLine1)} bytes of line 1 was cut off` : `${formatCount(lines.length - keptLineCount)} of ${formatCount(lines.length)} lines were cut off, starting at line ${formatCount(keptLineCount + 1)} ("${Array.from(lines[keptLineCount]).slice(0, 80).join("")}")`;
+    text = `${kept}
+
+> WARNING: MEMORY.md is ${formatCount(lines.length)} lines and ${formatCount(byteCount)} bytes (limits: ${formatCount(maxLines)} lines, ${formatCount(MAX_INDEX_BYTES)} bytes). Only part of it was loaded: ${detail}. Keep each entry to one line and move detail into the memory file.`;
+  }
+  return {
+    text,
+    totalLines: countNonEmptyLines(trimmed),
+    loadedLines: countNonEmptyLines(kept),
+    byteCount,
+    wasLineTruncated,
+    wasByteTruncated
+  };
+}
+function loadMemoryContext(workspace, opts) {
+  migrateLegacyMemoryDir(workspace, opts);
+  const dir = getProjectMemoryDir(workspace, opts);
+  migrateLegacyMemoryFormat(dir);
+  const maxIndexLines = opts?.maxIndexLines ?? DEFAULT_MAX_INDEX_LINES;
+  const result = {
+    dir,
+    indexFile: null,
+    indexLoaded: false,
+    indexLineCount: 0,
+    loadedLineCount: 0,
+    indexByteCount: 0,
+    wasLineTruncated: false,
+    wasByteTruncated: false,
+    indexText: "",
+    files: []
+  };
+  if (!existsSync(dir)) return result;
+  const indexFile = join(dir, INDEX_FILE);
+  if (existsSync(indexFile)) {
+    try {
+      const st = statSync(indexFile);
+      if (st.isFile()) {
+        const index = cutIndex(readFileSync(indexFile, "utf-8"), maxIndexLines);
+        result.indexFile = indexFile;
+        result.indexLoaded = index.text.length > 0;
+        result.indexLineCount = index.totalLines;
+        result.loadedLineCount = index.loadedLines;
+        result.indexByteCount = index.byteCount;
+        result.wasLineTruncated = index.wasLineTruncated;
+        result.wasByteTruncated = index.wasByteTruncated;
+        result.indexText = index.text;
+      }
+    } catch {
+      result.indexFile = indexFile;
+    }
+  }
+  result.files = listMemoryFiles(workspace, opts);
+  return result;
+}
+function getNewestMemoryWriteTime(memoryDir) {
+  if (!existsSync(memoryDir)) return null;
+  let newestMs = 0;
+  let entries;
+  try {
+    entries = readdirSync(memoryDir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    try {
+      const st = lstatSync(join(memoryDir, entry));
+      if (st.isSymbolicLink() || !st.isFile()) continue;
+      if (st.mtimeMs > newestMs) newestMs = st.mtimeMs;
+    } catch {
+    }
+  }
+  return newestMs > 0 ? new Date(newestMs) : null;
+}
+function getMemoryHealth(workspaceOrContext, opts) {
+  const dir = typeof workspaceOrContext === "string" ? getProjectMemoryDir(workspaceOrContext, opts) : workspaceOrContext.dir;
+  let fileCount = 0;
+  let legacySupersededCount = 0;
+  if (existsSync(dir)) {
+    try {
+      for (const entry of readdirSync(dir)) {
+        if (entry.startsWith(".") || !isMemoryTopicFile(entry)) continue;
+        const full = join(dir, entry);
+        try {
+          const st = lstatSync(full);
+          if (st.isSymbolicLink() || !st.isFile()) continue;
+          const summary = summarizeMemoryFile(full, entry);
+          if (!summary) continue;
+          fileCount++;
+          if (summary.legacySuperseded) legacySupersededCount++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  let indexLineCount = 0;
+  let indexByteCount = 0;
+  let wasLineTruncated = false;
+  let wasByteTruncated = false;
+  try {
+    indexLineCount = readIndexLines(dir).length;
+    const indexPath = join(dir, INDEX_FILE);
+    if (existsSync(indexPath)) {
+      const cut = cutIndex(
+        readFileSync(indexPath, "utf-8"),
+        opts?.maxIndexLines ?? DEFAULT_MAX_INDEX_LINES
+      );
+      indexByteCount = cut.byteCount;
+      wasLineTruncated = cut.wasLineTruncated;
+      wasByteTruncated = cut.wasByteTruncated;
+    }
+  } catch {
+  }
+  return {
+    fileCount,
+    legacySupersededCount,
+    indexLineCount,
+    indexByteCount,
+    wasLineTruncated,
+    wasByteTruncated,
+    lastWrite: getNewestMemoryWriteTime(dir)
+  };
+}
+function indexEntryFile(line) {
+  return /^- \[[^\]]*\]\(([^()]+)\)/.exec(line)?.[1];
+}
+function readIndexLines(dir) {
+  const indexPath = join(dir, INDEX_FILE);
+  if (!existsSync(indexPath)) return [];
+  return readFileSync(indexPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+}
+function writeIndexLines(dir, lines) {
+  writeFileAtomic(
+    join(dir, INDEX_FILE),
+    lines.length > 0 ? lines.join("\n") + "\n" : "# Book memory index\n"
+  );
+}
+function removeIndexEntries(dir, filename) {
+  const indexPath = join(dir, INDEX_FILE);
+  if (!lstatIfPresent(indexPath)?.isFile()) return;
+  const raw = readFileSync(indexPath, "utf-8");
+  const target = filename.toLowerCase();
+  const lines = raw.split("\n");
+  const kept = lines.filter((line) => {
+    const file = indexEntryFile(line);
+    return file === void 0 || file.replace(/^\.\//, "").toLowerCase() !== target;
+  });
+  if (kept.length !== lines.length) writeFileAtomic(indexPath, kept.join("\n"));
+}
+function deleteMemoryEntry(workspace, slug, opts) {
+  try {
+    const dir = getProjectMemoryDir(workspace, opts);
+    const named = memoryFileForSlug(dir, slug);
+    if ("error" in named) return { ok: false, error: named.error };
+    const { filename, target } = named;
+    if (!lstatIfPresent(target)) {
+      return { ok: false, error: `Memory file not found: ${filename}` };
+    }
+    if (lstatSync(target).isSymbolicLink()) {
+      return { ok: false, error: "Refusing to delete symlinked file." };
+    }
+    unlinkSync(target);
+    try {
+      removeIndexEntries(dir, filename);
+    } catch {
+    }
+    return { ok: true, path: target };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+export {
+  DEFAULT_MAX_INDEX_LINES,
+  MAX_INDEX_BYTES,
+  sanitizeMemorySlug,
+  memoryFileForSlug,
+  memoryWriteScope,
+  slugifyWorkspace,
+  findGitRoot,
+  getProjectMemoryDir,
+  migrateLegacyMemoryDir,
+  shortenAtWord,
+  findLegacyMemoryBackup,
+  legacyBackupNotice,
+  migrateLegacyMemoryFormat,
+  listMemoryFiles,
+  loadMemoryContext,
+  getNewestMemoryWriteTime,
+  getMemoryHealth,
+  deleteMemoryEntry
+};
+//# sourceMappingURL=chunk-EFXVSQ5J.js.map