@bennys001/claude-code-memory 0.9.7

package/dist/index.js

@@ -0,0 +1,1242 @@
+#!/usr/bin/env bun
+// @bun
+// package.json
+var package_default = {
+  name: "@bennys001/claude-code-memory",
+  publishConfig: { access: "public" },
+  version: "0.9.7",
+  description: "MCP server that gives Claude Code persistent memory via an Obsidian knowledge vault",
+  module: "dist/index.js",
+  main: "dist/index.js",
+  type: "module",
+  repository: {
+    type: "git",
+    url: "https://github.com/Ben-Spn/claude-code-memory.git"
+  },
+  bugs: {
+    url: "https://github.com/Ben-Spn/claude-code-memory/issues"
+  },
+  homepage: "https://github.com/Ben-Spn/claude-code-memory?tab=readme-ov-file#claude-code-memory-ccm",
+  scripts: {
+    prepare: "husky",
+    build: "bunup",
+    prepublishOnly: "bun run build"
+  },
+  bin: {
+    ccm: "dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  devDependencies: {
+    "@types/bun": "1.3.9",
+    "@types/dompurify": "3.2.0",
+    "@types/mozilla-readability": "0.2.1",
+    "@types/turndown": "5.0.6",
+    bunup: "0.16.31",
+    husky: "9.1.7"
+  },
+  peerDependencies: {
+    typescript: "5.9.3"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "1.27.1",
+    "@mozilla/readability": "0.6.0",
+    dompurify: "3.3.1",
+    globby: "16.1.1",
+    "gray-matter": "4.0.3",
+    linkedom: "0.18.12",
+    "smol-toml": "1.6.0",
+    tiktoken: "1.0.22",
+    turndown: "7.2.2",
+    zod: "4.3.6"
+  }
+};
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { homedir as homedir4 } from "os";
+import { join as join7 } from "path";
+
+// src/vault/loader.ts
+import { globby } from "globby";
+
+// src/vault/parser.ts
+import matter from "gray-matter";
+import { get_encoding } from "tiktoken";
+
+// src/vault/types.ts
+import { z } from "zod";
+var NoteType = z.enum(["gotcha", "decision", "pattern", "reference"]);
+var NOTE_TYPE_ICONS = {
+  gotcha: "\uD83D\uDD34",
+  decision: "\uD83D\uDFE4",
+  pattern: "\uD83D\uDD35",
+  reference: "\uD83D\uDFE2"
+};
+var NOTE_TYPE_PRIORITY = {
+  gotcha: 0,
+  decision: 1,
+  pattern: 2,
+  reference: 3
+};
+var NoteFrontmatter = z.object({
+  type: NoteType,
+  projects: z.array(z.string()).default([]),
+  tags: z.array(z.string()).default([]),
+  created: z.coerce.date(),
+  updated: z.coerce.date(),
+  title: z.string().optional()
+});
+var ProjectConfigSchema = z.object({
+  project: z.object({
+    name: z.string()
+  }).optional(),
+  filter: z.object({
+    tags: z.array(z.string()).optional(),
+    types: z.array(NoteType).optional(),
+    exclude: z.array(z.string()).optional()
+  }).optional()
+});
+
+// src/vault/parser.ts
+import { relative, basename } from "path";
+var encoder = get_encoding("cl100k_base");
+function countTokens(text) {
+  if (!text)
+    return 0;
+  return encoder.encode(text).length;
+}
+function extractTitle(frontmatter, content, filePath) {
+  if (frontmatter.title)
+    return frontmatter.title;
+  const headingMatch = content.match(/^#\s+(.+)$/m);
+  if (headingMatch)
+    return headingMatch[1].trim();
+  return basename(filePath, ".md");
+}
+async function parseNote(filePath, vaultPath) {
+  const raw = await Bun.file(filePath).text();
+  const { data, content } = matter(raw);
+  const result = NoteFrontmatter.safeParse(data);
+  if (!result.success) {
+    console.error(`Skipping ${relative(vaultPath, filePath)}: invalid frontmatter`);
+    return null;
+  }
+  const body = content.trim();
+  return {
+    frontmatter: result.data,
+    filePath,
+    relativePath: relative(vaultPath, filePath),
+    title: extractTitle(data, content, filePath),
+    body,
+    tokenCount: countTokens(body)
+  };
+}
+
+// src/vault/loader.ts
+async function discoverFiles(vaultPath) {
+  return globby("**/*.md", {
+    cwd: vaultPath,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/.*/**"]
+  });
+}
+async function loadVault(vaultPath) {
+  const files = await discoverFiles(vaultPath);
+  const results = await Promise.all(files.map((f) => parseNote(f, vaultPath)));
+  return results.filter((entry) => entry !== null).sort((a, b) => NOTE_TYPE_PRIORITY[a.frontmatter.type] - NOTE_TYPE_PRIORITY[b.frontmatter.type]);
+}
+function matchesGlob(path, pattern) {
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regex}$`).test(path);
+}
+function filterEntries(entries, config) {
+  if (!config?.filter)
+    return entries;
+  const { tags, types, exclude } = config.filter;
+  return entries.filter((entry) => {
+    if (types?.length && !types.includes(entry.frontmatter.type))
+      return false;
+    if (tags?.length && !entry.frontmatter.tags.some((t) => tags.includes(t)))
+      return false;
+    if (exclude?.length && exclude.some((pattern) => matchesGlob(entry.relativePath, pattern)))
+      return false;
+    return true;
+  });
+}
+
+// src/tools/index-tool.ts
+import { z as z2 } from "zod";
+
+// src/index-engine/index.ts
+function formatTokenCount(count) {
+  return `~${Math.round(count / 10) * 10}`;
+}
+function toIndexEntry(entry) {
+  return {
+    icon: NOTE_TYPE_ICONS[entry.frontmatter.type],
+    title: entry.title,
+    relativePath: entry.relativePath,
+    tokenDisplay: formatTokenCount(entry.tokenCount)
+  };
+}
+function buildIndexTable(entries) {
+  if (entries.length === 0) {
+    return "No knowledge entries match the current filters.";
+  }
+  const headers = ["T", "Title", "Path", "~Tok"];
+  const rows = entries.map((e) => {
+    const idx = toIndexEntry(e);
+    return [idx.icon, idx.title, idx.relativePath, idx.tokenDisplay];
+  });
+  const colWidths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+  const padRow = (cells) => "| " + cells.map((c, i) => c.padEnd(colWidths[i])).join(" | ") + " |";
+  const separator = "|" + colWidths.map((w) => "-".repeat(w + 2)).join("|") + "|";
+  return [padRow(headers), separator, ...rows.map(padRow)].join(`
+`);
+}
+function formatKnowledgeSection(entries) {
+  const table = buildIndexTable(entries);
+  return [
+    "## Knowledge Index",
+    "Use MCP tool `read` with the note path to fetch full details on demand.",
+    "\uD83D\uDD34 = gotcha  \uD83D\uDFE4 = decision  \uD83D\uDD35 = pattern  \uD83D\uDFE2 = reference",
+    "",
+    table
+  ].join(`
+`);
+}
+function injectKnowledgeSection(existingContent, entries) {
+  const newSection = formatKnowledgeSection(entries);
+  const sectionStart = existingContent.indexOf("## Knowledge Index");
+  if (sectionStart === -1) {
+    return newSection + `
+
+` + existingContent.trimStart();
+  }
+  const beforeSection = existingContent.substring(0, sectionStart);
+  const afterSectionStart = existingContent.indexOf(`
+## `, sectionStart + "## Knowledge Index".length);
+  const rest = afterSectionStart === -1 ? beforeSection.trimEnd() : (beforeSection + existingContent.substring(afterSectionStart + 1)).trimStart();
+  return rest ? newSection + `
+
+` + rest : newSection + `
+`;
+}
+
+// src/tools/index-tool.ts
+function executeIndex(args, entries) {
+  let filtered = entries;
+  if (args.project) {
+    filtered = filtered.filter((e) => e.frontmatter.projects.includes(args.project));
+  }
+  return buildIndexTable(filtered);
+}
+function registerIndexTool(server, entries) {
+  server.registerTool("index", {
+    description: "Return the compressed knowledge index table for the current project or vault",
+    inputSchema: z2.object({
+      project: z2.string().optional().describe("Filter to notes tagged with this project name")
+    })
+  }, async (args) => {
+    const result = executeIndex(args, entries);
+    return { content: [{ type: "text", text: result }] };
+  });
+}
+
+// src/tools/read-tool.ts
+import { resolve, relative as relative2 } from "path";
+import { z as z3 } from "zod";
+async function executeRead(notePath, vaultPath) {
+  if (notePath.startsWith("/")) {
+    return { ok: false, error: "Absolute paths not allowed. Use paths relative to vault root." };
+  }
+  const resolved = resolve(vaultPath, notePath);
+  const rel = relative2(vaultPath, resolved);
+  if (rel.startsWith("..")) {
+    return { ok: false, error: "Path resolves outside vault. Use paths relative to vault root." };
+  }
+  const file = Bun.file(resolved);
+  if (!await file.exists()) {
+    return { ok: false, error: `Note not found: ${notePath}. Run the 'index' tool to see available notes.` };
+  }
+  return { ok: true, content: await file.text() };
+}
+function registerReadTool(server, vaultPath) {
+  server.registerTool("read", {
+    description: "[Deprecated \u2014 prefer 'research' tool which returns full note content in one call] Fetch full content of a vault note by its relative path",
+    inputSchema: z3.object({
+      path: z3.string().describe("Relative path within vault (e.g. gotchas/bevy-system-ordering.md)")
+    })
+  }, async ({ path }) => {
+    const result = await executeRead(path, vaultPath);
+    if (result.ok) {
+      return { content: [{ type: "text", text: result.content }] };
+    }
+    return { content: [{ type: "text", text: result.error }], isError: true };
+  });
+}
+
+// src/tools/search-tool.ts
+import { z as z4 } from "zod";
+function scoreEntry(entry, keywords) {
+  let score = 0;
+  const titleLower = entry.title.toLowerCase();
+  const tagsLower = entry.frontmatter.tags.map((t) => t.toLowerCase());
+  const bodyLower = entry.body.toLowerCase();
+  for (const kw of keywords) {
+    const kwLower = kw.toLowerCase();
+    if (titleLower.includes(kwLower))
+      score += 10;
+    if (tagsLower.some((t) => t.includes(kwLower)))
+      score += 5;
+    if (bodyLower.includes(kwLower))
+      score += 1;
+  }
+  return score;
+}
+function executeSearch(args, entries) {
+  let filtered = entries.slice();
+  if (args.types?.length) {
+    filtered = filtered.filter((e) => args.types.includes(e.frontmatter.type));
+  }
+  if (args.tags?.length) {
+    filtered = filtered.filter((e) => e.frontmatter.tags.some((t) => args.tags.includes(t)));
+  }
+  const keywords = args.query.split(/\s+/).filter(Boolean);
+  if (keywords.length === 0)
+    return [];
+  const scored = filtered.map((entry) => ({
+    icon: NOTE_TYPE_ICONS[entry.frontmatter.type],
+    title: entry.title,
+    type: entry.frontmatter.type,
+    relativePath: entry.relativePath,
+    tokenDisplay: formatTokenCount(entry.tokenCount),
+    score: scoreEntry(entry, keywords)
+  })).filter((r) => r.score > 0).sort((a, b) => b.score - a.score);
+  const limit = args.limit ?? 10;
+  return scored.slice(0, limit);
+}
+function registerSearchTool(server, entries) {
+  server.registerTool("search", {
+    description: "[Deprecated \u2014 prefer 'research' tool which returns full note content in one call] Keyword search across vault notes. Returns index entries only.",
+    inputSchema: z4.object({
+      query: z4.string().describe("Space-separated keywords to search for"),
+      types: z4.array(NoteType).optional().describe("Filter to these note types"),
+      tags: z4.array(z4.string()).optional().describe("Filter to notes with these tags"),
+      limit: z4.number().optional().describe("Max results (default 10)")
+    })
+  }, async (args) => {
+    const results = executeSearch(args, entries);
+    if (results.length === 0) {
+      return { content: [{ type: "text", text: "No notes match that query." }] };
+    }
+    const table = [
+      "| T | Title | Path | ~Tok | Score |",
+      "|---|-------|------|------|-------|",
+      ...results.map((r) => `| ${r.icon} | ${r.title} | ${r.relativePath} | ${r.tokenDisplay} | ${r.score} |`)
+    ].join(`
+`);
+    return { content: [{ type: "text", text: table }] };
+  });
+}
+
+// src/tools/sync-tool.ts
+import { z as z5 } from "zod";
+import { join as join3, resolve as resolve2 } from "path";
+import { homedir } from "os";
+
+// src/vault/config.ts
+import { parse, stringify } from "smol-toml";
+import { join as join2, basename as basename2, extname } from "path";
+var {Glob } = globalThis.Bun;
+var EXT_TO_TAGS = {
+  rs: ["rust"],
+  ts: ["typescript"],
+  tsx: ["typescript", "react"],
+  js: ["javascript"],
+  jsx: ["javascript", "react"],
+  vue: ["vue"],
+  py: ["python"],
+  go: ["go"],
+  rb: ["ruby"],
+  java: ["java"],
+  kt: ["kotlin"],
+  scala: ["scala"],
+  cs: ["csharp"],
+  cpp: ["cpp"],
+  cc: ["cpp"],
+  cxx: ["cpp"],
+  c: ["c"],
+  h: ["c"],
+  swift: ["swift"],
+  dart: ["dart", "flutter"],
+  ex: ["elixir"],
+  exs: ["elixir"],
+  zig: ["zig"],
+  hs: ["haskell"],
+  php: ["php"],
+  lua: ["lua"]
+};
+var IGNORE_DIRS = ["node_modules", ".*", "target", "dist", "build"];
+async function loadProjectConfig(dir) {
+  const configPath = join2(dir, ".context.toml");
+  const file = Bun.file(configPath);
+  if (!await file.exists())
+    return null;
+  try {
+    const raw = await file.text();
+    const parsed = parse(raw);
+    const result = ProjectConfigSchema.safeParse(parsed);
+    if (!result.success) {
+      console.error(`Warning: Invalid .context.toml in ${dir}`);
+      return null;
+    }
+    return result.data;
+  } catch {
+    console.error(`Warning: Failed to parse .context.toml in ${dir}`);
+    return null;
+  }
+}
+function collectVaultTags(entries) {
+  const tags = new Set;
+  for (const entry of entries) {
+    for (const tag of entry.frontmatter.tags) {
+      tags.add(tag);
+    }
+  }
+  return tags;
+}
+async function detectTagsFromExtensions(dir, vaultTags) {
+  const glob = new Glob(`**/*.*`);
+  const extensions = new Set;
+  for await (const path of glob.scan({ cwd: dir, dot: false, followSymlinks: false })) {
+    const skip = IGNORE_DIRS.some((d) => d.startsWith(".") ? path.startsWith(".") : path.startsWith(d + "/"));
+    if (skip)
+      continue;
+    const ext = extname(path).slice(1).toLowerCase();
+    if (ext)
+      extensions.add(ext);
+  }
+  const candidates = new Set;
+  for (const ext of extensions) {
+    const tags = EXT_TO_TAGS[ext];
+    if (tags) {
+      for (const tag of tags)
+        candidates.add(tag);
+    }
+  }
+  return [...candidates].filter((t) => vaultTags.has(t)).sort();
+}
+async function createDefaultConfig(dir, allEntries) {
+  const config = { project: { name: basename2(dir) } };
+  if (allEntries) {
+    const vaultTags = collectVaultTags(allEntries);
+    const inferred = await detectTagsFromExtensions(dir, vaultTags);
+    if (inferred.length > 0) {
+      config.filter = { tags: inferred };
+    }
+  }
+  const configPath = join2(dir, ".context.toml");
+  await Bun.write(configPath, stringify(config) + `
+`);
+  return config;
+}
+
+// src/tools/sync-tool.ts
+var TECH_TAGS = new Set([
+  "bash",
+  "c",
+  "clojure",
+  "cpp",
+  "csharp",
+  "css",
+  "dart",
+  "elixir",
+  "erlang",
+  "fsharp",
+  "go",
+  "haskell",
+  "html",
+  "java",
+  "javascript",
+  "kotlin",
+  "lua",
+  "ocaml",
+  "perl",
+  "php",
+  "python",
+  "ruby",
+  "rust",
+  "scala",
+  "sql",
+  "swift",
+  "typescript",
+  "zig",
+  "angular",
+  "astro",
+  "bevy",
+  "django",
+  "docker",
+  "electron",
+  "express",
+  "fastapi",
+  "fastify",
+  "flask",
+  "flutter",
+  "gatsby",
+  "gin",
+  "godot",
+  "htmx",
+  "kubernetes",
+  "laravel",
+  "nestjs",
+  "nextjs",
+  "nuxt",
+  "rails",
+  "react",
+  "react-native",
+  "remix",
+  "solid",
+  "spring",
+  "svelte",
+  "tailwind",
+  "tauri",
+  "unity",
+  "unreal",
+  "vue",
+  "bun",
+  "deno",
+  "node",
+  "nodejs"
+]);
+function hasTechTag(entry) {
+  return entry.frontmatter.tags.some((t) => TECH_TAGS.has(t));
+}
+function extractTableEntries(content) {
+  const sectionStart = content.indexOf("## Knowledge Index");
+  if (sectionStart === -1)
+    return null;
+  let sectionEnd = content.indexOf(`
+## `, sectionStart + "## Knowledge Index".length);
+  const section = sectionEnd === -1 ? content.substring(sectionStart) : content.substring(sectionStart, sectionEnd);
+  const tableLines = section.split(`
+`).filter((line) => line.startsWith("|"));
+  if (tableLines.length < 2)
+    return null;
+  return tableLines.slice(2).map((row) => row.split("|").slice(1, -1).map((c) => c.trim()).join("|"));
+}
+function buildEntryFingerprint(entries) {
+  return entries.map((e) => {
+    const idx = toIndexEntry(e);
+    return [idx.icon, idx.title, idx.relativePath, idx.tokenDisplay].join("|");
+  });
+}
+async function syncToFile(claudeMdPath, filtered) {
+  const totalTokens = filtered.reduce((sum, e) => sum + e.tokenCount, 0);
+  const file = Bun.file(claudeMdPath);
+  const existing = await file.exists() ? await file.text() : "";
+  if (existing) {
+    const sectionAtTop = existing.trimStart().startsWith("## Knowledge Index");
+    const existingEntries = extractTableEntries(existing);
+    if (sectionAtTop && existingEntries !== null && existingEntries.join(`
+`) === buildEntryFingerprint(filtered).join(`
+`)) {
+      return { entryCount: filtered.length, totalTokens, changed: false };
+    }
+  }
+  const updated = existing ? injectKnowledgeSection(existing, filtered) : formatKnowledgeSection(filtered) + `
+`;
+  await Bun.write(claudeMdPath, updated);
+  return { entryCount: filtered.length, totalTokens, changed: true };
+}
+async function executeSync(targetDir, allEntries, vaultPath, options = {}) {
+  let config = await loadProjectConfig(targetDir);
+  let autoCreated = false;
+  const globalClaudeDir = options.globalClaudeDir ?? resolve2(homedir(), ".claude");
+  const isGlobalDir = resolve2(targetDir) === resolve2(globalClaudeDir);
+  if (!config && !isGlobalDir) {
+    config = await createDefaultConfig(targetDir, allEntries);
+    autoCreated = true;
+  }
+  const filterConfig = config?.filter ? { ...config, filter: { ...config.filter, tags: undefined } } : config;
+  let filtered = filterEntries(allEntries, filterConfig);
+  const projectName = config?.project?.name;
+  const filterTags = config?.filter?.tags;
+  if (projectName) {
+    filtered = filtered.filter((e) => e.frontmatter.projects.includes(projectName) || e.frontmatter.projects.length === 0 && filterTags?.length !== undefined && filterTags.length > 0 && e.frontmatter.tags.some((t) => filterTags.includes(t)));
+  } else {
+    filtered = filtered.filter((e) => e.frontmatter.projects.length === 0 && !hasTechTag(e));
+  }
+  const { entryCount, totalTokens, changed } = await syncToFile(join3(targetDir, "CLAUDE.md"), filtered);
+  let summary = changed ? `Synced ${entryCount} entries to CLAUDE.md (${formatTokenCount(totalTokens)} total index tokens)` : `CLAUDE.md already up to date (${entryCount} entries, ${formatTokenCount(totalTokens)} total index tokens)`;
+  if (autoCreated) {
+    const allTags = [...new Set(allEntries.flatMap((e) => e.frontmatter.tags))].sort();
+    const inferredTags = config?.filter?.tags;
+    if (inferredTags?.length) {
+      summary += `
+Auto-created .context.toml with inferred tags: [${inferredTags.join(", ")}]`;
+    } else {
+      summary += `
+Auto-created .context.toml (no tags inferred from file extensions)`;
+    }
+    if (allTags.length > 0) {
+      summary += `
+Available vault tags: [${allTags.join(", ")}] \u2014 edit .context.toml filter.tags to refine`;
+    }
+  }
+  if (!isGlobalDir) {
+    const globalEntries = allEntries.filter((e) => e.frontmatter.projects.length === 0 && !hasTechTag(e));
+    const globalResult = await syncToFile(join3(globalClaudeDir, "CLAUDE.md"), globalEntries);
+    summary += globalResult.changed ? `
+Synced ${globalResult.entryCount} global entries to ~/.claude/CLAUDE.md (${formatTokenCount(globalResult.totalTokens)} total index tokens)` : `
+~/.claude/CLAUDE.md already up to date (${globalResult.entryCount} entries, ${formatTokenCount(globalResult.totalTokens)} total index tokens)`;
+  }
+  return {
+    entryCount,
+    totalTokens,
+    summary
+  };
+}
+function registerSyncTool(server, entries, vaultPath) {
+  server.registerTool("sync", {
+    description: "Generate or update the Knowledge Index section in a project's CLAUDE.md",
+    inputSchema: z5.object({
+      targetDir: z5.string().optional().describe("Project directory (defaults to server CWD)")
+    })
+  }, async ({ targetDir }) => {
+    const dir = targetDir ?? process.cwd();
+    const result = await executeSync(dir, entries, vaultPath);
+    return { content: [{ type: "text", text: result.summary }] };
+  });
+}
+
+// src/tools/write-tool.ts
+import { resolve as resolve3, relative as relative3, dirname } from "path";
+import { mkdir } from "fs/promises";
+import { z as z6 } from "zod";
+
+// src/utils.ts
+function formatDate(date) {
+  return date.toISOString().slice(0, 10);
+}
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m"
+};
+
+// src/tools/write-tool.ts
+function buildFrontmatter(args) {
+  const lines = ["---", `type: ${args.type}`];
+  if (args.projects?.length) {
+    lines.push("projects:");
+    for (const p of args.projects)
+      lines.push(`  - ${p}`);
+  }
+  if (args.tags?.length) {
+    lines.push("tags:");
+    for (const t of args.tags)
+      lines.push(`  - ${t}`);
+  }
+  lines.push(`created: ${args.date}`, `updated: ${args.date}`, "---");
+  return lines.join(`
+`);
+}
+async function executeWrite(args, entries, vaultPath) {
+  if (args.path.startsWith("/")) {
+    return { ok: false, error: "Absolute paths not allowed. Use paths relative to vault root." };
+  }
+  const resolved = resolve3(vaultPath, args.path);
+  const rel = relative3(vaultPath, resolved);
+  if (rel.startsWith("..")) {
+    return { ok: false, error: "Path resolves outside vault. Use paths relative to vault root." };
+  }
+  if (await Bun.file(resolved).exists()) {
+    return { ok: false, error: `File already exists: ${args.path}. Use a different path.` };
+  }
+  const today = formatDate(new Date);
+  const frontmatter = buildFrontmatter({
+    type: args.type,
+    tags: args.tags,
+    projects: args.projects,
+    date: today
+  });
+  const content = `${frontmatter}
+
+# ${args.title}
+
+${args.body}
+`;
+  await mkdir(dirname(resolved), { recursive: true });
+  await Bun.write(resolved, content);
+  const entry = await parseNote(resolved, vaultPath);
+  if (entry) {
+    entries.push(entry);
+    entries.sort((a, b) => NOTE_TYPE_PRIORITY[a.frontmatter.type] - NOTE_TYPE_PRIORITY[b.frontmatter.type]);
+  }
+  return { ok: true, path: rel };
+}
+function registerWriteTool(server, entries, vaultPath) {
+  server.registerTool("write", {
+    description: "Create a new note in the vault with structured frontmatter. " + "Rejects writes to existing paths. " + "To write a web page to the vault, first use the fetch-page tool.",
+    inputSchema: z6.object({
+      path: z6.string().describe("Relative path within vault (e.g. gotchas/my-new-note.md)"),
+      type: NoteType.describe("Note type"),
+      title: z6.string().describe("Note title (becomes the H1 heading)"),
+      body: z6.string().describe("Markdown body content (after the H1)"),
+      tags: z6.array(z6.string()).optional().describe("Searchable tags"),
+      projects: z6.array(z6.string()).optional().describe("Project names this note relates to")
+    })
+  }, async (args) => {
+    const result = await executeWrite(args, entries, vaultPath);
+    if (result.ok) {
+      return { content: [{ type: "text", text: `Created note: ${result.path}` }] };
+    }
+    return { content: [{ type: "text", text: result.error }], isError: true };
+  });
+}
+
+// src/tools/fetch-page-tool.ts
+import { join as join4 } from "path";
+import { mkdtemp, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { z as z7 } from "zod";
+
+// src/web/fetcher.ts
+import { Readability } from "@mozilla/readability";
+import { parseHTML } from "linkedom";
+import DOMPurify from "dompurify";
+import TurndownService from "turndown";
+function convertHTMLToMarkdown(html, url) {
+  const window = parseHTML(html);
+  if (!window.document?.documentElement) {
+    throw new Error(`Could not extract readable content from ${url}`);
+  }
+  const purify = DOMPurify(window);
+  const cleanHTML = purify.sanitize(window.document.documentElement.outerHTML, {
+    WHOLE_DOCUMENT: true
+  });
+  const cleanWindow = parseHTML(cleanHTML);
+  const reader = new Readability(cleanWindow.document, {
+    charThreshold: 0
+  });
+  const article = reader.parse();
+  if (!article?.content) {
+    throw new Error(`Could not extract readable content from ${url}`);
+  }
+  const turndown = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced"
+  });
+  const markdown = turndown.turndown(article.content);
+  return {
+    title: article.title ?? "",
+    markdown,
+    siteName: article.siteName ?? null,
+    excerpt: article.excerpt ?? null
+  };
+}
+async function fetchPageAsMarkdown(url) {
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "claude-code-memory/1.0 (vault note fetcher)"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("text/html")) {
+    throw new Error(`Expected text/html but got ${contentType}`);
+  }
+  const html = await response.text();
+  return convertHTMLToMarkdown(html, url);
+}
+
+// src/tools/fetch-page-tool.ts
+async function executeFetchPage(url, fetcher = fetchPageAsMarkdown) {
+  let page;
+  try {
+    page = await fetcher(url);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Failed to fetch URL: ${msg}` };
+  }
+  const tempDir = await mkdtemp(join4(tmpdir(), "ccm-fetch-"));
+  const tempPath = join4(tempDir, "page.md");
+  await writeFile(tempPath, page.markdown);
+  return {
+    ok: true,
+    tempPath,
+    title: page.title,
+    excerpt: page.excerpt,
+    siteName: page.siteName
+  };
+}
+function registerFetchPageTool(server) {
+  server.registerTool("fetch-page", {
+    description: "Fetch a web page and convert it to markdown. " + "Returns a temp file path containing the raw markdown. " + "After calling this tool, read the temp file, clean up the markdown, " + "pick appropriate title/tags/type, then call the write tool to save to the vault.",
+    inputSchema: z7.object({
+      url: z7.url().describe("URL of the web page to fetch")
+    })
+  }, async (args) => {
+    const result = await executeFetchPage(args.url);
+    if (result.ok) {
+      const parts = [
+        `Temp file: ${result.tempPath}`,
+        `Title: ${result.title}`
+      ];
+      if (result.excerpt)
+        parts.push(`Excerpt: ${result.excerpt}`);
+      if (result.siteName)
+        parts.push(`Site: ${result.siteName}`);
+      return { content: [{ type: "text", text: parts.join(`
+`) }] };
+    }
+    return { content: [{ type: "text", text: result.error }], isError: true };
+  });
+}
+
+// src/tools/research-tool.ts
+import { z as z8 } from "zod";
+function buildResearchOutput(result) {
+  const lines = [];
+  const countLabel = result.truncated ? `${result.notes.length} notes (truncated to ~${result.maxTokenBudget} tokens)` : `${result.notes.length} notes`;
+  lines.push(`## Research Results (${countLabel})`, "", result.table);
+  for (const note of result.notes) {
+    lines.push("", "---", `### ${note.relativePath}`, "", note.content);
+  }
+  return lines.join(`
+`);
+}
+async function executeResearch(args, entries, vaultPath) {
+  const searchResults = executeSearch({ query: args.query, types: args.types, tags: args.tags, limit: args.limit }, entries);
+  if (searchResults.length === 0) {
+    return { table: "", notes: [], totalTokens: 0, truncated: false };
+  }
+  const table = [
+    "| T | Title | Path | ~Tok | Score |",
+    "|---|-------|------|------|-------|",
+    ...searchResults.map((r) => `| ${r.icon} | ${r.title} | ${r.relativePath} | ${r.tokenDisplay} | ${r.score} |`)
+  ].join(`
+`);
+  const notes = [];
+  let totalTokens = 0;
+  let truncated = false;
+  const maxTokens = args.maxTokens ?? Infinity;
+  for (const result of searchResults) {
+    const entry = entries.find((e) => e.relativePath === result.relativePath);
+    if (!entry)
+      continue;
+    if (totalTokens + entry.tokenCount > maxTokens && notes.length > 0) {
+      truncated = true;
+      break;
+    }
+    const readResult = await executeRead(result.relativePath, vaultPath);
+    if (!readResult.ok)
+      continue;
+    notes.push({ relativePath: result.relativePath, content: readResult.content });
+    totalTokens += entry.tokenCount;
+  }
+  return { table, notes, totalTokens, truncated, maxTokenBudget: args.maxTokens };
+}
+function registerResearchTool(server, entries, vaultPath) {
+  server.registerTool("research", {
+    description: "Batched search+read: finds matching notes and returns their full content in a single call. " + "Use this instead of search \u2192 read chains to reduce round-trips.",
+    inputSchema: z8.object({
+      query: z8.string().describe("Space-separated keywords to search for"),
+      types: z8.array(NoteType).optional().describe("Filter to these note types"),
+      tags: z8.array(z8.string()).optional().describe("Filter to notes with these tags"),
+      limit: z8.number().optional().describe("Max results (default 10)"),
+      maxTokens: z8.number().optional().describe("Token budget \u2014 stops including note bodies once exceeded")
+    })
+  }, async (args) => {
+    const result = await executeResearch(args, entries, vaultPath);
+    if (result.notes.length === 0) {
+      return { content: [{ type: "text", text: "No notes match that query." }] };
+    }
+    return { content: [{ type: "text", text: buildResearchOutput(result) }] };
+  });
+}
+
+// src/cli/init.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { join as join6 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/cli/seed.ts
+var OFM_NOTE = (date) => `---
+type: pattern
+tags:
+  - obsidian
+  - markdown
+  - formatting
+created: ${date}
+updated: ${date}
+---
+
+# Obsidian Flavored Markdown Conventions
+
+Follow these conventions when writing vault notes to ensure compatibility with Obsidian.
+
+## Links
+
+Use wikilinks, not markdown links:
+
+\`\`\`markdown
+[[Note Name]]
+[[Note Name|Display Text]]
+[[Note Name#Heading]]
+[[Note Name#^block-id]]
+\`\`\`
+
+## Embeds
+
+\`\`\`markdown
+![[Note Name]]
+![[Note Name#Heading]]
+![[image.png|300]]
+\`\`\`
+
+## Callouts
+
+Use callouts for important information:
+
+\`\`\`markdown
+> [!note]
+> General information.
+
+> [!warning] Watch Out
+> Something to be careful about.
+
+> [!tip]- Collapsed by default
+> Hidden until expanded.
+\`\`\`
+
+Common types: \`note\`, \`tip\`, \`warning\`, \`danger\`, \`info\`, \`example\`, \`quote\`, \`bug\`, \`todo\`
+
+## Highlights
+
+Use \`==double equals==\` for emphasis instead of bold when marking key terms.
+
+## Tags
+
+Use \`#tag\` or \`#nested/tag\` inline. In frontmatter, use a YAML list under \`tags:\`.
+
+## Block References
+
+Add \`^block-id\` at the end of a paragraph to make it linkable:
+
+\`\`\`markdown
+This paragraph can be referenced elsewhere. ^my-block
+
+Then link to it: [[Note Name#^my-block]]
+\`\`\`
+
+## Comments
+
+Use \`%%\` for content hidden in reading view:
+
+\`\`\`markdown
+Visible text %%hidden comment%% more visible text.
+\`\`\`
+
+## Properties
+
+Frontmatter uses YAML. Common fields:
+
+\`\`\`yaml
+---
+title: Note Title
+tags:
+  - tag1
+  - tag2
+aliases:
+  - Alternative Name
+---
+\`\`\`
+`;
+var NOTE_TEMPLATE = `---
+type:
+tags:
+  -
+projects:
+  -
+created:
+updated:
+---
+
+# Title
+
+Body content here.
+`;
+function buildSeedNotes(dateStr) {
+  return [
+    { relativePath: "patterns/obsidian-flavored-markdown.md", content: OFM_NOTE(dateStr) },
+    { relativePath: "_templates/note.md", content: NOTE_TEMPLATE }
+  ];
+}
+
+// src/cli/obsidian.ts
+import { readFile, writeFile as writeFile2, copyFile } from "fs/promises";
+import { join as join5 } from "path";
+import { randomBytes } from "crypto";
+import { homedir as homedir2 } from "os";
+var DEFAULT_CONFIG_PATH = join5(homedir2(), ".config/obsidian/obsidian.json");
+function generateVaultId() {
+  return randomBytes(8).toString("hex");
+}
+async function loadObsidianConfig(configPath = DEFAULT_CONFIG_PATH) {
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function findVaultByPath(config, vaultPath) {
+  for (const [id, vault] of Object.entries(config.vaults)) {
+    if (vault.path === vaultPath)
+      return id;
+  }
+  return null;
+}
+async function registerVaultWithObsidian(vaultPath, configPath = DEFAULT_CONFIG_PATH) {
+  const config = await loadObsidianConfig(configPath);
+  if (!config) {
+    return { skipped: true, reason: "Obsidian not installed (config not found)" };
+  }
+  const existingId = findVaultByPath(config, vaultPath);
+  if (existingId) {
+    return { skipped: true, reason: "Vault already registered", vaultId: existingId };
+  }
+  await copyFile(configPath, `${configPath}.backup`);
+  const vaultId = generateVaultId();
+  config.vaults[vaultId] = {
+    path: vaultPath,
+    ts: Date.now(),
+    open: true
+  };
+  await writeFile2(configPath, JSON.stringify(config, null, 2));
+  return { registered: true, vaultId };
+}
+
+// src/cli/claude-code.ts
+import { spawn } from "child_process";
+import { resolve as resolvePath } from "path";
+function buildServerCommand() {
+  const runtime = resolvePath(process.argv[0]);
+  const script = resolvePath(process.argv[1]);
+  return [runtime, script, "--stdio"];
+}
+function buildRegisterArgs(serverCmd) {
+  return [
+    "mcp",
+    "add",
+    "--transport",
+    "stdio",
+    "--scope",
+    "user",
+    "ccm",
+    "--",
+    ...serverCmd
+  ];
+}
+function formatManualCommand(serverCmd) {
+  return `claude mcp add --transport stdio --scope user ccm -- ${serverCmd.join(" ")}`;
+}
+function registerMcpServer() {
+  const serverCmd = buildServerCommand();
+  const registerArgs = buildRegisterArgs(serverCmd);
+  const manualCommand = formatManualCommand(serverCmd);
+  return new Promise((resolve4) => {
+    let stdout = "";
+    let stderr = "";
+    const proc = spawn("claude", registerArgs, { stdio: "pipe" });
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        resolve4({
+          success: false,
+          error: "Claude CLI not found in PATH",
+          manualCommand
+        });
+      } else {
+        resolve4({
+          success: false,
+          error: err.message,
+          manualCommand
+        });
+      }
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve4({ success: true, output: (stdout || stderr).trim() });
+      } else {
+        resolve4({
+          success: false,
+          error: (stderr || stdout).trim() || `Process exited with code ${code}`,
+          manualCommand
+        });
+      }
+    });
+  });
+}
+
+// src/cli/init.ts
+var VAULT_PATH = join6(homedir3(), ".ccm", "knowledge-base");
+var SUBDIRS = ["gotchas", "decisions", "patterns", "references", "_templates"];
+async function executeInit() {
+  const steps = [];
+  await mkdir2(VAULT_PATH, { recursive: true });
+  steps.push({ name: "vault directory", status: "created", detail: VAULT_PATH });
+  for (const sub of SUBDIRS) {
+    await mkdir2(join6(VAULT_PATH, sub), { recursive: true });
+  }
+  steps.push({ name: "subdirectories", status: "created", detail: SUBDIRS.join(", ") });
+  const dotObsidian = join6(VAULT_PATH, ".obsidian");
+  await mkdir2(dotObsidian, { recursive: true });
+  const dateStr = formatDate(new Date);
+  const seedNotes = buildSeedNotes(dateStr);
+  for (const note of seedNotes) {
+    const fullPath = join6(VAULT_PATH, note.relativePath);
+    const file = Bun.file(fullPath);
+    if (await file.exists()) {
+      steps.push({ name: note.relativePath, status: "skipped", detail: "already exists" });
+    } else {
+      await mkdir2(join6(VAULT_PATH, note.relativePath, ".."), { recursive: true });
+      await Bun.write(fullPath, note.content);
+      steps.push({ name: note.relativePath, status: "created", detail: "" });
+    }
+  }
+  const obsidianResult = await registerVaultWithObsidian(VAULT_PATH);
+  if ("registered" in obsidianResult) {
+    steps.push({
+      name: "Obsidian registration",
+      status: "created",
+      detail: `vault ID: ${obsidianResult.vaultId}`
+    });
+  } else {
+    steps.push({
+      name: "Obsidian registration",
+      status: "skipped",
+      detail: obsidianResult.reason
+    });
+  }
+  const mcpResult = await registerMcpServer();
+  if (mcpResult.success) {
+    steps.push({ name: "Claude Code MCP", status: "created", detail: mcpResult.output });
+  } else {
+    steps.push({
+      name: "Claude Code MCP",
+      status: "failed",
+      detail: `${mcpResult.error}
+  Run manually: ${mcpResult.manualCommand}`
+    });
+  }
+  return { vaultPath: VAULT_PATH, steps };
+}
+function formatStep(step) {
+  const icons = {
+    created: `${C.green}+${C.reset}`,
+    skipped: `${C.yellow}-${C.reset}`,
+    failed: `${C.red}!${C.reset}`
+  };
+  const detail = step.detail ? ` ${C.dim}(${step.detail})${C.reset}` : "";
+  return `  ${icons[step.status]} ${step.name}${detail}`;
+}
+function formatInitSummary(result) {
+  const lines = [
+    `${C.bold}ccm init${C.reset}`,
+    `${C.dim}vault:${C.reset} ${result.vaultPath}`,
+    "",
+    ...result.steps.map(formatStep)
+  ];
+  const created = result.steps.filter((s) => s.status === "created").length;
+  const skipped = result.steps.filter((s) => s.status === "skipped").length;
+  const failed = result.steps.filter((s) => s.status === "failed").length;
+  lines.push("");
+  if (failed > 0) {
+    lines.push(`${C.red}${created} created, ${skipped} skipped, ${failed} failed${C.reset}`);
+  } else {
+    lines.push(`${C.green}${created} created${C.reset}, ${skipped} skipped`);
+  }
+  return lines.join(`
+`);
+}
+
+// src/index.ts
+var VAULT_PATH2 = join7(homedir4(), ".ccm", "knowledge-base");
+function parseCliArgs() {
+  const args = process.argv.slice(2);
+  if (args.includes("--init"))
+    return "init";
+  if (args.includes("--stdio"))
+    return "serve";
+  return "help";
+}
+function printHelp() {
+  console.log(`${C.bold}ccm${C.reset} ${C.dim}\u2014 persistent memory for Claude Code${C.reset}
+
+${C.bold}Usage:${C.reset}
+  ${C.cyan}ccm --init${C.reset}    Scaffold vault and register MCP server
+
+${C.dim}Vault:${C.reset} ~/.ccm/knowledge-base/
+${C.dim}Docs:${C.reset}  https://github.com/bennys001/claude-code-memory`);
+}
+async function runInit() {
+  const result = await executeInit();
+  console.log(formatInitSummary(result));
+  const failed = result.steps.filter((s) => s.status === "failed").length;
+  process.exit(failed > 0 ? 1 : 0);
+}
+async function runServer() {
+  const entries = await loadVault(VAULT_PATH2);
+  console.error(`Loaded ${entries.length} notes from ${VAULT_PATH2}`);
+  const server = new McpServer({
+    name: "ccm",
+    version: package_default.version
+  });
+  registerIndexTool(server, entries);
+  registerReadTool(server, VAULT_PATH2);
+  registerSearchTool(server, entries);
+  registerSyncTool(server, entries, VAULT_PATH2);
+  registerWriteTool(server, entries, VAULT_PATH2);
+  registerFetchPageTool(server);
+  registerResearchTool(server, entries, VAULT_PATH2);
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  const shutdown = async () => {
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+var cli = parseCliArgs();
+if (cli === "help") {
+  printHelp();
+  process.exit(0);
+} else if (cli === "init") {
+  runInit().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+  });
+} else {
+  runServer().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+  });
+}