minimem 0.0.4 → 0.0.6

package/dist/internal.cjs

@@ -0,0 +1,286 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  buildFileEntry: () => buildFileEntry,
+  chunkMarkdown: () => chunkMarkdown,
+  cosineSimilarity: () => cosineSimilarity,
+  ensureDir: () => ensureDir,
+  extractChunkMetadata: () => extractChunkMetadata,
+  hashText: () => hashText,
+  isMemoryPath: () => isMemoryPath,
+  listMemoryFiles: () => listMemoryFiles,
+  logError: () => logError,
+  normalizeRelPath: () => normalizeRelPath,
+  parseEmbedding: () => parseEmbedding,
+  stripPrivateContent: () => stripPrivateContent,
+  truncateUtf16Safe: () => truncateUtf16Safe,
+  vectorToBlob: () => vectorToBlob
+});
+module.exports = __toCommonJS(internal_exports);
+var import_node_crypto = __toESM(require("crypto"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+function logError(context, error, debug) {
+  if (!debug) return;
+  const message = error instanceof Error ? error.message : String(error);
+  debug(`[${context}] Error: ${message}`);
+}
+function ensureDir(dir, debug) {
+  try {
+    import_node_fs.default.mkdirSync(dir, { recursive: true });
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code !== "EEXIST") {
+      logError("ensureDir", error, debug);
+    }
+  }
+  return dir;
+}
+function normalizeRelPath(value) {
+  const trimmed = value.trim().replace(/^[./]+/, "");
+  return trimmed.replace(/\\/g, "/");
+}
+function isMemoryPath(relPath) {
+  const normalized = normalizeRelPath(relPath);
+  if (!normalized) return false;
+  if (normalized === "MEMORY.md" || normalized === "memory.md") return true;
+  return normalized.startsWith("memory/");
+}
+async function exists(filePath) {
+  try {
+    await import_promises.default.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function walkDir(dir, files) {
+  const entries = await import_promises.default.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = import_node_path.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDir(full, files);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith(".md")) continue;
+    files.push(full);
+  }
+}
+async function listMemoryFiles(memoryDir) {
+  const result = [];
+  const memoryFile = import_node_path.default.join(memoryDir, "MEMORY.md");
+  const altMemoryFile = import_node_path.default.join(memoryDir, "memory.md");
+  const hasUpper = await exists(memoryFile);
+  const hasLower = await exists(altMemoryFile);
+  if (hasUpper && hasLower) {
+    let upperReal = memoryFile;
+    let lowerReal = altMemoryFile;
+    try {
+      upperReal = await import_promises.default.realpath(memoryFile);
+    } catch {
+    }
+    try {
+      lowerReal = await import_promises.default.realpath(altMemoryFile);
+    } catch {
+    }
+    if (upperReal !== lowerReal) {
+      throw new Error(
+        `Both MEMORY.md and memory.md exist in ${memoryDir}. Please remove one to avoid ambiguity.`
+      );
+    }
+    result.push(memoryFile);
+  } else if (hasUpper) {
+    result.push(memoryFile);
+  } else if (hasLower) {
+    result.push(altMemoryFile);
+  }
+  const memorySubDir = import_node_path.default.join(memoryDir, "memory");
+  if (await exists(memorySubDir)) {
+    await walkDir(memorySubDir, result);
+  }
+  if (result.length <= 1) return result;
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const entry of result) {
+    let key = entry;
+    try {
+      key = await import_promises.default.realpath(entry);
+    } catch {
+    }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(entry);
+  }
+  return deduped;
+}
+function hashText(value) {
+  return import_node_crypto.default.createHash("sha256").update(value).digest("hex");
+}
+async function buildFileEntry(absPath, memoryDir) {
+  const stat = await import_promises.default.stat(absPath);
+  const content = await import_promises.default.readFile(absPath, "utf-8");
+  const hash = hashText(content);
+  return {
+    path: import_node_path.default.relative(memoryDir, absPath).replace(/\\/g, "/"),
+    absPath,
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    hash
+  };
+}
+function stripPrivateContent(content) {
+  return content.replace(/<private>[\s\S]*?<\/private>/gi, (match) => {
+    const lineCount = match.split("\n").length;
+    return "\n".repeat(lineCount - 1);
+  });
+}
+function chunkMarkdown(content, chunking) {
+  const stripped = stripPrivateContent(content);
+  const lines = stripped.split("\n");
+  if (lines.length === 0) return [];
+  const maxChars = Math.max(32, chunking.tokens * 4);
+  const overlapChars = Math.max(0, chunking.overlap * 4);
+  const chunks = [];
+  let current = [];
+  let currentChars = 0;
+  const flush = () => {
+    if (current.length === 0) return;
+    const firstEntry = current[0];
+    const lastEntry = current[current.length - 1];
+    if (!firstEntry || !lastEntry) return;
+    const text = current.map((entry) => entry.line).join("\n");
+    const startLine = firstEntry.lineNo;
+    const endLine = lastEntry.lineNo;
+    chunks.push({
+      startLine,
+      endLine,
+      text,
+      hash: hashText(text)
+    });
+  };
+  const carryOverlap = () => {
+    if (overlapChars <= 0 || current.length === 0) {
+      current = [];
+      currentChars = 0;
+      return;
+    }
+    let acc = 0;
+    const kept = [];
+    for (let i = current.length - 1; i >= 0; i -= 1) {
+      const entry = current[i];
+      if (!entry) continue;
+      acc += entry.line.length + 1;
+      kept.unshift(entry);
+      if (acc >= overlapChars) break;
+    }
+    current = kept;
+    currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const lineNo = i + 1;
+    const segments = [];
+    if (line.length === 0) {
+      segments.push("");
+    } else {
+      for (let start = 0; start < line.length; start += maxChars) {
+        segments.push(line.slice(start, start + maxChars));
+      }
+    }
+    for (const segment of segments) {
+      const lineSize = segment.length + 1;
+      if (currentChars + lineSize > maxChars && current.length > 0) {
+        flush();
+        carryOverlap();
+      }
+      current.push({ line: segment, lineNo });
+      currentChars += lineSize;
+    }
+  }
+  flush();
+  return chunks;
+}
+function extractChunkMetadata(text) {
+  const typeMatch = text.match(/<!--\s*type:\s*([\w-]+)\s*-->/i);
+  return typeMatch ? { type: typeMatch[1].toLowerCase() } : {};
+}
+function parseEmbedding(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const len = Math.min(a.length, b.length);
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < len; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    dot += av * bv;
+    normA += av * av;
+    normB += bv * bv;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function truncateUtf16Safe(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars);
+}
+function vectorToBlob(embedding) {
+  return Buffer.from(new Float32Array(embedding).buffer);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFileEntry,
+  chunkMarkdown,
+  cosineSimilarity,
+  ensureDir,
+  extractChunkMetadata,
+  hashText,
+  isMemoryPath,
+  listMemoryFiles,
+  logError,
+  normalizeRelPath,
+  parseEmbedding,
+  stripPrivateContent,
+  truncateUtf16Safe,
+  vectorToBlob
+});
+//# sourceMappingURL=internal.cjs.map

package/dist/internal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal.ts"],"sourcesContent":["import crypto from \"node:crypto\";\nimport fsSync from \"node:fs\";\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\n\n/**\n * Debug function type for optional logging\n */\nexport type DebugFn = (message: string, data?: Record<string, unknown>) => void;\n\n/**\n * Log an error with context (for debugging).\n * Only logs if a debug function is provided.\n *\n * @param context - A short identifier for where the error occurred\n * @param error - The error object or message\n * @param debug - Optional debug function to log to\n */\nexport function logError(\n  context: string,\n  error: unknown,\n  debug?: DebugFn\n): void {\n  if (!debug) return;\n\n  const message = error instanceof Error ? error.message : String(error);\n  debug(`[${context}] Error: ${message}`);\n}\n\nexport type MemoryFileEntry = {\n  path: string;\n  absPath: string;\n  mtimeMs: number;\n  size: number;\n  hash: string;\n};\n\nexport type MemoryChunk = {\n  startLine: number;\n  endLine: number;\n  text: string;\n  hash: string;\n};\n\n/**\n * Ensure a directory exists, creating it if necessary.\n *\n * @param dir - The directory path to ensure exists\n * @param debug - Optional debug function for logging errors\n * @returns The directory path\n */\nexport function ensureDir(dir: string, debug?: DebugFn): string {\n  try {\n    fsSync.mkdirSync(dir, { recursive: true });\n  } catch (error) {\n    // Only swallow EEXIST errors (directory already exists)\n    // Log other errors for debugging\n    const nodeError = error as NodeJS.ErrnoException;\n    if (nodeError.code !== \"EEXIST\") {\n      logError(\"ensureDir\", error, debug);\n    }\n  }\n  return dir;\n}\n\nexport function normalizeRelPath(value: string): string {\n  const trimmed = value.trim().replace(/^[./]+/, \"\");\n  return trimmed.replace(/\\\\/g, \"/\");\n}\n\nexport function isMemoryPath(relPath: string): boolean {\n  const normalized = normalizeRelPath(relPath);\n  if (!normalized) return false;\n  if (normalized === \"MEMORY.md\" || normalized === \"memory.md\") return true;\n  return normalized.startsWith(\"memory/\");\n}\n\nasync function exists(filePath: string): Promise<boolean> {\n  try {\n    await fs.access(filePath);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function walkDir(dir: string, files: string[]) {\n  const entries = await fs.readdir(dir, { withFileTypes: true });\n  for (const entry of entries) {\n    const full = path.join(dir, entry.name);\n    if (entry.isDirectory()) {\n      await walkDir(full, files);\n      continue;\n    }\n    if (!entry.isFile()) continue;\n    if (!entry.name.endsWith(\".md\")) continue;\n    files.push(full);\n  }\n}\n\nexport async function listMemoryFiles(memoryDir: string): Promise<string[]> {\n  const result: string[] = [];\n  const memoryFile = path.join(memoryDir, \"MEMORY.md\");\n  const altMemoryFile = path.join(memoryDir, \"memory.md\");\n  const hasUpper = await exists(memoryFile);\n  const hasLower = await exists(altMemoryFile);\n\n  // Prevent ambiguity: both MEMORY.md and memory.md cannot coexist\n  // (unless they resolve to the same file on case-insensitive filesystems)\n  if (hasUpper && hasLower) {\n    let upperReal = memoryFile;\n    let lowerReal = altMemoryFile;\n    try { upperReal = await fs.realpath(memoryFile); } catch {}\n    try { lowerReal = await fs.realpath(altMemoryFile); } catch {}\n    if (upperReal !== lowerReal) {\n      throw new Error(\n        `Both MEMORY.md and memory.md exist in ${memoryDir}. ` +\n        `Please remove one to avoid ambiguity.`\n      );\n    }\n    // Same file (case-insensitive FS) — only include once\n    result.push(memoryFile);\n  } else if (hasUpper) {\n    result.push(memoryFile);\n  } else if (hasLower) {\n    result.push(altMemoryFile);\n  }\n\n  const memorySubDir = path.join(memoryDir, \"memory\");\n  if (await exists(memorySubDir)) {\n    await walkDir(memorySubDir, result);\n  }\n  if (result.length <= 1) return result;\n  const seen = new Set<string>();\n  const deduped: string[] = [];\n  for (const entry of result) {\n    let key = entry;\n    try {\n      key = await fs.realpath(entry);\n    } catch {}\n    if (seen.has(key)) continue;\n    seen.add(key);\n    deduped.push(entry);\n  }\n  return deduped;\n}\n\nexport function hashText(value: string): string {\n  return crypto.createHash(\"sha256\").update(value).digest(\"hex\");\n}\n\nexport async function buildFileEntry(\n  absPath: string,\n  memoryDir: string,\n): Promise<MemoryFileEntry> {\n  const stat = await fs.stat(absPath);\n  const content = await fs.readFile(absPath, \"utf-8\");\n  const hash = hashText(content);\n  return {\n    path: path.relative(memoryDir, absPath).replace(/\\\\/g, \"/\"),\n    absPath,\n    mtimeMs: stat.mtimeMs,\n    size: stat.size,\n    hash,\n  };\n}\n\n/**\n * Strip content between <private>...</private> tags.\n * Replaces private blocks with the same number of empty lines to preserve line numbering.\n */\nexport function stripPrivateContent(content: string): string {\n  return content.replace(/<private>[\\s\\S]*?<\\/private>/gi, (match) => {\n    const lineCount = match.split(\"\\n\").length;\n    return \"\\n\".repeat(lineCount - 1);\n  });\n}\n\nexport function chunkMarkdown(\n  content: string,\n  chunking: { tokens: number; overlap: number },\n): MemoryChunk[] {\n  const stripped = stripPrivateContent(content);\n  const lines = stripped.split(\"\\n\");\n  if (lines.length === 0) return [];\n  const maxChars = Math.max(32, chunking.tokens * 4);\n  const overlapChars = Math.max(0, chunking.overlap * 4);\n  const chunks: MemoryChunk[] = [];\n\n  let current: Array<{ line: string; lineNo: number }> = [];\n  let currentChars = 0;\n\n  const flush = () => {\n    if (current.length === 0) return;\n    const firstEntry = current[0];\n    const lastEntry = current[current.length - 1];\n    if (!firstEntry || !lastEntry) return;\n    const text = current.map((entry) => entry.line).join(\"\\n\");\n    const startLine = firstEntry.lineNo;\n    const endLine = lastEntry.lineNo;\n    chunks.push({\n      startLine,\n      endLine,\n      text,\n      hash: hashText(text),\n    });\n  };\n\n  const carryOverlap = () => {\n    if (overlapChars <= 0 || current.length === 0) {\n      current = [];\n      currentChars = 0;\n      return;\n    }\n    let acc = 0;\n    const kept: Array<{ line: string; lineNo: number }> = [];\n    for (let i = current.length - 1; i >= 0; i -= 1) {\n      const entry = current[i];\n      if (!entry) continue;\n      acc += entry.line.length + 1;\n      kept.unshift(entry);\n      if (acc >= overlapChars) break;\n    }\n    current = kept;\n    currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);\n  };\n\n  for (let i = 0; i < lines.length; i += 1) {\n    const line = lines[i] ?? \"\";\n    const lineNo = i + 1;\n    const segments: string[] = [];\n    if (line.length === 0) {\n      segments.push(\"\");\n    } else {\n      for (let start = 0; start < line.length; start += maxChars) {\n        segments.push(line.slice(start, start + maxChars));\n      }\n    }\n    for (const segment of segments) {\n      const lineSize = segment.length + 1;\n      if (currentChars + lineSize > maxChars && current.length > 0) {\n        flush();\n        carryOverlap();\n      }\n      current.push({ line: segment, lineNo });\n      currentChars += lineSize;\n    }\n  }\n  flush();\n  return chunks;\n}\n\n/**\n * Extract metadata from a chunk's text content.\n * Looks for HTML comments like <!-- type: decision --> in the chunk.\n */\nexport function extractChunkMetadata(text: string): { type?: string } {\n  const typeMatch = text.match(/<!--\\s*type:\\s*([\\w-]+)\\s*-->/i);\n  return typeMatch ? { type: typeMatch[1].toLowerCase() } : {};\n}\n\nexport function parseEmbedding(raw: string): number[] {\n  try {\n    const parsed = JSON.parse(raw) as number[];\n    return Array.isArray(parsed) ? parsed : [];\n  } catch {\n    return [];\n  }\n}\n\nexport function cosineSimilarity(a: number[], b: number[]): number {\n  if (a.length === 0 || b.length === 0) return 0;\n  const len = Math.min(a.length, b.length);\n  let dot = 0;\n  let normA = 0;\n  let normB = 0;\n  for (let i = 0; i < len; i += 1) {\n    const av = a[i] ?? 0;\n    const bv = b[i] ?? 0;\n    dot += av * bv;\n    normA += av * av;\n    normB += bv * bv;\n  }\n  if (normA === 0 || normB === 0) return 0;\n  return dot / (Math.sqrt(normA) * Math.sqrt(normB));\n}\n\nexport function truncateUtf16Safe(text: string, maxChars: number): string {\n  if (text.length <= maxChars) return text;\n  return text.slice(0, maxChars);\n}\n\n/**\n * Convert a numeric embedding vector to a Buffer suitable for sqlite-vec storage.\n * Uses Float32 encoding, which is the format expected by sqlite-vec's vector functions.\n */\nexport function vectorToBlob(embedding: number[]): Buffer {\n  return Buffer.from(new Float32Array(embedding).buffer);\n}\n"],"mappings":"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","names":["fsSync","fs","path","crypto"]}

package/dist/internal.d.cts

@@ -0,0 +1,65 @@
+/**
+ * Debug function type for optional logging
+ */
+type DebugFn = (message: string, data?: Record<string, unknown>) => void;
+/**
+ * Log an error with context (for debugging).
+ * Only logs if a debug function is provided.
+ *
+ * @param context - A short identifier for where the error occurred
+ * @param error - The error object or message
+ * @param debug - Optional debug function to log to
+ */
+declare function logError(context: string, error: unknown, debug?: DebugFn): void;
+type MemoryFileEntry = {
+    path: string;
+    absPath: string;
+    mtimeMs: number;
+    size: number;
+    hash: string;
+};
+type MemoryChunk = {
+    startLine: number;
+    endLine: number;
+    text: string;
+    hash: string;
+};
+/**
+ * Ensure a directory exists, creating it if necessary.
+ *
+ * @param dir - The directory path to ensure exists
+ * @param debug - Optional debug function for logging errors
+ * @returns The directory path
+ */
+declare function ensureDir(dir: string, debug?: DebugFn): string;
+declare function normalizeRelPath(value: string): string;
+declare function isMemoryPath(relPath: string): boolean;
+declare function listMemoryFiles(memoryDir: string): Promise<string[]>;
+declare function hashText(value: string): string;
+declare function buildFileEntry(absPath: string, memoryDir: string): Promise<MemoryFileEntry>;
+/**
+ * Strip content between <private>...</private> tags.
+ * Replaces private blocks with the same number of empty lines to preserve line numbering.
+ */
+declare function stripPrivateContent(content: string): string;
+declare function chunkMarkdown(content: string, chunking: {
+    tokens: number;
+    overlap: number;
+}): MemoryChunk[];
+/**
+ * Extract metadata from a chunk's text content.
+ * Looks for HTML comments like <!-- type: decision --> in the chunk.
+ */
+declare function extractChunkMetadata(text: string): {
+    type?: string;
+};
+declare function parseEmbedding(raw: string): number[];
+declare function cosineSimilarity(a: number[], b: number[]): number;
+declare function truncateUtf16Safe(text: string, maxChars: number): string;
+/**
+ * Convert a numeric embedding vector to a Buffer suitable for sqlite-vec storage.
+ * Uses Float32 encoding, which is the format expected by sqlite-vec's vector functions.
+ */
+declare function vectorToBlob(embedding: number[]): Buffer;
+
+export { type DebugFn, type MemoryChunk, type MemoryFileEntry, buildFileEntry, chunkMarkdown, cosineSimilarity, ensureDir, extractChunkMetadata, hashText, isMemoryPath, listMemoryFiles, logError, normalizeRelPath, parseEmbedding, stripPrivateContent, truncateUtf16Safe, vectorToBlob };

package/dist/session.cjs

@@ -0,0 +1,298 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/session.ts
+var session_exports = {};
+__export(session_exports, {
+  addFrontmatter: () => addFrontmatter,
+  addSessionToContent: () => addSessionToContent,
+  extractSession: () => extractSession,
+  parseFrontmatter: () => parseFrontmatter,
+  serializeFrontmatter: () => serializeFrontmatter
+});
+module.exports = __toCommonJS(session_exports);
+var os = __toESM(require("os"), 1);
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { frontmatter: void 0, body: content };
+  }
+  const yamlContent = match[1];
+  const body = content.slice(match[0].length);
+  try {
+    const frontmatter = parseSimpleYaml(yamlContent);
+    return { frontmatter, body };
+  } catch {
+    return { frontmatter: void 0, body: content };
+  }
+}
+function parseSimpleYaml(yaml) {
+  const lines = yaml.split("\n");
+  return parseYamlBlock(lines, 0, 0, lines.length).value;
+}
+function parseYamlBlock(lines, indent, startIdx, endIdx) {
+  const result = {};
+  let i = startIdx;
+  while (i < endIdx) {
+    const line = lines[i];
+    if (!line || !line.trim()) {
+      i++;
+      continue;
+    }
+    const lineIndent = getIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) {
+      i++;
+      continue;
+    }
+    const keyMatch = line.match(/^(\s*)([\w-]+):\s*(.*)?$/);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const [, , key, rawValue] = keyMatch;
+    const value = rawValue?.trim() ?? "";
+    if (value === "" || value === void 0) {
+      const nextNonEmpty = findNextNonEmptyLine(lines, i + 1, endIdx);
+      if (nextNonEmpty < endIdx) {
+        const nextLine = lines[nextNonEmpty];
+        const nextIndent = getIndent(nextLine);
+        if (nextIndent > indent) {
+          if (nextLine.trimStart().startsWith("- ")) {
+            const listResult = parseYamlList(lines, nextIndent, i + 1, endIdx);
+            result[key] = listResult.value;
+            i = listResult.nextIdx;
+          } else {
+            const blockResult = parseYamlBlock(lines, nextIndent, i + 1, endIdx);
+            result[key] = blockResult.value;
+            i = blockResult.nextIdx;
+          }
+          continue;
+        }
+      }
+      result[key] = null;
+      i++;
+    } else {
+      result[key] = parseYamlValue(value);
+      i++;
+    }
+  }
+  return { value: result, nextIdx: i };
+}
+function parseYamlList(lines, indent, startIdx, endIdx) {
+  const result = [];
+  let i = startIdx;
+  while (i < endIdx) {
+    const line = lines[i];
+    if (!line || !line.trim()) {
+      i++;
+      continue;
+    }
+    const lineIndent = getIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) {
+      i++;
+      continue;
+    }
+    const trimmed = line.trimStart();
+    if (!trimmed.startsWith("- ")) break;
+    const itemContent = trimmed.slice(2).trim();
+    if (itemContent === "" || itemContent === void 0) {
+      const nextNonEmpty = findNextNonEmptyLine(lines, i + 1, endIdx);
+      if (nextNonEmpty < endIdx) {
+        const nextIndent = getIndent(lines[nextNonEmpty]);
+        if (nextIndent > indent) {
+          const blockResult = parseYamlBlock(lines, nextIndent, i + 1, endIdx);
+          result.push(blockResult.value);
+          i = blockResult.nextIdx;
+          continue;
+        }
+      }
+      result.push(null);
+      i++;
+    } else {
+      const kvMatch = itemContent.match(/^([\w-]+):\s*(.*)$/);
+      if (kvMatch) {
+        const obj = {};
+        const [, firstKey, firstVal] = kvMatch;
+        obj[firstKey] = parseYamlValue(firstVal?.trim() ?? "");
+        const itemKeyIndent = indent + 2;
+        let j = i + 1;
+        while (j < endIdx) {
+          const nextLine = lines[j];
+          if (!nextLine || !nextLine.trim()) {
+            j++;
+            continue;
+          }
+          const nextLineIndent = getIndent(nextLine);
+          if (nextLineIndent < itemKeyIndent) break;
+          if (nextLineIndent === itemKeyIndent) {
+            const nextKv = nextLine.match(/^\s*([\w-]+):\s*(.*)$/);
+            if (nextKv) {
+              const [, nk, nv] = nextKv;
+              obj[nk] = parseYamlValue(nv?.trim() ?? "");
+              j++;
+              continue;
+            }
+          }
+          break;
+        }
+        result.push(obj);
+        i = j;
+      } else {
+        result.push(parseYamlValue(itemContent));
+        i++;
+      }
+    }
+  }
+  return { value: result, nextIdx: i };
+}
+function getIndent(line) {
+  const match = line.match(/^(\s*)/);
+  return match ? match[1].length : 0;
+}
+function findNextNonEmptyLine(lines, from, end) {
+  for (let i = from; i < end; i++) {
+    if (lines[i]?.trim()) return i;
+  }
+  return end;
+}
+function parseYamlValue(value) {
+  if (value === "") return null;
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "null" || value === "~") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  const num = Number(value);
+  if (!isNaN(num) && value !== "") return num;
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1);
+    if (inner.trim() === "") return [];
+    return inner.split(",").map((s) => parseYamlValue(s.trim()));
+  }
+  return value;
+}
+function serializeFrontmatter(frontmatter) {
+  const lines = ["---"];
+  if (frontmatter.id) {
+    lines.push(`id: ${frontmatter.id}`);
+  }
+  if (frontmatter.type) {
+    lines.push(`type: ${frontmatter.type}`);
+  }
+  if (frontmatter.session) {
+    lines.push("session:");
+    const session = frontmatter.session;
+    if (session.id) lines.push(`  id: ${session.id}`);
+    if (session.source) lines.push(`  source: ${session.source}`);
+    if (session.project) lines.push(`  project: ${formatPath(session.project)}`);
+    if (session.transcript) lines.push(`  transcript: ${formatPath(session.transcript)}`);
+  }
+  if (frontmatter.created) {
+    lines.push(`created: ${frontmatter.created}`);
+  }
+  if (frontmatter.updated) {
+    lines.push(`updated: ${frontmatter.updated}`);
+  }
+  if (frontmatter.tags && frontmatter.tags.length > 0) {
+    lines.push(`tags: [${frontmatter.tags.join(", ")}]`);
+  }
+  if (frontmatter.domain && frontmatter.domain.length > 0) {
+    lines.push(`domain: [${frontmatter.domain.join(", ")}]`);
+  }
+  if (frontmatter.entities && frontmatter.entities.length > 0) {
+    lines.push(`entities: [${frontmatter.entities.join(", ")}]`);
+  }
+  if (frontmatter.confidence !== void 0) {
+    lines.push(`confidence: ${frontmatter.confidence}`);
+  }
+  if (frontmatter.source) {
+    lines.push("source:");
+    if (frontmatter.source.origin) lines.push(`  origin: ${frontmatter.source.origin}`);
+    if (frontmatter.source.trajectories && frontmatter.source.trajectories.length > 0) {
+      lines.push(`  trajectories: [${frontmatter.source.trajectories.join(", ")}]`);
+    }
+    if (frontmatter.source.agentId) lines.push(`  agentId: ${frontmatter.source.agentId}`);
+  }
+  if (frontmatter.links && frontmatter.links.length > 0) {
+    lines.push("links:");
+    for (const link of frontmatter.links) {
+      lines.push(`  - target: ${link.target}`);
+      lines.push(`    relation: ${link.relation}`);
+      if (link.layer) lines.push(`    layer: ${link.layer}`);
+    }
+  }
+  if (frontmatter.supersedes !== void 0) {
+    lines.push(`supersedes: ${frontmatter.supersedes === null ? "~" : frontmatter.supersedes}`);
+  }
+  lines.push("---");
+  return lines.join("\n") + "\n";
+}
+function addFrontmatter(content, frontmatter) {
+  const { frontmatter: existing, body } = parseFrontmatter(content);
+  const merged = {
+    ...existing,
+    ...frontmatter,
+    session: {
+      ...existing?.session,
+      ...frontmatter.session
+    }
+  };
+  if (!merged.created) {
+    merged.created = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  merged.updated = (/* @__PURE__ */ new Date()).toISOString();
+  return serializeFrontmatter(merged) + body;
+}
+function addSessionToContent(content, session) {
+  return addFrontmatter(content, { session });
+}
+function formatPath(filePath) {
+  const home = os.homedir();
+  if (filePath.startsWith(home)) {
+    return "~" + filePath.slice(home.length);
+  }
+  return filePath;
+}
+function extractSession(content) {
+  const { frontmatter } = parseFrontmatter(content);
+  return frontmatter?.session;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addFrontmatter,
+  addSessionToContent,
+  extractSession,
+  parseFrontmatter,
+  serializeFrontmatter
+});
+//# sourceMappingURL=session.cjs.map