@kitakitsune/memoria 0.1.0

package/dist/chunk-R6AR3ICV.js

@@ -0,0 +1,931 @@
+// src/types.ts
+var MEMORY_TYPES = [
+  "fact",
+  "decision",
+  "lesson",
+  "commitment",
+  "preference",
+  "relationship",
+  "project"
+];
+var TYPE_TO_CATEGORY = {
+  fact: "facts",
+  decision: "decisions",
+  lesson: "lessons",
+  commitment: "commitments",
+  preference: "preferences",
+  relationship: "people",
+  project: "projects"
+};
+var DEFAULT_CATEGORIES = [
+  "decisions",
+  "preferences",
+  "lessons",
+  "facts",
+  "commitments",
+  "people",
+  "projects",
+  "inbox",
+  "sessions",
+  "observations"
+];
+
+// src/lib/config.ts
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var CONFIG_FILE = ".memoria.json";
+function configPath(vaultPath) {
+  return join(vaultPath, CONFIG_FILE);
+}
+async function readConfig(vaultPath) {
+  const raw = await readFile(configPath(vaultPath), "utf-8");
+  return JSON.parse(raw);
+}
+async function writeConfig(config) {
+  const filePath = configPath(config.path);
+  await writeFile(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+async function configExists(vaultPath) {
+  try {
+    await readFile(configPath(vaultPath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/document.ts
+import matter from "gray-matter";
+function parseDocument(raw, filePath, category) {
+  const { data, content } = matter(raw);
+  const id = filePath.replace(/\.md$/, "");
+  const tags = Array.isArray(data.tags) ? data.tags : [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id,
+    path: filePath,
+    category,
+    title: data.title || id.split("/").pop() || id,
+    content: content.trim(),
+    frontmatter: data,
+    tags,
+    created: data.created || now,
+    updated: data.updated || now
+  };
+}
+function serializeDocument(doc) {
+  const fm = {
+    title: doc.title,
+    ...doc.frontmatter
+  };
+  if (doc.type) fm.type = doc.type;
+  if (doc.tags && doc.tags.length > 0) fm.tags = doc.tags;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (!fm.created) fm.created = now;
+  fm.updated = now;
+  return matter.stringify(doc.content || "", fm);
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/lib/vault.ts
+import { mkdir, readFile as readFile2, writeFile as writeFile2, readdir, stat, unlink } from "fs/promises";
+import { join as join2, relative, extname, dirname } from "path";
+async function initVault(vaultPath, name, categories) {
+  const cats = categories || DEFAULT_CATEGORIES;
+  await mkdir(vaultPath, { recursive: true });
+  for (const cat of cats) {
+    await mkdir(join2(vaultPath, cat), { recursive: true });
+  }
+  await mkdir(join2(vaultPath, "sessions", "handoffs"), { recursive: true });
+  const config = {
+    path: vaultPath,
+    name,
+    categories: cats
+  };
+  await writeConfig(config);
+  return config;
+}
+async function resolveVault(startPath) {
+  const searchPath = startPath || process.cwd();
+  if (await configExists(searchPath)) {
+    return readConfig(searchPath);
+  }
+  const envPath = process.env.MEMORIA_VAULT;
+  if (envPath && await configExists(envPath)) {
+    return readConfig(envPath);
+  }
+  throw new Error(
+    `No Memoria vault found at "${searchPath}". Run "memoria init" first or set MEMORIA_VAULT.`
+  );
+}
+async function storeDocument(vaultPath, options) {
+  const slug = slugify(options.title);
+  const filePath = join2(vaultPath, options.category, `${slug}.md`);
+  const relPath = relative(vaultPath, filePath);
+  if (!options.overwrite) {
+    let exists = false;
+    try {
+      await stat(filePath);
+      exists = true;
+    } catch {
+    }
+    if (exists) {
+      throw new Error(`Document already exists: ${relPath}. Use --overwrite to replace.`);
+    }
+  }
+  const raw = serializeDocument({
+    title: options.title,
+    content: options.content,
+    frontmatter: options.frontmatter,
+    tags: options.frontmatter?.tags
+  });
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile2(filePath, raw, "utf-8");
+  return parseDocument(raw, relPath, options.category);
+}
+async function getDocument(vaultPath, id) {
+  let filePath = join2(vaultPath, id);
+  if (extname(filePath) !== ".md") filePath += ".md";
+  const raw = await readFile2(filePath, "utf-8");
+  const parts = relative(vaultPath, filePath).split("/");
+  const category = parts.length > 1 ? parts[0] : "inbox";
+  return parseDocument(raw, relative(vaultPath, filePath), category);
+}
+async function listDocuments(vaultPath, category) {
+  const config = await readConfig(vaultPath);
+  const categories = category ? [category] : config.categories;
+  const docs = [];
+  for (const cat of categories) {
+    const catDir = join2(vaultPath, cat);
+    let entries;
+    try {
+      entries = await readdir(catDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const filePath = join2(catDir, entry);
+      try {
+        const raw = await readFile2(filePath, "utf-8");
+        docs.push(parseDocument(raw, relative(vaultPath, filePath), cat));
+      } catch {
+        continue;
+      }
+    }
+  }
+  return docs;
+}
+async function deleteDocument(vaultPath, id) {
+  let filePath = join2(vaultPath, id);
+  if (extname(filePath) !== ".md") filePath += ".md";
+  await unlink(filePath);
+}
+
+// src/lib/search.ts
+import natural from "natural";
+var { TfIdf } = natural;
+function searchDocuments(docs, query, options = {}) {
+  const { limit = 10, minScore = 0.01, category, tags } = options;
+  let filtered = docs;
+  if (category) {
+    filtered = filtered.filter((d) => d.category === category);
+  }
+  if (tags && tags.length > 0) {
+    const lowerTags = tags.map((t) => t.toLowerCase());
+    filtered = filtered.filter(
+      (d) => lowerTags.some((lt) => d.tags.map((t) => t.toLowerCase()).includes(lt))
+    );
+  }
+  if (filtered.length === 0) return [];
+  const tfidf = new TfIdf();
+  for (const doc of filtered) {
+    const text = `${doc.title} ${doc.tags.join(" ")} ${doc.content}`;
+    tfidf.addDocument(text);
+  }
+  const scored = [];
+  tfidf.tfidfs(query, (i, measure) => {
+    if (measure > minScore) {
+      scored.push({ index: i, score: measure });
+    }
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const maxScore = scored.length > 0 ? scored[0].score : 1;
+  return scored.slice(0, limit).map(({ index, score }) => {
+    const doc = filtered[index];
+    const normalizedScore = maxScore > 0 ? score / maxScore : 0;
+    return {
+      document: doc,
+      score: normalizedScore,
+      snippet: extractSnippet(doc.content, query)
+    };
+  });
+}
+function extractSnippet(content, query, maxLen = 150) {
+  const lower = content.toLowerCase();
+  const terms = query.toLowerCase().split(/\s+/);
+  for (const term of terms) {
+    const idx = lower.indexOf(term);
+    if (idx !== -1) {
+      const start = Math.max(0, idx - 40);
+      const end = Math.min(content.length, idx + maxLen - 40);
+      let snippet = content.slice(start, end).trim();
+      if (start > 0) snippet = "..." + snippet;
+      if (end < content.length) snippet = snippet + "...";
+      return snippet;
+    }
+  }
+  return content.slice(0, maxLen).trim() + (content.length > maxLen ? "..." : "");
+}
+
+// src/lib/session.ts
+import { readFile as readFile3, writeFile as writeFile3, readdir as readdir2, mkdir as mkdir2 } from "fs/promises";
+import { join as join3 } from "path";
+import matter2 from "gray-matter";
+var SESSION_FILE = "sessions/current.md";
+var HANDOFFS_DIR = "sessions/handoffs";
+function sessionPath(vaultPath) {
+  return join3(vaultPath, SESSION_FILE);
+}
+function handoffsDir(vaultPath) {
+  return join3(vaultPath, HANDOFFS_DIR);
+}
+async function getSession(vaultPath) {
+  try {
+    const raw = await readFile3(sessionPath(vaultPath), "utf-8");
+    const { data } = matter2(raw);
+    return {
+      state: data.state || "idle",
+      startedAt: data.startedAt,
+      workingOn: data.workingOn,
+      focus: data.focus,
+      lastCheckpoint: data.lastCheckpoint
+    };
+  } catch {
+    return { state: "idle" };
+  }
+}
+async function saveSession(vaultPath, session) {
+  const content = session.workingOn ? `Currently working on: ${session.workingOn}` : "";
+  const fm = {};
+  for (const [key, val] of Object.entries(session)) {
+    if (val !== void 0) fm[key] = val;
+  }
+  const raw = matter2.stringify(content, fm);
+  await writeFile3(sessionPath(vaultPath), raw, "utf-8");
+}
+async function startSession(vaultPath) {
+  const session = {
+    state: "active",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveSession(vaultPath, session);
+  return session;
+}
+async function updateCheckpoint(vaultPath, workingOn, focus) {
+  const session = await getSession(vaultPath);
+  session.state = "active";
+  session.lastCheckpoint = (/* @__PURE__ */ new Date()).toISOString();
+  if (workingOn) session.workingOn = workingOn;
+  if (focus) session.focus = focus;
+  await saveSession(vaultPath, session);
+  return session;
+}
+async function endSession(vaultPath, summary, nextSteps) {
+  const session = await getSession(vaultPath);
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().slice(0, 10);
+  const handoff = {
+    created: now.toISOString(),
+    summary,
+    workingOn: session.workingOn,
+    focus: session.focus,
+    nextSteps
+  };
+  const dir = handoffsDir(vaultPath);
+  await mkdir2(dir, { recursive: true });
+  const handoffContent = matter2.stringify(
+    [
+      `## Summary
+${summary}`,
+      session.workingOn ? `## Working On
+${session.workingOn}` : "",
+      session.focus ? `## Focus
+${session.focus}` : "",
+      nextSteps ? `## Next Steps
+${nextSteps}` : ""
+    ].filter(Boolean).join("\n\n"),
+    {
+      created: handoff.created,
+      type: "handoff"
+    }
+  );
+  const handoffPath = join3(dir, `${dateStr}.md`);
+  await writeFile3(handoffPath, handoffContent, "utf-8");
+  const idleSession = { state: "idle" };
+  await saveSession(vaultPath, idleSession);
+  return handoff;
+}
+async function getRecentHandoffs(vaultPath, limit = 3) {
+  const dir = handoffsDir(vaultPath);
+  let entries;
+  try {
+    entries = await readdir2(dir);
+  } catch {
+    return [];
+  }
+  const mdFiles = entries.filter((e) => e.endsWith(".md")).sort().reverse();
+  const handoffs = [];
+  for (const file of mdFiles.slice(0, limit)) {
+    try {
+      const raw = await readFile3(join3(dir, file), "utf-8");
+      const { data, content } = matter2(raw);
+      handoffs.push({
+        created: data.created || file.replace(".md", ""),
+        summary: content.trim(),
+        workingOn: data.workingOn,
+        focus: data.focus,
+        nextSteps: data.nextSteps
+      });
+    } catch {
+      continue;
+    }
+  }
+  return handoffs;
+}
+
+// src/lib/notion-client.ts
+import { Client } from "@notionhq/client";
+function createNotionClient(token) {
+  return new Client({ auth: token });
+}
+async function createCategoryDatabase(client, parentPageId, categoryName) {
+  return client.databases.create({
+    parent: { type: "page_id", page_id: parentPageId },
+    title: [{ type: "text", text: { content: categoryName } }],
+    properties: {
+      Title: { title: {} },
+      Type: { select: { options: [] } },
+      Tags: { multi_select: { options: [] } },
+      Created: { date: {} },
+      Updated: { date: {} }
+    }
+  });
+}
+async function createNotionPage(client, databaseId, title, properties, children) {
+  const props = {
+    Title: { title: [{ text: { content: title } }] }
+  };
+  if (properties.type) {
+    props.Type = { select: { name: properties.type } };
+  }
+  if (properties.tags && properties.tags.length > 0) {
+    props.Tags = {
+      multi_select: properties.tags.map((t) => ({ name: t }))
+    };
+  }
+  if (properties.created) {
+    props.Created = { date: { start: properties.created } };
+  }
+  if (properties.updated) {
+    props.Updated = { date: { start: properties.updated } };
+  }
+  const result = await client.pages.create({
+    parent: { database_id: databaseId },
+    properties: props,
+    children: children || []
+  });
+  return { id: result.id };
+}
+async function updateNotionPage(client, pageId, properties) {
+  const props = {};
+  if (properties.title) {
+    props.Title = { title: [{ text: { content: properties.title } }] };
+  }
+  if (properties.type) {
+    props.Type = { select: { name: properties.type } };
+  }
+  if (properties.tags) {
+    props.Tags = {
+      multi_select: properties.tags.map((t) => ({ name: t }))
+    };
+  }
+  if (properties.updated) {
+    props.Updated = { date: { start: properties.updated } };
+  }
+  await client.pages.update({
+    page_id: pageId,
+    properties: props
+  });
+}
+async function replacePageContent(client, pageId, children) {
+  const existing = await client.blocks.children.list({ block_id: pageId });
+  for (const block of existing.results) {
+    await client.blocks.delete({ block_id: block.id });
+  }
+  if (children.length > 0) {
+    await client.blocks.children.append({
+      block_id: pageId,
+      children
+    });
+  }
+}
+async function queryDatabase(client, databaseId, lastSyncAt) {
+  const filter = lastSyncAt ? {
+    timestamp: "last_edited_time",
+    last_edited_time: { after: lastSyncAt }
+  } : void 0;
+  return client.databases.query({
+    database_id: databaseId,
+    filter
+  });
+}
+async function getPageBlocks(client, pageId) {
+  const blocks = [];
+  let cursor;
+  do {
+    const response = await client.blocks.children.list({
+      block_id: pageId,
+      start_cursor: cursor
+    });
+    blocks.push(...response.results);
+    cursor = response.has_more ? response.next_cursor ?? void 0 : void 0;
+  } while (cursor);
+  return blocks;
+}
+
+// src/lib/notion-converter.ts
+function markdownToBlocks(markdown) {
+  const lines = markdown.split("\n");
+  const blocks = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const h1 = line.match(/^# (.+)$/);
+    if (h1) {
+      blocks.push({
+        object: "block",
+        type: "heading_1",
+        heading_1: { rich_text: parseInlineMarkdown(h1[1]) }
+      });
+      i++;
+      continue;
+    }
+    const h2 = line.match(/^## (.+)$/);
+    if (h2) {
+      blocks.push({
+        object: "block",
+        type: "heading_2",
+        heading_2: { rich_text: parseInlineMarkdown(h2[1]) }
+      });
+      i++;
+      continue;
+    }
+    const h3 = line.match(/^### (.+)$/);
+    if (h3) {
+      blocks.push({
+        object: "block",
+        type: "heading_3",
+        heading_3: { rich_text: parseInlineMarkdown(h3[1]) }
+      });
+      i++;
+      continue;
+    }
+    if (line.match(/^```/)) {
+      const langMatch = line.match(/^```(\w*)$/);
+      const language = langMatch?.[1] || "plain text";
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].match(/^```$/)) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      blocks.push({
+        object: "block",
+        type: "code",
+        code: {
+          rich_text: [{ type: "text", text: { content: codeLines.join("\n") } }],
+          language: mapLanguage(language)
+        }
+      });
+      continue;
+    }
+    if (line.match(/^> /)) {
+      const quoteLines = [];
+      while (i < lines.length && lines[i].match(/^> /)) {
+        quoteLines.push(lines[i].replace(/^> /, ""));
+        i++;
+      }
+      blocks.push({
+        object: "block",
+        type: "quote",
+        quote: { rich_text: parseInlineMarkdown(quoteLines.join("\n")) }
+      });
+      continue;
+    }
+    if (line.match(/^[-*] /)) {
+      blocks.push({
+        object: "block",
+        type: "bulleted_list_item",
+        bulleted_list_item: { rich_text: parseInlineMarkdown(line.replace(/^[-*] /, "")) }
+      });
+      i++;
+      continue;
+    }
+    const numMatch = line.match(/^\d+\. (.+)$/);
+    if (numMatch) {
+      blocks.push({
+        object: "block",
+        type: "numbered_list_item",
+        numbered_list_item: { rich_text: parseInlineMarkdown(numMatch[1]) }
+      });
+      i++;
+      continue;
+    }
+    if (line.match(/^(-{3,}|_{3,}|\*{3,})$/)) {
+      blocks.push({
+        object: "block",
+        type: "divider",
+        divider: {}
+      });
+      i++;
+      continue;
+    }
+    blocks.push({
+      object: "block",
+      type: "paragraph",
+      paragraph: { rich_text: parseInlineMarkdown(line) }
+    });
+    i++;
+  }
+  return blocks;
+}
+function blocksToMarkdown(blocks) {
+  const lines = [];
+  for (const block of blocks) {
+    const b = block;
+    const type = b.type;
+    switch (type) {
+      case "paragraph":
+        lines.push(richTextToMarkdown(getBlockRichText(b, "paragraph")));
+        lines.push("");
+        break;
+      case "heading_1":
+        lines.push(`# ${richTextToMarkdown(getBlockRichText(b, "heading_1"))}`);
+        lines.push("");
+        break;
+      case "heading_2":
+        lines.push(`## ${richTextToMarkdown(getBlockRichText(b, "heading_2"))}`);
+        lines.push("");
+        break;
+      case "heading_3":
+        lines.push(`### ${richTextToMarkdown(getBlockRichText(b, "heading_3"))}`);
+        lines.push("");
+        break;
+      case "bulleted_list_item":
+        lines.push(`- ${richTextToMarkdown(getBlockRichText(b, "bulleted_list_item"))}`);
+        break;
+      case "numbered_list_item":
+        lines.push(`1. ${richTextToMarkdown(getBlockRichText(b, "numbered_list_item"))}`);
+        break;
+      case "code": {
+        const codeData = b.code;
+        const lang = codeData.language || "";
+        const text = richTextToMarkdown(
+          codeData.rich_text || []
+        );
+        lines.push(`\`\`\`${lang}`);
+        lines.push(text);
+        lines.push("```");
+        lines.push("");
+        break;
+      }
+      case "quote":
+        lines.push(
+          richTextToMarkdown(getBlockRichText(b, "quote")).split("\n").map((l) => `> ${l}`).join("\n")
+        );
+        lines.push("");
+        break;
+      case "divider":
+        lines.push("---");
+        lines.push("");
+        break;
+      default:
+        break;
+    }
+  }
+  return lines.join("\n").trim();
+}
+function getBlockRichText(block, type) {
+  const data = block[type];
+  return data?.rich_text || [];
+}
+function parseInlineMarkdown(text) {
+  const items = [];
+  const regex = /(\*\*(.+?)\*\*|__(.+?)__|_(.+?)_|\*(.+?)\*|`(.+?)`|\[(.+?)\]\((.+?)\))/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      items.push({
+        type: "text",
+        text: { content: text.slice(lastIndex, match.index) }
+      });
+    }
+    if (match[2] || match[3]) {
+      items.push({
+        type: "text",
+        text: { content: match[2] || match[3] },
+        annotations: { bold: true }
+      });
+    } else if (match[4] || match[5]) {
+      items.push({
+        type: "text",
+        text: { content: match[4] || match[5] },
+        annotations: { italic: true }
+      });
+    } else if (match[6]) {
+      items.push({
+        type: "text",
+        text: { content: match[6] },
+        annotations: { code: true }
+      });
+    } else if (match[7] && match[8]) {
+      items.push({
+        type: "text",
+        text: { content: match[7], link: { url: match[8] } }
+      });
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    items.push({
+      type: "text",
+      text: { content: text.slice(lastIndex) }
+    });
+  }
+  if (items.length === 0) {
+    items.push({ type: "text", text: { content: text } });
+  }
+  return items;
+}
+function richTextToMarkdown(richText) {
+  return richText.map((item) => {
+    let text = item.text.content;
+    const a = item.annotations;
+    if (a?.bold) text = `**${text}**`;
+    if (a?.italic) text = `_${text}_`;
+    if (a?.code) text = `\`${text}\``;
+    if (item.text.link?.url) text = `[${text}](${item.text.link.url})`;
+    return text;
+  }).join("");
+}
+function mapLanguage(lang) {
+  const map = {
+    js: "javascript",
+    ts: "typescript",
+    py: "python",
+    rb: "ruby",
+    sh: "bash",
+    yml: "yaml",
+    "": "plain text"
+  };
+  return map[lang] || lang;
+}
+
+// src/lib/sync-state.ts
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { join as join4 } from "path";
+var SYNC_STATE_FILE = ".sync-state.json";
+function syncStatePath(vaultPath) {
+  return join4(vaultPath, SYNC_STATE_FILE);
+}
+async function readSyncState(vaultPath) {
+  try {
+    const raw = await readFile4(syncStatePath(vaultPath), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {
+      lastSyncAt: "",
+      databases: {},
+      entries: {}
+    };
+  }
+}
+async function writeSyncState(vaultPath, state) {
+  await writeFile4(
+    syncStatePath(vaultPath),
+    JSON.stringify(state, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function getEntry(state, localPath) {
+  return state.entries[localPath];
+}
+function setEntry(state, localPath, entry) {
+  state.entries[localPath] = entry;
+}
+
+// src/lib/notion-sync.ts
+import { writeFile as writeFile5, readFile as readFile5 } from "fs/promises";
+import { join as join5 } from "path";
+async function ensureDatabases(client, config, state) {
+  const rootPageId = config.notion.rootPageId;
+  for (const category of config.categories) {
+    if (state.databases[category]) continue;
+    try {
+      const db = await createCategoryDatabase(client, rootPageId, category);
+      state.databases[category] = db.id;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!msg.includes("already exists")) {
+        throw err;
+      }
+    }
+  }
+  return state;
+}
+async function pushToNotion(client, config, options = {}) {
+  const report = { pushed: [], pulled: [], conflicts: [], errors: [] };
+  const state = await readSyncState(config.path);
+  await ensureDatabases(client, config, state);
+  const docs = await listDocuments(config.path);
+  for (const doc of docs) {
+    const dbId = state.databases[doc.category];
+    if (!dbId) {
+      report.errors.push(`${doc.path}: no Notion database for category "${doc.category}"`);
+      continue;
+    }
+    const existing = getEntry(state, doc.path);
+    const blocks = markdownToBlocks(doc.content);
+    try {
+      if (existing) {
+        if (doc.updated <= existing.localUpdatedAt) continue;
+        if (!options.dryRun) {
+          await updateNotionPage(client, existing.notionPageId, {
+            title: doc.title,
+            type: doc.frontmatter.type,
+            tags: doc.tags,
+            updated: doc.updated
+          });
+          await replacePageContent(client, existing.notionPageId, blocks);
+        }
+        setEntry(state, doc.path, {
+          ...existing,
+          localUpdatedAt: doc.updated,
+          lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else {
+        if (!options.dryRun) {
+          const page = await createNotionPage(client, dbId, doc.title, {
+            type: doc.frontmatter.type,
+            tags: doc.tags,
+            created: doc.created,
+            updated: doc.updated
+          }, blocks);
+          setEntry(state, doc.path, {
+            localPath: doc.path,
+            notionPageId: page.id,
+            lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            localUpdatedAt: doc.updated,
+            notionUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }
+      report.pushed.push(doc.path);
+    } catch (err) {
+      report.errors.push(`${doc.path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (!options.dryRun) {
+    state.lastSyncAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeSyncState(config.path, state);
+  }
+  return report;
+}
+async function pullFromNotion(client, config, options = {}) {
+  const report = { pushed: [], pulled: [], conflicts: [], errors: [] };
+  const state = await readSyncState(config.path);
+  await ensureDatabases(client, config, state);
+  for (const [category, dbId] of Object.entries(state.databases)) {
+    try {
+      const response = await queryDatabase(client, dbId, state.lastSyncAt || void 0);
+      for (const page of response.results) {
+        const pageAny = page;
+        const pageId = pageAny.id;
+        const lastEdited = pageAny.last_edited_time;
+        const props = pageAny.properties;
+        const titleProp = props.Title;
+        const titleArr = titleProp?.title;
+        const title = titleArr?.[0]?.plain_text || "untitled";
+        const typeProp = props.Type;
+        const typeSelect = typeProp?.select;
+        const type = typeSelect?.name;
+        const tagsProp = props.Tags;
+        const tagsArr = tagsProp?.multi_select;
+        const tags = tagsArr?.map((t) => t.name) || [];
+        const existingEntry = Object.values(state.entries).find(
+          (e) => e.notionPageId === pageId
+        );
+        if (existingEntry) {
+          const localPath = join5(config.path, existingEntry.localPath);
+          let localRaw;
+          try {
+            localRaw = await readFile5(localPath, "utf-8");
+          } catch {
+            localRaw = "";
+          }
+          if (localRaw) {
+            const localDoc = parseDocument(localRaw, existingEntry.localPath, category);
+            if (localDoc.updated > existingEntry.localUpdatedAt && !options.preferNotion) {
+              report.conflicts.push(existingEntry.localPath);
+              continue;
+            }
+          }
+          if (!options.dryRun) {
+            const blocks = await getPageBlocks(client, pageId);
+            const content = blocksToMarkdown(blocks);
+            const fm = { title };
+            if (type) fm.type = type;
+            if (tags.length > 0) fm.tags = tags;
+            const raw = serializeDocument({ title, content, frontmatter: fm, tags });
+            await writeFile5(localPath, raw, "utf-8");
+            setEntry(state, existingEntry.localPath, {
+              ...existingEntry,
+              lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              notionUpdatedAt: lastEdited,
+              localUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          report.pulled.push(existingEntry.localPath);
+        } else {
+          const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+          const relPath = `${category}/${slug}.md`;
+          const filePath = join5(config.path, relPath);
+          if (!options.dryRun) {
+            const blocks = await getPageBlocks(client, pageId);
+            const content = blocksToMarkdown(blocks);
+            const fm = { title };
+            if (type) fm.type = type;
+            if (tags.length > 0) fm.tags = tags;
+            const raw = serializeDocument({ title, content, frontmatter: fm, tags });
+            await writeFile5(filePath, raw, "utf-8");
+            setEntry(state, relPath, {
+              localPath: relPath,
+              notionPageId: pageId,
+              lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              localUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              notionUpdatedAt: lastEdited
+            });
+          }
+          report.pulled.push(relPath);
+        }
+      }
+    } catch (err) {
+      report.errors.push(`${category}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (!options.dryRun) {
+    state.lastSyncAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeSyncState(config.path, state);
+  }
+  return report;
+}
+
+export {
+  MEMORY_TYPES,
+  TYPE_TO_CATEGORY,
+  DEFAULT_CATEGORIES,
+  readConfig,
+  writeConfig,
+  configExists,
+  parseDocument,
+  serializeDocument,
+  slugify,
+  initVault,
+  resolveVault,
+  storeDocument,
+  getDocument,
+  listDocuments,
+  deleteDocument,
+  searchDocuments,
+  getSession,
+  startSession,
+  updateCheckpoint,
+  endSession,
+  getRecentHandoffs,
+  createNotionClient,
+  markdownToBlocks,
+  blocksToMarkdown,
+  readSyncState,
+  writeSyncState,
+  pushToNotion,
+  pullFromNotion
+};